# libtmux for Ruby
> The Ruby library (libtmux). These pages include its guides, tested examples and API documentation.
- [Ruby API reference](https://libtmux.org/en/ruby/v0.1.0.alpha.3/reference/): every public symbol, generated from the source. Hosted on libtmux.org.
---
# libtmux-workspace CLI manual
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/
> Commands, options and exit statuses for the Ruby workspace CLI.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
`libtmux-workspace` validates a YAML or JSON configuration, shows its creation
plan, and applies it to an explicitly selected tmux server. Install the
workspace gem using the [workspace installation instructions](https://libtmux.org/en/ruby/v0.1.0.alpha.3/).
## Commands
validate- Check the configuration without contacting tmux or running commands.
plan- Inspect ordered creation operations, optionally using a live snapshot.
load- Create a new session on an existing server selected by socket path.
## Input and common options
Pass one configuration file after the options. If you omit the file, discovery
requires exactly one of [`.tmuxp.yaml`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/validate/), [`.tmuxp.yml`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/validate/), or
[`.tmuxp.json`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/validate/) in the current directory. Missing or ambiguous
input exits with status `2`.
| Option | Behavior |
| --- | --- |
| `--json` | Write one JSON result or error to stdout. |
| `--expand-environment` | Expand `${NAME}` in configured paths and environment values using explicit [`--env`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#input-and-common-options-env-name-value) values. Shell command text stays unchanged. |
| `--env NAME=VALUE` | Supply an expansion value. Repeat for different names; duplicate names are invalid. Ambient environment variables are not the expansion map. |
| `-h`, `--help` | Show commands and options without reading a file or contacting tmux. |
| `--version` | Show the installed gem version without reading a file or contacting tmux. |
Show the installed command's options:
```console
$ libtmux-workspace --help
```
Check the installed version:
```console
$ libtmux-workspace --version
```
The command pages explain `--socket`, `--live`, `--timeout`, `--compensate`,
`--attach`, and `--switch`, including which commands accept them.
## Output and exit statuses
Successful human-readable results go to stdout. Human-readable errors go to
stderr; an application failure can also include its partial creation ledger
there. With [`--json`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#input-and-common-options-json), both results and errors go to stdout as JSON. Check the
exit status as well as the output.
| Status | Meaning |
| --- | --- |
| `0` | The requested operation succeeded. |
| `1` | Execution failed before recorded application effects. |
| `2` | Arguments or configuration are invalid. |
| `3` | Application effects are partial or uncertain, or a post-load attach or switch failed. |
| `130` | The operation was interrupted or cancelled. |
A successful load confirms that the creation operations completed and shell
commands were dispatched. It does not establish that the programs in those
panes have completed. A failed load can leave a session behind; inspect its
result before retrying.
[CLI parser and implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-workspace/lib/libtmux/workspace/cli.rb).
---
# validate
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/validate/
> Check a Ruby workspace configuration without contacting tmux.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
`validate` reads and checks a YAML or JSON workspace without starting tmux,
opening a socket, creating a session, or running configured shell commands.
Use it before inspecting or applying a plan.
## Check a workspace
Save the [complete example configuration](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/examples/) as [`workspace.yaml`](),
then validate it:
```console
$ libtmux-workspace validate workspace.yaml
```
Success prints `Workspace configuration is valid.` and exits with status `0`.
To request a JSON result:
```console
$ libtmux-workspace validate \
--json \
workspace.yaml
```
The result contains `valid`, `profile`, and `version`. Invalid configuration
exits with status `2`. In JSON mode, the error object is written to stdout;
otherwise diagnostics go to stderr.
## Options and limits
The [common options](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#input-and-common-options) control output and explicit
environment expansion. Omit the filename only when the current directory
contains exactly one discoverable configuration. `--socket`, `--live`,
`--attach`, `--switch`, and `--compensate` are invalid for validation.
Validation checks the [supported configuration format](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/topics/). It does
not prove that a session name is free on a server, a shell command will
succeed, or a program is installed. Use [live planning](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/#inspect-a-live-server)
to inspect the chosen server, and check [load results](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/#results-and-failures)
when applying the workspace.
[CLI parser and implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-workspace/lib/libtmux/workspace/cli.rb).
---
# plan
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/
> Inspect the ordered operations needed to create a Ruby workspace.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
`plan` lists the ordered creation operations without applying them. By
default it reads only the configuration. It does not contact tmux or execute
the workspace's shell commands.
## Inspect an offline plan
Save the [complete example configuration](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/examples/) as [`workspace.yaml`](),
then inspect its plan:
```console
$ libtmux-workspace plan \
--json \
workspace.yaml
```
The JSON result includes configured command text and paths. Treat it as
application data, not a redacted diagnostic. Without [`--json`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#input-and-common-options-json), the output
lists the mode, step count, and each step's operation, target, and effect.
## Inspect a live server
`--live` acquires a snapshot from an existing server before planning. It
requires `--socket PATH`; passing a socket without `--live` is invalid.
Use the private server prepared in the [load walkthrough](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/#create-a-workspace):
```console
$ libtmux-workspace plan \
--live \
--socket "$WORKSPACE_TMP/tmux.sock" \
--json \
workspace.yaml
```
Run this before loading the workspace. The manager creates new sessions; it
does not reconcile an existing session with the file. A live snapshot describes
the server when captured, so inspect the later load result rather than assuming
the server stayed unchanged.
## Options and failures
`--timeout SECONDS` bounds the live snapshot operation. It defaults to `5` and
must be finite and positive. The [common options](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#input-and-common-options)
control file discovery, JSON output, and explicit environment expansion.
`--attach`, `--switch`, and `--compensate` are invalid for planning.
Invalid arguments or configuration return status `2`. An unavailable live
server returns an execution error. See [exit statuses](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#output-and-exit-statuses)
before using a plan in automation.
[CLI parser and implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-workspace/lib/libtmux/workspace/cli.rb).
---
# load
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/
> Create a Ruby workspace on an explicitly selected existing tmux server.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
`load` applies a creation plan to an existing server selected by [`--socket`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/#options-socket-path).
It creates a new session and leaves it detached by default. It does not
reconcile, replace, or delete a preexisting workspace.
## Create a workspace
Install tmux and the workspace gem using the [installation instructions](https://libtmux.org/en/ruby/v0.1.0.alpha.3/),
then save the [complete example configuration](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/examples/) as
[`workspace.yaml`](). Run these commands in the same POSIX shell.
Create a temporary directory for this example's private socket:
```console
$ WORKSPACE_TMP=$(mktemp -d)
```
Start a private server with a keepalive session and no user configuration:
```console
$ tmux \
-S "$WORKSPACE_TMP/tmux.sock" \
-f /dev/null \
new-session -d -s manual-keepalive
```
Load the workspace on that socket:
```console
$ libtmux-workspace load \
--socket "$WORKSPACE_TMP/tmux.sock" \
--json \
workspace.yaml
```
The result records completed steps, effects, and created references. Inspect
the example's `work` session:
```console
$ tmux \
-S "$WORKSPACE_TMP/tmux.sock" \
list-windows -t work
```
This lists the `editor` window. When finished, stop only the private server:
```console
$ tmux -S "$WORKSPACE_TMP/tmux.sock" kill-server
```
Remove the private socket and temporary directory after stopping the server:
```console
$ rm -rf "$WORKSPACE_TMP"
```
## Options
| Option | Behavior |
| --- | --- |
| `--socket PATH` | Required path to an existing server's socket. Relative paths resolve from the current directory. |
| `--timeout SECONDS` | Finite positive time budget shared by preflight and all creation steps; defaults to `5`. A post-load client switch receives a separate budget of the same length. This option does not bound terminal attachment. |
| `--compensate` | Attempt guarded cleanup of positively identified created resources after application failure. It cannot undo shell effects. |
| `--attach` | Attach this CLI's terminal after loading. Requires `/dev/tty` and a valid `TERM`. |
| `--switch CLIENT` | Switch the explicitly named current client to the created session after loading. There is no fallback client selection. |
[`--attach`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/#options-attach) and [`--switch`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/#options-switch-client) are mutually exclusive. `--live` belongs to [`plan`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/)
and is invalid for `load`. The [common options](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#input-and-common-options)
cover JSON output, file discovery, and explicit environment expansion.
## Results and failures
Success means that the creation operations completed and configured shell
commands were dispatched. It does not mean those programs finished or became
ready. Inspect their output or use an application-specific readiness signal.
A failed operation can leave completed steps in place. The result retains
created references and effects for inspection; do not retry blindly. The
default preserves partial state. [`--compensate`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/#options-compensate) attempts cleanup only when
ownership can be established.
If post-load attachment or switching fails, the created session and its ledger
remain available and the command returns status `3`. Read the [exit statuses](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#output-and-exit-statuses)
when using JSON output in a script.
[CLI parser and implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-workspace/lib/libtmux/workspace/cli.rb).
[Apply deadline](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-workspace/lib/libtmux/workspace/apply.rb).
---
# Async
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/
> Run concurrent commands within an owned Async scope.
Run libtmux operations inside an application-owned Async task: a
[subprocess facade][async-server], [ordered mapping][async-scope-map],
[control replies][guardedreply] and
[event subscriptions][async-controlsubscription].
[API reference](https://libtmux.org/en/ruby/latest/reference/libtmux-async/) ·
[Guide](https://libtmux.org/en/ruby/latest/guides/async/) ·
[RubyGems](https://rubygems.org/gems/libtmux-async)
Part of [libtmux for Ruby](https://github.com/libtmux/libtmux-ruby#readme).
Built on [libtmux](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux).
Imports start no scheduler, tmux server or background task. A scope borrows a
core [`Server`][server] and leaves its daemon running when the scope exits.
**Contents** — [Quick start](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/#quick-start) ·
[Cancel](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/#cancel-a-request-without-stalling-the-others) ·
[Map](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/#keep-results-ordered-and-bounded) ·
[Control](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/#read-control-events-in-a-scope) ·
[Leaves out](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/#what-it-leaves-out) · [Support](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/#support-and-status) ·
[Documentation](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/#documentation)
## Quick start
Install the alpha. It needs Ruby 3.3 or newer and tmux 3.3a or newer on
`PATH`:
```console
$ gem install libtmux-async --pre
```
Open a scope over a core server with [`LibTmux::Async.open`][async-open], then
capture every pane concurrently with [`Scope#map`][async-scope-map]. The outer
[`Server.start`][server-start] block only supplies a server for the scope to
borrow:
```ruby
require "libtmux"
require "libtmux/async"
LibTmux::Server.start do |server|
server.new_session(name: "work", command: ["/bin/cat"])
server.new_session(name: "logs", command: ["/bin/cat"])
Async do |parent|
LibTmux::Async.open(parent: parent, server: server) do |scope|
refs = scope.server.list_panes.map(&:ref)
screens = scope.map(refs, concurrency: 2) { |ref| scope.server.pane(ref).capture }
puts "captured panes: #{screens.length}"
puts "all succeeded: #{screens.all?(&:success?)}"
end
end.wait
end
```
It prints:
```text
captured panes: 2
all succeeded: true
```
- Leave out `parent:` to use the current Async task.
- A scope rejects use from another thread, process or scheduler, so create one
scope for each scheduler thread.
- Scope exit retires its clients and joins its owned tasks.
## Cancel a request without stalling the others
### [`Async::Server#run`][async-server-run]: cancel a request that is waiting
[`scope.server.run`]() waits for a tmux command in a task. Cancel that task and
the scope retires its client, while sibling requests keep running.
[`wait_for`][async-server-wait_for] returns once the request has signalled
that it is running, so the cancel arrives while it waits:
```ruby
require "libtmux"
require "libtmux/async"
LibTmux::Server.start do |server|
server.new_session(name: "work", command: ["/bin/cat"])
Async do |parent|
LibTmux::Async.open(parent: parent, server: server) do |scope|
waiting = parent.async do
scope.server.run(["wait-for", "-S", "ready", ";", "wait-for", "held"], timeout: 5)
rescue LibTmux::Cancelled => error
error
end
scope.server.wait_for("ready", timeout: 5)
waiting.cancel
failure = waiting.wait
puts "request: #{failure.class}"
puts "delivery: #{failure.delivery}"
end
end.wait
end
```
It prints:
```text
request: LibTmux::Cancelled
delivery: possibly_sent
```
- `run` returns the same binary [`CommandResult`][commandresult] as the core.
- [`Cancelled`][cancelled] carries `delivery` as `:not_sent` or
`:possibly_sent`. A deadline cannot undo tmux effects.
- Interactive terminal attachment stays on the blocking core and raises
[`UnsupportedFeatureError`][unsupportedfeatureerror] here.
The [complete program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/async_cancel.rb) also keeps capturing
while the request waits, and checks that the cancelled client is reaped. The
contract is in [Async scope][behavior-async-scope].
## Keep results ordered and bounded
### [`Scope#map`][async-scope-map]: input order, capped payloads
[`map`]() runs a block for each item, up to `concurrency:` at a time, and returns a
frozen Array in input order. The quick start is a [`map`](). These limits apply to
every scope:
| Scope limit | Default |
| --- | --- |
| Active subprocess clients | 4 |
| Admitted subprocess requests, including unconsumed results | 32 |
| Queued request payload | 4 MiB |
| Retained process and map output payload | 8 MiB |
| Per-command stdout / stderr | 1 MiB / 256 KiB |
| Control connections | 4 |
| Ordinary command deadline | 5 seconds |
- Independent requests may complete out of order, and the result is still in
input order.
- [`map`]() caps retained items and counts payload bytes of strings, primitive
values, [`CommandResult`][commandresult], Arrays and Hashes. Cycles and deep
nesting are refused.
- An application-defined result needs a `result_bytes:` callable that returns
a nonnegative Integer.
- Keep measured values unchanged until the map returns. The counts cover
payload bytes and do not measure the Ruby heap.
The contract is in [Async map][behavior-async-map].
## Read control events in a scope
### [`Async::Server#open_control`][async-server-open_control]: replies and events
A control connection has its own request, reply and subscriber limits.
[`exchange`][async-controlconnection-exchange] runs one command, and
[`events`][async-controlconnection-events] yields what tmux reports outside a
reply:
```ruby
require "libtmux"
require "libtmux/async"
LibTmux::Server.start do |server|
session = server.new_session(name: "work", command: ["/bin/cat"])
window = session.list_windows.fetch(0)
Async do |parent|
LibTmux::Async.open(parent: parent, server: server) do |scope|
scope.server.open_control(session: session.ref) do |control|
reply = control.exchange("display-message -p ready", timeout: 5)
puts "reply: #{reply.blocks.last.body.strip}"
events = control.events
window.rename("renamed")
event = events.next(timeout: 5) until event&.raw&.start_with?("%window-renamed")
puts "event: #{event.raw.strip}"
end
end
end.wait
end
```
It prints:
```text
reply: ready
event: %window-renamed @0 renamed
```
- `exchange` answers a [`GuardedReply`][guardedreply] with `:boundary_window`
attribution. It makes no claim that the command finished.
- Events arrive through [`events.next`]() or an explicit
[`subscribe`][async-controlconnection-subscribe]. Consumer callbacks run
outside the parser.
- A reliable subscription raises on overflow, and a tail subscription reports
the dropped range.
- Cancelling a dispatched exchange that is not drained closes the connection.
- [`pause_output`][async-controlconnection-pause_output] and
[`resume_output`][async-controlconnection-resume_output] report possible
loss through gap events. A gap does not show that the action took effect.
- To reconnect, close the connection and pass it as `reconnect:`. The
replacement stays owned by the scope, has a new generation, and starts with
a gap of unknown loss. Nothing is replayed.
The contract is in [Control connections][behavior-control].
## What it leaves out
- **Terminal attachment.** `attach` stays on the blocking core and raises
[`UnsupportedFeatureError`][unsupportedfeatureerror] on this facade.
- **Replay.** Reconnect and resume never replay requests or missed output. See
[Control connections][behavior-control].
- **A scheduler.** Imports start no scheduler or background task, and your
application owns the Async root task. See [Execution modes][doc-modes].
- **Cross-thread scopes.** A scope belongs to the thread, process and
scheduler that opened it. See [Async scope][behavior-async-scope].
## Support and status
**Alpha.** APIs may change between releases.
- **Ruby 3.3 or newer** and **tmux 3.3a or newer.** The facade dispatches
through a version-checked core server, so it carries the same daemon release
check.
- **Control connections need tmux 3.7 or newer.**
[`open_control`][async-server-open_control] refuses an older daemon before a
control client attaches.
- **Async 2.46.** The gem depends on `async` ~> 2.46.0 and the same version of
`libtmux`.
- **Linux, including WSL, and macOS.** The [compatibility workflow][compat]
runs Ruby 3.3, 3.4 and 4.0 with tmux 3.3a through 3.8 on Ubuntu 24.04 and retains
per-revision results. macOS is supported on a best-effort basis, and CI
coverage for it is highly limited.
## Documentation
| | |
| --- | --- |
| [Reference](https://libtmux.org/en/ruby/latest/reference/libtmux-async/) | The Async classes, one page each |
| [Async guide](https://libtmux.org/en/ruby/latest/guides/async/) | Running concurrent commands within an owned scope |
| [Execution modes][doc-modes] | Blocking calls, Async tasks and control subscriptions |
| [Recipes][doc-recipes] | Complete programs with checked excerpts |
| [Public behavior][behavior-async-scope] | Scheduling, ownership and limits of a scope |
[async-controlconnection-events]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-controlconnection-events/
[async-controlconnection-exchange]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-controlconnection-exchange/
[async-controlconnection-pause_output]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-controlconnection-pause_output/
[async-controlconnection-resume_output]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-controlconnection-resume_output/
[async-controlconnection-subscribe]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-controlconnection-subscribe/
[async-controlsubscription]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-controlsubscription/
[async-open]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-open/
[async-scope-map]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-scope-map/
[async-server]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-server/
[async-server-open_control]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-server-open_control/
[async-server-run]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-server-run/
[async-server-wait_for]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-server-wait_for/
[behavior-async-map]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#async-map
[behavior-async-scope]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#async-scope
[behavior-control]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#control-connections
[cancelled]: https://libtmux.org/en/ruby/latest/reference/libtmux-cancelled/
[commandresult]: https://libtmux.org/en/ruby/latest/reference/libtmux-commandresult/
[compat]: https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml
[doc-modes]: https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/transports/
[doc-recipes]: https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/
[guardedreply]: https://libtmux.org/en/ruby/latest/reference/libtmux-guardedreply/
[server]: https://libtmux.org/en/ruby/latest/reference/libtmux-server/
[server-start]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-start/
[unsupportedfeatureerror]: https://libtmux.org/en/ruby/latest/reference/libtmux-unsupportedfeatureerror/
---
# Concepts
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/
> Concepts for libtmux.
Understand captured queries, object identities, and operations.
- [Execution modes](https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/transports/): Choose blocking commands, captured queries, control mode, or Async tasks.
---
# Server, session, window, pane
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/server-session-window-pane/
> How tmux servers, sessions, windows, panes and attached clients relate to each other.
libtmux models tmux's server, session, window, and pane objects:
```
Server
├── Session
│ └── Window
│ └── Pane
└── Client (attached view)
```
A `Server` contains sessions. Each [`Session`]() contains links to windows, and each
[`Window`]() contains panes. Commands run inside a [`Pane`](), where you send input and
capture output. A window can be linked to more than one session.
## Stable identity, not name or index
tmux assigns a unique ID to each session, window, and pane at creation. The ID
remains stable for that object's lifetime even if its name or index changes:
| Object | ID prefix | Example |
|--------|-----------|---------|
| Session | `$` | `$13` |
| Window | `@` | `@3243` |
| Pane | `%` | `%5433` |
| Server | - | identified by socket name or path instead |
Use stable IDs to identify the same tmux object across reads. Names and indexes
can change while a program is running.
## Client: a view, not a child
A tmux client represents a terminal attached to a session. Several clients can view
the same server, and each can switch sessions or windows independently. Client
fields describe the view at the time of the read.
A [control-mode connection](https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/transports/) is also a client. It appears in
[`list-clients`](https://libtmux.org/en/tmux/latest/manual/list-clients/), counts toward [`session_attached`](https://libtmux.org/en/tmux/latest/catalog/formats/session_attached/), and affects
attachment-dependent behavior such as [`destroy-unattached`](https://libtmux.org/en/tmux/latest/catalog/options/destroy-unattached/). Closing the last
attached client can therefore destroy a session configured with that option.
---
# Execution modes
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/transports/
> Choose blocking commands, captured queries, control mode, or Async tasks.
| Mode | Wait and ownership | Result evidence |
| --- | --- | --- |
| Core command | Calling thread blocks; server binding owns each client and its pipes | [`CommandResult`]() has binary stdout/stderr and final client status |
| Captured query | Snapshot acquisition performs explicit I/O; [`Selection`]() filtering is local | Stable captured membership with acquisition interval and coverage |
| Command group | One client submits an ordered, nontransactional group | Aggregate final status; individual steps remain `unknown` |
| Core control | One owned reader thread drains the connection; each subscriber has limits | Guarded blocks between boundaries; hooks can share the interval |
| Async | Caller supplies an Async parent task; pipe I/O yields on its scheduler | Same command evidence, with bounded request admission and cancellation |
| MCP | Caller supplies transport streams, Async scope and tool policy | Versioned protocol envelopes and structured tool responses |
| Workspace | Parsing and planning are inert; apply performs ordered commands | Created-reference ledger, observed effects and explicit uncertainty |
Use `Server.open(socket_path: ...)` to borrow a daemon through a pinned
binding. `Server.start` creates an owned daemon on a unique socket and closes
it with the block. No API in these recipes chooses the default server.
`CommandResult#success?` means the client exited successfully. Sending input
does not establish shell completion. A [`GuardedReply`]() has no `success?`:
`%end` terminates a guard, while WAIT commands, aliases and hooks can change
what finishes when. Its `boundary_window` attribution is deliberately weaker
than per-command ownership.
Concurrent control calls pipeline complete wire requests on one connection.
The writer can submit a later request while an earlier reply waits; the reader
assigns boundaries in the same order. Admission limits include all pending
and completed but unconsumed requests. Cancellation after any request bytes
are written closes the connection: other written requests have
`possibly_sent` delivery, and requests with no written bytes have `not_sent`.
No uncertain request is replayed. Sequential calls still wait for each reply.
Reliable control subscriptions raise [`SubscriptionOverflow`]() when they cannot
retain the stream. Tail subscriptions emit a gap containing lost sequence
and byte evidence. Neither mode blocks the command reader behind a slow
consumer. Limits apply to connection-owned buffers; callers own the replies
they retain after return.
Captured queries evaluate the whole criteria tree before selecting rows,
including inactive OR branches. Explain methods perform no I/O. Current
source plans use explicit capture and local evaluation; unsupported required
pushdown fails rather than silently changing semantics.
See [the recipes](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/) for event-based WAIT release, cancellation,
overflow and group-failure examples. No throughput comparison is claimed.
---
# Examples
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/
> Examples for libtmux.
Run complete programs with their documented setup and cleanup.
- [Capture pane output](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/capture-pane-output/): Send a command, wait for its output, and clean up the private server.
- [Recipes](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/): Run programs for queries, linked windows, capture, and cancellation.
---
# Capture pane output
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/capture-pane-output/
> Run a complete Ruby program that captures output on an isolated tmux server.
This complete Ruby program starts a private tmux server, sends a command,
and captures the line it prints. It includes imports, setup, and cleanup.
You need tmux and a Unix environment; no existing session is required.
## Read what's on screen
The leading newline puts the output on a fresh row. Matching the whole line
avoids mistaking the echoed command for its output.
```ruby title="capture.rb"
require "libtmux"
LibTmux::Server.start do |server|
created = server.new_session(
name: "capture", command: ["/bin/sh"],
environment: {"ENV" => "/dev/null"}, receipt: true
)
pane = created.pane
pane.send_text("printf '\\nlibtmux capture ready\\n'")
pane.send_keys("Enter")
deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
loop do
if pane.capture.stdout.lines(chomp: true).include?("libtmux capture ready")
puts "libtmux capture ready"
break
end
if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
raise "Output did not arrive within five seconds"
end
sleep 0.025
end
end
```
## Wait for output or completion
[`LibTmux::Server.start`]() owns the private server. Leaving its block stops the server, including when capture or the deadline raises an error.
Capture reads screen state and scrollback, so output that has scrolled away
may be absent. The program prints `libtmux capture ready` when its check passes
and exits unsuccessfully if an operation fails.
## Setup and run
Use an empty directory and save the files using the displayed names. You need
Ruby 4.0.7 and Bundler. Bundler installs the library and its runtime dependencies.
Save this dependency file beside the program.
```ruby title="Gemfile"
source "https://rubygems.org"
gem "libtmux", path: "libtmux-source/gems/libtmux"
```
The commands pin the library revision used to run this program.
```console
$ git clone https://github.com/libtmux/libtmux-ruby libtmux-source &&
git -C libtmux-source checkout 2599d45369515aaf2fd5793bfe71cdc20de641b6 &&
bundle config set --local path vendor/bundle &&
bundle install &&
bundle exec ruby capture.rb
```
## Where this comes from
The displayed files were compiled or loaded with their native tools and run
on Linux with tmux 3.2a and 3.7c. The rendering checks preserve those file bytes.
---
# Recipes
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/
> Run programs for queries, linked windows, capture, and cancellation.
Every linked program loads installed gems, starts an isolated server, asserts
its result and verifies owned-daemon cleanup. The shared
[support module](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/support.rb) supplies assertions and the cleanup
wrapper. No program adds checkout paths to Ruby's load path.
Run a program from the repository after installing its required local gems:
```console
$ ruby examples/window_links.rb
```
The artifact suite copies programs outside the checkout and runs them against
each gem's isolated dependency closure. [The manifest](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/manifest.json)
owns file discovery and the source regions used below. `scripts/examples
--check` rejects an unlisted program or a changed excerpt.
## Captured queries
[Complete list/filter/exact-one program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/list_filter.rb). A fresh
window does not alter an existing capture; local filtering still works after
the binding closes.
```ruby
session = server.new_session(name: "capture", command: ["/bin/cat"])
session.new_window(name: "second", command: ["/bin/cat"])
snapshot = server.snapshot
panes = snapshot.panes
first = panes.one(id: panes.first.id)
session.new_window(name: "later", command: ["/bin/cat"])
Example.check(panes.size == 2, "captured membership changed")
Example.check(panes.where(id: first.id).one.ref == first.ref, "wrong exact match")
Example.raises(LibTmux::MultipleMatchesError) { panes.one }
Example.check(panes.one_or_nil(id: "%4294967294").nil?, "missing pane was invented")
```
## Layout and bytes
[Complete layout/capture/send program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/layout_io.rb). On tmux 3.7
and newer a control output event establishes that the literal input has
reached the pane before capture; older daemons refuse the control client.
Binary buffers round-trip without text decoding.
```ruby
receipt = server.new_session(name: "layout", command: ["/bin/cat"], receipt: true)
pane = receipt.pane
second = pane.split(direction: :horizontal, size: "40%", command: ["/bin/cat"])
receipt.window.select_layout("tiled")
Example.check(receipt.window.list_panes.map(&:id).sort == [pane.id, second.id].sort, "assigned pane IDs differ")
if Example.control?(server)
server.open_control(session: receipt.entity.ref) do |control|
control.exchange("display-message -p ready", timeout: 0.5)
output = control.subscribe(pane_id: pane.id, max_bytes: 8192, max_events: 32)
literal = "literal; #{'#{pane_id}'} $HOME"
pane.send_text(literal)
bytes = "".b
bytes << output.next(timeout: 0.5).data until bytes.include?(literal)
Example.check(pane.capture.stdout.include?(literal), "capture lost literal input")
end
else
Example.refuses_control(server, receipt.entity)
end
payload = "NUL\0\xff\n".b
server.write_buffer(name: "bytes", data: payload)
Example.check(server.read_buffer("bytes").stdout == payload, "buffer bytes changed")
```
## One window at three indexes
[Complete window-link program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/window_links.rb). Window identity
and selection context remain distinct.
```ruby
session = server.new_session(name: "links", command: ["/bin/cat"])
window = session.list_windows.fetch(0)
session.link_window(window.ref, index: 4)
session.link_window(window.ref, index: 9)
links = session.list_window_links
Example.check(links.map(&:index) == [0, 4, 9], "link indexes differ")
Example.check(links.map { |link| link.window.ref }.uniq == [window.ref], "window identity split")
Example.check(links.map(&:ref).uniq.length == 3, "link contexts collapsed")
links.find { |link| link.index == 9 }.select
Example.check(session.display('#{window_index}').text == "9\n", "wrong current link")
```
## Blocking request cancellation
[Complete plain-Ruby cancellation program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/cancel.rb). A tmux event
proves dispatch before another thread cancels the blocked client. The program
joins the caller, checks client reaping and closes the token's owned pipe.
```ruby
cancellation = LibTmux::Cancellation.new
waiting = nil
begin
waiting = Thread.new do
server.run(["wait-for", "-S", "ready", ";", "wait-for", "held"],
timeout: 0.5, cancel: cancellation)
rescue LibTmux::Cancelled => error
error
end
server.wait_for("ready", timeout: 0.5)
cancellation.cancel
failure = waiting.value
Example.check(failure.is_a?(LibTmux::Cancelled), "cancellation lost")
Example.check(failure.delivery == :possibly_sent, "dispatched wait claimed no effects")
Example.raises(Errno::ECHILD) { Process.waitpid(failure.pid, Process::WNOHANG) }
Example.check(server.diagnostics.fetch(:admitted_requests).zero?, "client remains admitted")
ensure
begin
cancellation.cancel
waiting&.join
ensure
cancellation.close
end
end
```
## Async capture and cancellation
[Complete Async program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/async_cancel.rb). A second task captures
while another tmux client waits; cancellation retires that client's process.
```ruby
Async do |parent|
LibTmux::Async.open(parent: parent, server: server) do |scope|
waiting = parent.async do
scope.server.run(["wait-for", "-S", "ready", ";", "wait-for", "held"], timeout: 0.5)
rescue LibTmux::Cancelled => error
error
end
scope.server.wait_for("ready", timeout: 0.5)
Example.check(scope.diagnostics.fetch(:active_process_slots) == 1, "waiting client lost its slot")
captures = scope.map(scope.server.list_panes.map(&:ref), concurrency: 2) do |ref|
scope.server.pane(ref).capture
end
Example.check(captures.all?(&:success?), "sibling captures stalled")
waiting.cancel
failure = waiting.wait
Example.check(failure.is_a?(LibTmux::Cancelled), "cancellation lost")
Example.check(failure.delivery == :possibly_sent, "cancelled dispatch claimed no effects")
Example.raises(Errno::ECHILD) { Process.waitpid(failure.pid, Process::WNOHANG) }
Example.check(scope.server.diagnostics.fetch(:admitted_requests).zero?, "cancelled client remains admitted")
end
end.wait
```
## Control overflow
[Complete control program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/control_overflow.rb). It needs tmux 3.7
or newer and demonstrates the refusal on older daemons. A slow reliable
subscriber fails explicitly; a tail subscriber reports a gap and replies
continue to drain.
```ruby
server.open_control(session: session.ref) do |control|
control.exchange("display-message -p ready", timeout: 0.5)
reliable = control.subscribe(max_events: 1, max_bytes: 1024)
tail = control.subscribe(mode: :tail, max_events: 1, max_bytes: 1024)
3.times { |index| window.rename("event#{index}") }
reply = control.exchange("display-message -p alive", timeout: 0.5)
Example.check(reply.blocks.last.body == "alive\n", "slow reader blocked commands")
Example.check(reply.attribution == :boundary_window, "reply overclaims attribution")
Example.check(reliable.diagnostics.fetch(:overflowed), "overflow is missing from diagnostics")
Example.check(control.diagnostics.fetch(:retained_reply_bytes).zero?, "consumed reply remains retained")
reliable.next(timeout: 0.5)
Example.raises(LibTmux::SubscriptionOverflow) { reliable.next(timeout: 0.5) }
gap = tail.next(timeout: 0.5)
Example.check(gap.kind == :gap && gap.dropped_bytes.positive?, "tail hid lost bytes")
end
```
## Failure inside a group
[Complete group program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/failed_group.rb). The first mutation
survives a later failure. A separate read establishes the missing later effect;
the group result does not invent statuses for its members.
```ruby
group = server.run_group([
["set-option", "-g", "@before", "retained"],
["select-pane", "-t", "%4294967294"],
["set-option", "-g", "@after", "not-executed"]
])
Example.check(!group.success?, "failing group succeeded")
Example.check(group.steps.all? { |step| step.fetch(:outcome) == :unknown }, "invented per-step status")
Example.check(server.options(scope: :session).get("@before").raw == "retained", "earlier effect rolled back")
Example.check(server.options(scope: :session).list.none? { |option| option.name == "@after" }, "later step executed")
```
## MCP protocol
[Complete MCP program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/mcp_protocol.rb). Real pipe frames exercise
discovery, snapshot reads, default mutation denial and cancellation of an
application-owned WAIT method. The custom WAIT method is a transport probe,
not part of the advertised tmux tool catalog.
```ruby
application = LibTmux::MCP::Application.new(server: scope.server, endpoint_name: "example")
sdk = application.sdk_server
input, client_input = IO.pipe
client_output, output = IO.pipe
transport = LibTmux::MCP::StdioTransport.new(server: sdk, parent: parent, input: input, output: output)
runner = parent.async { transport.run }
```
The installed executable also exercises explicitly enabled create, send,
close and authored-run tools. Its complete program creates a zsh pane whose
startup file explicitly sources the CLI's mode-0600 enrollment file, waits
for the authenticated acknowledgement, and checks binary stderr and native
exit status. It closes stdin and verifies enrollment cleanup and borrowed
daemon survival. An unsupported advertised process backend exercises the
structured refusal instead; that is not positive enrollment evidence.
```ruby
executable = Gem.bin_path("libtmux-mcp", "libtmux-mcp")
Open3.popen3(Gem.ruby, "-W:no-experimental", executable, "--socket", server.endpoint.socket_path,
"--tmux", Example.executable, "--endpoint", "installed", "--enable-tool", "tmux_create", "--enable-tool", "tmux_send",
"--enable-tool", "tmux_close", "--enable-tool", "tmux_run", *enrollment_arguments) do |input, output, errors, process|
request = lambda do |id, method, params = {}|
input.write(JSON.generate({jsonrpc: "2.0", id: id, method: method, params: params}) + "\n")
Example.check(IO.select([output], nil, nil, id == 1 ? 1.0 : 0.5), "installed MCP did not return a frame")
response = JSON.parse(output.gets)
Example.check(response.fetch("id") == id, "MCP response identity changed")
response.fetch("result")
end
request.call(1, "initialize", {protocolVersion: "2025-11-25", capabilities: {},
clientInfo: {name: "recipe", version: "1"}})
input.write(JSON.generate({jsonrpc: "2.0", method: "notifications/initialized"}) + "\n")
names = request.call(2, "tools/list").fetch("tools").map { |tool| tool.fetch("name") }
Example.check(names.sort == %w[tmux_capabilities tmux_close tmux_create tmux_run tmux_send tmux_snapshot], "tool policy differs")
created = request.call(3, "tools/call", {name: "tmux_create", arguments: {
kind: "session", name: "via-protocol", argv: ["/bin/cat"]}}).fetch("structuredContent")
Example.check(created.fetch("ok"), "protocol creation failed")
data = created.fetch("data")
pane = data.fetch("created").find { |ref| ref.fetch("kind") == "pane" }
sent = request.call(4, "tools/call", {name: "tmux_send", arguments: {
target: pane, input: {type: "text", text: "literal;"}}}).fetch("structuredContent")
Example.check(sent.fetch("data").fetch("completion") == "dispatch_only", "send claimed shell completion")
target = pane
if channel
Example.check(File.stat(setup).mode & 0o777 == 0o600, "enrollment setup permissions differ")
channel.puts(setup)
Example.check(IO.select([channel], nil, nil, 0.5) && channel.gets == "ready\n", "shell enrollment was not acknowledged")
target = pane.merge("id" => shell_pane.id)
end
script = 'printf "%s:%s" "$EXAMPLE_CONTEXT" "$TMUX_PANE"; printf "\\000\\377" >&2; exit 9'
run = request.call(5, "tools/call", {name: "tmux_run", arguments: {
target: target, script: script, stdout_limit: 128, stderr_limit: 2}}).fetch("structuredContent")
if channel
Example.check(run.fetch("ok"), "installed authored run failed")
result = run.fetch("data")
Example.check(result.fetch("stdout").fetch("data") == "installed:#{shell_pane.id}", "authored shell context differs")
Example.check(result.fetch("stderr") == {"encoding" => "base64", "data" => "AP8=", "bytes" => 2, "truncated" => false}, "authored bytes differ")
Example.check(result.fetch("completion") == {"state" => "exited", "exit_status" => 9, "signal" => nil}, "native completion differs")
Example.check(result.fetch("authorization").fetch("state") == "authorized", "authorization receipt missing")
else
Example.check(run.dig("error", "code") == "unsupported" && run.dig("error", "delivery") == "not_sent", "unsupported enrollment did not refuse")
end
closed = request.call(6, "tools/call", {name: "tmux_close", arguments: {target: data.fetch("entity")}})
Example.check(closed.fetch("structuredContent").fetch("ok"), "protocol close failed")
input.close
Example.check(process.join(0.5), "MCP EOF did not retire its process")
Example.check(process.value.success? && errors.read.empty?, "MCP executable failed")
Example.check(!File.exist?(setup), "enrollment setup survived EOF")
end
```
## Workspace plan, load and failure
[Complete workspace program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/workspace_apply.rb) consumes the
[checked configuration](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/workspace.yaml), applies it, then verifies
partial failure and guarded compensation when another layout exceeds available
pane space. It also runs installed CLI validation, planning and loading.
```ruby
workspace = LibTmux::Workspace.load(File.join(__dir__, "workspace.yaml"))
plan = workspace.plan(snapshot: server.snapshot)
Example.check(server.list_sessions.size == 1, "planning changed tmux")
result = plan.apply(server: server)
Example.check(result.success?, "workspace apply failed")
Example.check(result.effects.any? { |effect| effect.outcome == :dispatch_only }, "shell dispatch overclaims completion")
crowded = LibTmux::Workspace.parse(JSON.generate({
session_name: "crowded", windows: [{window_name: "small", panes: Array.new(40) { {} }}]
}), format: :json, base_directory: __dir__)
error = Example.raises(LibTmux::Workspace::ApplyError) do
crowded.plan.apply(server: server, compensate: true)
end
Example.check(!error.result.created_refs.empty?, "failure lost partial creation ledger")
Example.check(error.result.compensation == :completed, "owned compensation failed")
Example.check(server.list_sessions.map(&:ref).include?(borrowed.ref), "borrowed session was removed")
```
---
# Ruby MCP examples
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/examples/
> Run complete Ruby programs for an MCP client or an embedded application.
**MCP concept example** A working example of the core library. It can change without notice.
Both examples include their complete program, pinned dependencies, run
commands, expected results, and cleanup. Each creates its own tmux daemon.
## Default read-only catalog
The [client guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/connect-client/#configure-a-client) generates an
MCP configuration using the launcher's absolute path and the current Ruby
executable. Its default catalog contains [`tmux_capabilities`]() and
[`tmux_snapshot`](). Listing the tools and querying the example session verifies
the connection.
The [embedded example](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/examples/page-session-metadata/) calls those tools from Ruby
inside an Async scope. It creates two sessions and prints their names by
following a snapshot cursor.
## Add bounded observation
For capture or waits in the client launcher, add
`"--enable-tool", "`[`tmux_capture`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/)`"` or `"--enable-tool", "`[`tmux_wait`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/)`"` to the
array passed to [`LibTmux::MCP::CLI.run`]() in `run-mcp.rb`. Adding them to the
generated client configuration's arguments has no effect: the launcher does
not forward those arguments. Enable creation, input, close, or authored
execution only when the client needs those effects.
The [guides overview](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/#enable-observation) explains the tool choices;
the [source-owned guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/) gives their lifecycle contracts.
- [Page session metadata](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/examples/page-session-metadata/): Embed the MCP application, page two session names from one capture, and close owned resources.
- [Launch a client server](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/connect-client/): Run a stdio MCP server with a private tmux daemon and a generated client configuration.
---
# Page session metadata from Ruby
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/examples/page-session-metadata/
> Embed the Ruby MCP application, read a retained session listing, and close its owned resources.
**MCP concept example** A working example of the core library. It can change without notice.
Use the MCP application directly when a Ruby host needs the same tool policy
and result envelopes as its MCP clients. This complete example creates two
sessions, selects one row per page, and prints both names from one retained
metadata capture.
It calls the application in process. For a client that launches a stdio
server, use the [client guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/connect-client/).
## Prepare the project
Use Ruby 4.0.7 with its development headers, Bundler, Git, a C compiler and
Make, and tmux 3.3a or newer on a Unix host. The locked bundle includes native
extensions. Start with an empty directory:
```console
$ mkdir ruby-mcp-pages && cd ruby-mcp-pages
```
Fetch the source:
```console
$ git clone https://github.com/libtmux/libtmux-ruby libtmux-source
```
Select the documented revision:
```console
$ git -C libtmux-source checkout 9b1545562a112353c2c893a1d3e8c0d9b4b51f8d
```
Install the locked dependencies:
```console
$ BUNDLE_FROZEN=true BUNDLE_GEMFILE=./libtmux-source/Gemfile bundle install
```
## Run the complete example
Save this file beside the source checkout:
```ruby title="snapshot-sessions.rb"
# frozen_string_literal: true
ENV["BUNDLE_GEMFILE"] = File.expand_path("libtmux-source/Gemfile", __dir__)
require "bundler/setup"
require "libtmux/mcp"
def describe_failure(error)
details = ["#{error.class}: #{error.message}"]
if error.is_a?(LibTmux::Error)
details.concat(error.cleanup_errors.map { |message| "Cleanup: #{message}" })
end
if error.respond_to?(:async_cleanup_errors)
details.concat(error.async_cleanup_errors.map { |message| "Cleanup: #{message}" })
end
details.join("\n")
end
def tool_data(application, name, arguments = {})
result = application.call(name, arguments).structured_content
return result.fetch("data") if result.fetch("ok")
error = result.fetch("error")
raise "#{name}: #{error.fetch('code')} (#{error.fetch('delivery')}): " \
"#{error.fetch('message')}"
end
server = nil
failures = []
begin
server = LibTmux::Server.start(timeout: 5.0)
%w[build editor].each do |name|
server.new_session(name: name, command: ["/bin/cat"], timeout: 5.0)
end
Async do |parent|
LibTmux::Async.open(parent: parent, server: server) do |scope|
application = nil
begin
application = LibTmux::MCP::Application.new(
server: scope.server, endpoint_name: "example", request_timeout: 5.0
)
capabilities = tool_data(application, "tmux_capabilities")
puts "Endpoint: #{capabilities.fetch('endpoint')}"
page = tool_data(
application, "tmux_snapshot", {entity: "session", limit: 1}
)
loop do
page.fetch("items").each do |item|
puts item.fetch("fields").fetch("name")
end
break unless page.fetch("truncated")
page = tool_data(
application, "tmux_snapshot", {cursor: page.fetch("next_cursor")}
)
end
ensure
begin
application&.close
rescue StandardError => error
failures << "MCP cleanup failed: #{describe_failure(error)}"
end
end
end
end.wait
rescue StandardError => error
failures << describe_failure(error)
ensure
begin
server&.close
rescue StandardError => error
failures << "Server cleanup failed: #{describe_failure(error)}"
end
end
abort failures.join("\n") unless failures.empty?
```
Run it with tmux available on `PATH`:
```console
$ ruby -W:no-experimental snapshot-sessions.rb
```
Expected output:
```text
Endpoint: example
build
editor
```
The Ruby option suppresses the experimental [`IO::Buffer`](https://docs.ruby-lang.org/en/4.0/IO/Buffer.html) warning. It does not
suppress operation or cleanup errors. A failure produces a nonzero exit and
diagnostics on stderr; earlier stdout may contain partial results.
## Pagination
[`Application`]() requires a [`LibTmux::Async::Server`]() facade inside its owning
Async scheduler. [`LibTmux::Async.open`]() supplies that facade and closes the
scope after the block. The application and its calls stay in the same
scheduler throughout the example.
The first [`tmux_snapshot`]() call selects session metadata with a page limit of
one. A continuation sends only the returned `next_cursor`. It keeps the same
capture and selection; it does not relist sessions. The private daemon has
two sessions, so this example receives two pages. `truncated: false` ends the
loop.
Every call checks the application's `structured_content` envelope before
using `"data"`. Tool failures include a code, delivery state, and message. A
missing or expired cursor is an error to handle, not an instruction to
silently restart the listing. The [snapshot topic](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/topics/snapshots-and-references/)
explains cursor lifetime, capacity, and reference identity.
## Resource ownership
`Server.start` creates a private socket directory and foreground tmux daemon
with an empty configuration. The program creates its own `build` and `editor`
sessions running `cat`; no existing socket, session, or pane is required.
The MCP application uses its default capability and snapshot tools. The two
sessions are ordinary Ruby API setup, not mutations admitted through the MCP
tool policy. Embedding the application does not constrain what other Ruby
code in the host can do.
Startup and each session creation have separate five-second deadlines.
The application uses `request_timeout: 5.0` for metadata acquisition during
capability discovery and fresh snapshot calls. Continuations read retained
data. Shutdown first closes the application, then its Async scope, then the
owned daemon. Each cleanup attempt still runs if an earlier operation or
cleanup fails, and the program reports the collected errors.
The [pinned application implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-mcp/lib/libtmux/mcp/application.rb)
and [Async scope](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-async/lib/libtmux/async.rb)
define these ownership and request contracts.
---
# Guides
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/
> Guides for libtmux.
Connect to tmux and work with its sessions, windows, and panes.
- [Getting started](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/): Install the gem, create a session, and query a snapshot.
- [Attaching to tmux](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/attaching-to-tmux/): Connect to an existing socket and leave its server running.
- [Server bindings](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/): Own a private server or connect to an existing socket.
---
# Ruby MCP guides
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/
> Connect an MCP client to a private tmux server and select its tools.
**MCP concept example** A working example of the core library. It can change without notice.
Start with a private tmux server and the default read-only catalog. The client
guide includes the complete launcher, dependency setup, client configuration,
and connection checks.
## Select the tmux server
`--socket PATH` selects an explicit socket; `--socket-name NAME` selects a
named socket. `--endpoint` assigns the public alias used in discovery and
resource URIs. It does not choose the socket.
The [client launcher](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/connect-client/) creates and owns its tmux daemon.
When an application already owns the daemon, the MCP command borrows its
endpoint: end of input closes the protocol clients without stopping tmux.
The owning application remains responsible for the daemon's lifetime.
## Enable observation
Screen capture and waits are absent from the default catalog. In the client
guide's `run-mcp.rb`, add `"--enable-tool", "`[`tmux_capture`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/)`"` or
`"--enable-tool", "`[`tmux_wait`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/)`"` to the array passed to [`LibTmux::MCP::CLI.run`]().
The launcher does not forward arguments from the client configuration.
When launching the installed `libtmux-mcp` executable directly, pass
`--enable-tool `[`tmux_capture`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/) or `--enable-tool `[`tmux_wait`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/) as command arguments.
[`tmux_wait`]() can observe screen text or a process exit. Strong process tracking
requires tmux 3.3 or newer and a supported native identity backend. A refusal
means the required evidence is unavailable; it is not a successful wait.
See the [tool reference](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/) for arguments and results.
## Enable mutations
Add another `--enable-tool` pair for [`tmux_create`](), [`tmux_send`](), or [`tmux_close`]()
in the same launcher array or executable arguments.
Creation accepts command argument arrays. Sending text and sending named keys
are separate variants. A dispatch receipt does not claim that the pane program
completed.
The [source-owned MCP guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/) covers tool policy and shell
enrollment. The [snapshot topic](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/topics/snapshots-and-references/) explains
the references used to address observed objects.
- [Connect a client](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/connect-client/): Build a pinned launcher, inspect its tools, and close its private daemon with the client.
---
# Getting started
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/
> Install the gem, create a session, and query a snapshot.
Create tmux sessions, split windows, send input, and capture pane output from
Ruby. Read server state into a [snapshot][snapshot], then query it with
[`where`][selection-where], [`select`][selection-select], and the rest of
`Enumerable`.
[Quick start](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#quick-start) · [Find things](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#find-things-in-a-snapshot) ·
[Packages](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#packages) · [Guide](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/index.md) ·
[API reference](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/api.md) · [Recipes](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/) ·
[API on libtmux.org](https://libtmux.org/en/ruby/latest/reference/)
**Alpha.** APIs may change between releases. See the
[initial alpha notes](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/CHANGELOG.md) and [release guide](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/releasing.md).
It suits scripts, tests that need a real tmux, and tools that drive a terminal
program. An [MCP server][mcp-application], an Async adapter and a workspace
loader ship beside the core, under [Packages](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#packages).
**Contents** — [Quick start](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#quick-start) ·
[Find things](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#find-things-in-a-snapshot) ·
[Your own server](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#use-the-tmux-server-you-already-run) ·
[Packages](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#packages) · [Build from source](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#build-from-source) ·
[Leaves out](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#what-it-leaves-out) · [Support](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#support-and-status) ·
[Documentation](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#documentation)
## Quick start
Install the core prerelease from RubyGems. It needs Ruby 3.3 or newer and tmux
3.3a or newer on `PATH`:
```console
$ gem install libtmux --pre
```
This program creates a session, adds a window, splits it, and prints each
window with its panes. [`Server.start`][server-start] closes its private tmux
server when the block exits, and the snapshot stays readable afterward:
```ruby
require "libtmux"
snapshot = LibTmux::Server.start do |server|
session = server.new_session(name: "work", window_name: "main", command: ["/bin/cat"])
window = session.new_window(name: "logs", command: ["/bin/cat"])
window.split(direction: :horizontal, size: "40%", command: ["/bin/cat"])
server.snapshot
end
snapshot.windows.each do |window|
puts "#{window.name}: #{window.panes.map(&:id).join(', ')}"
end
```
From a checkout, run the [complete example](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/quickstart.rb):
```console
$ mise exec -- bundle exec ruby examples/quickstart.rb
```
It prints:
```text
main: %0
logs: %1, %2
```
Pane commands take argument arrays. [`Server.start`][server-start] gives its
tmux server a socket and an empty configuration of its own, so it never
touches a tmux you already use.
## Find things in a snapshot
### [`Server#snapshot`][server-snapshot]: one read, many queries
Continue with the snapshot above. [`where`][selection-where] accepts criteria
as data, and [`select`][selection-select] accepts a Ruby block. These queries
make no tmux calls:
```ruby
panes = snapshot.panes
active_ids = panes.where(active: true).map(&:id)
wide_panes = panes.select { |pane| pane.width >= 40 }
panes_by_window = panes.group_by { |pane| pane.window.name }
logs = snapshot.windows.one(name: "logs")
missing = snapshot.windows.one_or_nil(name: "missing")
```
[`one`][selection-one] raises [`NoMatchError`][nomatcherror] or
[`MultipleMatchesError`][multiplematcheserror] unless exactly one record
matches. [`one_or_nil`][selection-one_or_nil] returns `nil` for no match and
still rejects duplicates. Both errors live under `LibTmux`.
A selection keeps the membership it captured. Call
[`server.snapshot`][server-snapshot] again while the server is open to read
later changes.
The [field catalog][doc-fields] lists query fields and wire names, and the
[list/filter recipe](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/list_filter.rb) covers exact matches and queries
after close.
## Use the tmux server you already run
### [`Server.new`][server-new]: borrow a daemon
[`Server.open`][server-open] and [`Server.new`][server-new] bind an endpoint
that already exists, such as `Server.open(socket_path: ...)`. Closing the
binding leaves the daemon running. The outer [`Server.start`][server-start]
block here only supplies a daemon to borrow:
```ruby
require "libtmux"
LibTmux::Server.start do |owner|
owner.new_session(name: "work", command: ["/bin/cat"])
server = LibTmux::Server.new(endpoint: owner.endpoint)
begin
puts "connected sessions: #{server.list_sessions.length}"
ensure
server.close
end
puts "sessions after client close: #{owner.list_sessions.length}"
end
```
It prints:
```text
connected sessions: 1
sessions after client close: 1
```
See [ownership and errors][doc-ownership] for what close and failure mean.
## Packages
Start with `libtmux`. Add the companion for your caller:
| Gem | Require | Use it for |
| --- | --- | --- |
| [libtmux](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/) | `libtmux` | Blocking scripts, snapshots, and control connections |
| [libtmux-async](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/async/) | `libtmux/async` | Concurrent commands and bounded streams in Async tasks |
| [libtmux-mcp](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/) | `libtmux/mcp` | An MCP server with explicit endpoints and tool policy |
| [libtmux-workspace](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/) | `libtmux/workspace` | YAML/JSON workspace plans and a CLI to apply them |
Requiring a gem starts no tmux process, scheduler, or protocol server. The
companion gems install separately, and need `--pre` for their alpha versions
too. [Execution modes][doc-modes] explains blocking calls, Async tasks, and
control subscriptions.
### [libtmux](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux): the core
Blocking [server][server], [session][session], [window][window] and
[pane][pane] handles, immutable [snapshots][snapshot], and
[control connections][controlconnection]. Require `libtmux`.
[API reference](https://libtmux.org/en/ruby/latest/reference/) ·
[Guides](https://libtmux.org/en/ruby/latest/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux)
```console
$ gem install libtmux --pre
```
The [quick start](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#quick-start) and
[snapshot queries](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/getting-started/#find-things-in-a-snapshot) above run against this gem.
### [libtmux-async](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-async): concurrent commands
Concurrent commands and bounded control streams inside an Async task that your
application owns. Require `libtmux/async`, then open a scope with
[`LibTmux::Async.open`][async-open].
[API reference](https://libtmux.org/en/ruby/latest/reference/libtmux-async/) ·
[Guide](https://libtmux.org/en/ruby/latest/guides/async/) ·
[RubyGems](https://rubygems.org/gems/libtmux-async)
```console
$ gem install libtmux-async --pre
```
Capture every pane concurrently with [`Scope#map`][async-scope-map]. `server`
is an open [`LibTmux::Server`][server]:
```ruby
Async do |parent|
LibTmux::Async.open(parent: parent, server: server) do |scope|
refs = scope.server.list_panes.map(&:ref)
screens = scope.map(refs, concurrency: 2) { |ref| scope.server.pane(ref).capture }
Example.check(screens.length == refs.length && screens.all?(&:success?), "concurrent captures failed")
end
end.wait
```
### [libtmux-mcp](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-mcp): a tmux server for MCP clients
An MCP server over stdio for one tmux server, with an explicit tool policy.
Installs `libtmux-mcp`; require `libtmux/mcp` to embed it through
[`LibTmux::MCP::Application`][mcp-application].
[API reference](https://libtmux.org/en/ruby/latest/mcp/reference/) ·
[Tools](https://libtmux.org/en/ruby/latest/mcp/tools/) ·
[Guides](https://libtmux.org/en/ruby/latest/mcp/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux-mcp)
```console
$ gem install libtmux-mcp --pre
```
The server borrows a tmux server that is already running. Start one on a
socket of its own:
```console
$ tmux -L agent new-session -d -s work
```
Add the server to Claude Code. Until you enable more tools, it serves
[`tmux_capabilities`][tool-tmux_capabilities] and
[`tmux_snapshot`][tool-tmux_snapshot]:
```console
$ claude mcp add tmux -- libtmux-mcp --socket-name agent --endpoint dev
```
The [MCP README](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/) covers other clients, every tool
and authored shell commands. Tracked captures, waits and authored runs need
tmux 3.3a or newer and native process identity.
### [libtmux-workspace](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-workspace): YAML workspaces
YAML or JSON workspaces, validated, planned offline and applied to an open
server. Installs `libtmux-workspace`; require `libtmux/workspace` to use it
from Ruby through [`LibTmux::Workspace`][workspace].
[API reference](https://libtmux.org/en/ruby/latest/workspace/reference/) ·
[Command reference](https://libtmux.org/en/ruby/latest/workspace/cli/) ·
[Guides](https://libtmux.org/en/ruby/latest/workspace/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux-workspace)
```console
$ gem install libtmux-workspace --pre
```
Save this workspace as `workspace.yaml`:
```yaml
session_name: work
environment:
PROJECT_MODE: development
windows:
- window_name: editor
window_index: 1
layout: tiled
panes:
- shell_command: printf 'editor ready\n'
- {}
```
Check it without contacting tmux:
```console
$ libtmux-workspace validate workspace.yaml
```
```text
Workspace configuration is valid.
```
The [workspace README](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/) loads it into a
running server and lists every option, including how `--switch` moves a
client.
## Build from source
Use the Ruby pinned in [.tool-versions](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/.tool-versions) and have `tmux` on your
`PATH`. From this checkout, install the development bundle:
```console
$ mise install
```
```console
$ mise exec -- bundle config set --local path vendor/bundle
```
```console
$ mise exec -- bundle install
```
To use the core outside this checkout, build the artifacts:
```console
$ mise exec -- bundle exec rake build
```
Install into the Ruby environment that will run your application. The core's
runtime dependencies must already be installed for this local-only command:
```console
$ gem install \
--local \
--no-document \
pkg/libtmux-0.1.0.alpha.3.gem
```
Companion gems need their declared runtime dependencies too. The
[packaging check](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/.github/CONTRIBUTING.md#checks) verifies each gem in an
isolated installation and runs the recipes outside the checkout.
## What it leaves out
- **Live objects.** A [snapshot][snapshot] record is what tmux said when you
read it, and a selection keeps the membership it captured. Read again to see
a change.
- **A terminal emulator.** [`Pane#capture`][pane-capture] returns what tmux's
[`capture-pane`](https://libtmux.org/en/tmux/latest/manual/capture-pane/) prints for the pane.
- **An implied server.** [`Endpoint.new`][endpoint-new] needs an explicit
socket, and no API in the recipes uses the default server.
- **Whole-program typing.** RBS declarations ship with each gem, and selected
installed calls are checked. See the [public methods][doc-api].
- **Throughput claims.** The [benchmarks][doc-benchmark] list their workloads,
measurements and limits.
## Support and status
**Alpha.** APIs may change between releases.
- **Ruby 3.3 or newer** and **tmux 3.3a or newer.** Unpatched 3.3 is below the
minimum. A [server handle][server] checks the connected daemon's release, not
the client's, and refuses an older daemon before any requested command runs.
- **Linux, including WSL, and macOS.** The [compatibility workflow][compat]
runs Ruby 3.3, 3.4 and 4.0 with tmux 3.3a through 3.8 on Ubuntu 24.04.
macOS is supported on a best-effort basis, and CI coverage for it is highly
limited.
- **tmux master and old daemons.** On Ubuntu the workflow also runs the suite
against a pinned tmux master, and checks that tmux 3.0a, 3.1c, 3.2a and 3.3
daemons are refused.
- **Per-revision results.** Check the workflow's results for your revision
before relying on one combination.
## Documentation
- [Send text and capture output](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/layout_io.rb): split panes, wait for
output events, and round-trip binary buffers.
- [Work with linked windows](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/window_links.rb): address one window at
several session indexes.
- [Capture concurrently](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/async_cancel.rb): read panes while another
request waits, then cancel it.
- [Load a workspace](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/workspace_apply.rb): parse a configuration, plan,
and apply it.
- [All recipes](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/): cancellation, control streams, command groups,
and MCP.
- [API reference](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/api.md): public methods, source links, and
behavioral contracts. RBS declarations ship with each gem; selected installed
calls are checked, without a whole-program typing guarantee.
- [Benchmarks](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/benchmark.md): workloads, measurements, and their limits.
See [Contributing](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/.github/CONTRIBUTING.md) for setup and checks.
## Attribution
Please use the following BibTeX template to cite libtmux-ruby in scientific discourse:
```bibtex
@misc{libtmux-ruby,
author = {Tony Narlock},
year = {2026},
note = {https://libtmux.org/en/ruby/},
title = {libtmux-ruby: Ruby wrapper for tmux}
}
```
## License
MIT. See [LICENSE](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/LICENSE).
[async-open]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-open/
[async-scope-map]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-scope-map/
[compat]: https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml
[controlconnection]: https://libtmux.org/en/ruby/latest/reference/libtmux-controlconnection/
[doc-api]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/api.md
[doc-benchmark]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/benchmark.md
[doc-fields]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/fields.md
[doc-modes]: https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/transports/
[doc-ownership]: https://libtmux.org/en/ruby/v0.1.0.alpha.3/topics/errors-and-exceptions/
[endpoint-new]: https://libtmux.org/en/ruby/latest/reference/libtmux-endpoint-new/
[mcp-application]: https://libtmux.org/en/ruby/latest/mcp/reference/libtmux-mcp-application/
[multiplematcheserror]: https://libtmux.org/en/ruby/latest/reference/libtmux-multiplematcheserror/
[nomatcherror]: https://libtmux.org/en/ruby/latest/reference/libtmux-nomatcherror/
[pane]: https://libtmux.org/en/ruby/latest/reference/libtmux-pane-14z6/
[pane-capture]: https://libtmux.org/en/ruby/latest/reference/libtmux-pane-capture/
[selection-one]: https://libtmux.org/en/ruby/latest/reference/libtmux-selection-one/
[selection-one_or_nil]: https://libtmux.org/en/ruby/latest/reference/libtmux-selection-one_or_nil/
[selection-select]: https://libtmux.org/en/ruby/latest/reference/libtmux-selection-select/
[selection-where]: https://libtmux.org/en/ruby/latest/reference/libtmux-selection-where/
[server]: https://libtmux.org/en/ruby/latest/reference/libtmux-server/
[server-new]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-new/
[server-open]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-open/
[server-snapshot]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-snapshot/
[server-start]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-start/
[session]: https://libtmux.org/en/ruby/latest/reference/libtmux-session-nvps/
[snapshot]: https://libtmux.org/en/ruby/latest/reference/libtmux-snapshot/
[tool-tmux_capabilities]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_capabilities/
[tool-tmux_snapshot]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_snapshot/
[window]: https://libtmux.org/en/ruby/latest/reference/libtmux-window-1vfx/
[workspace]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace/
---
# Attaching to tmux
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/attaching-to-tmux/
> Connect to an existing tmux server and find a session with Ruby.
Connect a `Server` to an explicit socket and find the existing `work` session.
The program prints its name and leaves the tmux server running. It reports an
error if the connection fails or the session is absent.
This controls tmux from your program. To open a session in your terminal, use
[`tmux attach-session`](https://libtmux.org/en/tmux/latest/manual/attach-session/); the [shared guide](https://libtmux.org/en/tmux/guides/attaching-to-tmux/) covers
interactive attachment and detaching.
## Connect to an existing server
Save the complete program as `connect.rb`. `LIBTMUX_SOCKET_PATH` selects
the existing server. The launcher below supplies a private socket for trying
the example.
```ruby title="connect.rb"
require "libtmux"
LibTmux::Server.open(socket_path: ENV.fetch("LIBTMUX_SOCKET_PATH")) do |server|
session = server.snapshot.sessions.find { |candidate| candidate.name == "work" }
raise "The work session does not exist" unless session
puts session.name
end
```
## Setup and run
Use an empty directory on Linux with Git and tmux 3.3a or newer installed.
This example was checked with Ruby 4.0.7, Bundler.
Save this file beside the program using the displayed filename.
```ruby title="Gemfile"
source "https://rubygems.org"
gem "libtmux", path: "libtmux-source/gems/libtmux"
```
Save the launcher as `run.sh`. It starts an isolated tmux server, runs the
program, checks that the session still exists, then stops only that server.
Cleanup runs after failures too. A failed shutdown keeps its socket directory
and prints its location for inspection.
```sh title="run.sh"
#!/bin/sh
set -eu
binary=$(command -v tmux)
directory=$(mktemp -d "${TMPDIR:-/tmp}/libtmux-ruby-attach.XXXXXX")
socket="$directory/tmux.sock"
cleanup() {
status=$?
trap - 0 HUP INT TERM
if [ -S "$socket" ] && ! "$binary" -S "$socket" kill-server; then
printf 'Cannot stop tmux; kept %s\n' "$directory" >&2
exit 1
fi
rm -rf "$directory" || exit 1
exit "$status"
}
trap cleanup 0
trap 'exit 1' HUP INT TERM
unset TMUX TMUX_PANE
export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
"$binary" -S "$socket" -f /dev/null new-session -d -s work /bin/cat
"$@"
"$binary" -S "$socket" has-session -t '=work'
```
Fetch the verified library revision, build, and run:
```console
$ git clone https://github.com/libtmux/libtmux-ruby libtmux-source &&
git -C libtmux-source checkout 2599d45369515aaf2fd5793bfe71cdc20de641b6 &&
bundle config set --local path vendor/bundle &&
bundle install &&
sh run.sh bundle exec ruby connect.rb
```
The program prints `work`. To use an existing server of your own, set
`LIBTMUX_SOCKET_PATH` to its socket and run the program without the launcher.
That launcher is responsible for the demonstration server's lifetime.
## Find or create a session
The example only looks up a session. If your application creates a session
after an unsuccessful lookup, another client may create the same name between
those operations. Handle the creation error instead of assuming the lookup
reserves the name.
For a complete program that starts and owns its server, see
[Capture pane output](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/capture-pane-output/).
---
# MCP server guide
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/
> MCP server guide: libtmux documentation.
**MCP concept example** A working example of the core library. It can change without notice.
Expose an existing tmux server over MCP stdio. Read snapshots, capture pane
output and wait for events, or enable creation, input and shell commands one
tool at a time.
[API reference](https://libtmux.org/en/ruby/latest/mcp/reference/) ·
[Tools](https://libtmux.org/en/ruby/latest/mcp/tools/) ·
[Guides](https://libtmux.org/en/ruby/latest/mcp/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux-mcp)
Part of [libtmux for Ruby](https://github.com/libtmux/libtmux-ruby#readme).
Built on [libtmux](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux)
and [libtmux-async](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-async).
An MCP client starts `libtmux-mcp` and talks to it over stdin and stdout. The
official MCP SDK handles the protocol, and bounded Async tasks handle
transport.
**Contents** — [Quick start](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#quick-start) ·
[Connect a client](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#connect-a-client) ·
[Choose the server](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#choose-which-tmux-server-it-serves) ·
[The tools](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#the-tools) · [Read](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#read-the-layout-and-the-screen) ·
[Create](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#create-type-and-close) · [Run](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#run-a-script-in-a-pane) ·
[Embed](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#embed-it-in-ruby) · [Leaves out](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#what-it-leaves-out) ·
[Support](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#support-and-status) · [Documentation](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#documentation)
## Quick start
Install the alpha and its `libtmux-mcp` executable. It needs Ruby 3.3 or newer
and tmux 3.3a or newer:
```console
$ gem install libtmux-mcp --pre
```
The server borrows a tmux server that is already running. Start one on a
socket of its own:
```console
$ tmux -L agent new-session -d -s work
```
Add the server to Claude Code. Until you enable more tools, it serves
[`tmux_capabilities`][tool-tmux_capabilities] and
[`tmux_snapshot`][tool-tmux_snapshot]:
```console
$ claude mcp add tmux -- libtmux-mcp --socket-name agent --endpoint dev
```
Run by hand, `libtmux-mcp` waits for input until EOF. `libtmux-mcp --help`
lists every option.
## Connect a client
### `claude mcp add`: Claude Code
The command in the quick start registers the server with Claude Code. Start the
tmux server first, as above.
### `codex mcp add`: Codex CLI
Codex CLI takes the same command after `--`:
```console
$ codex mcp add tmux -- libtmux-mcp --socket-name agent --endpoint dev
```
### `mcpServers`: clients that read JSON
A client that reads a JSON configuration, such as Claude Desktop's
`claude_desktop_config.json`, takes the same command as an `mcpServers` entry:
```json
{
"mcpServers": {
"tmux": {
"command": "libtmux-mcp",
"args": ["--socket-name", "agent", "--endpoint", "dev"]
}
}
}
```
If the client does not start servers with your shell's `PATH`, set `command` to
the absolute path that `command -v libtmux-mcp` prints.
## Choose which tmux server it serves
### `--socket` and `--socket-name`: pick the daemon
Set `TMUX_SOCKET` to an existing tmux socket. This command borrows that daemon
and serves MCP on stdin and stdout:
```console
$ libtmux-mcp \
--socket "$TMUX_SOCKET" \
--endpoint local
```
Use `--socket-name NAME` instead of `--socket PATH` to select a named socket,
as the quick start does:
```console
$ libtmux-mcp \
--socket-name agent
```
- EOF retires the clients the server owns and leaves the daemon running.
- `--endpoint` sets the public alias in discovery and resource URIs, and
defaults to `local`.
## The tools
Each tool name links to its page on libtmux.org, with the arguments, limits and
result schema. Repeat `--enable-tool` for each additional tool.
| Tools | Default | Purpose |
| --- | --- | --- |
| [`tmux_capabilities`](https://libtmux.org/en/ruby/latest/mcp/tools/tmux_capabilities/), [`tmux_snapshot`](https://libtmux.org/en/ruby/latest/mcp/tools/tmux_snapshot/) | Enabled | Discover capabilities and query captured metadata |
| [`tmux_capture`](https://libtmux.org/en/ruby/latest/mcp/tools/tmux_capture/), [`tmux_wait`](https://libtmux.org/en/ruby/latest/mcp/tools/tmux_wait/) | Disabled | Capture a screen or wait for text/process exit |
| [`tmux_create`](https://libtmux.org/en/ruby/latest/mcp/tools/tmux_create/), [`tmux_send`](https://libtmux.org/en/ruby/latest/mcp/tools/tmux_send/), [`tmux_close`](https://libtmux.org/en/ruby/latest/mcp/tools/tmux_close/) | Disabled | Create entities, send text/keys and tear down exact targets |
| [`tmux_run`](https://libtmux.org/en/ruby/latest/mcp/tools/tmux_run/) | Disabled | Run a script in an explicitly enrolled zsh shell |
- Disabled tools are absent from discovery and denied on direct application
calls.
- An unknown tool name is refused when the server starts.
The [complete protocol recipe](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/mcp_protocol.rb) exercises
discovery, snapshots, default denial, enabled mutations, cancellation and EOF
cleanup through actual pipes, including the installed executable.
## Read the layout and the screen
### [`tmux_snapshot`][tool-tmux_snapshot]: the layout, in pages
- Pages come from one immutable capture, and a cursor continues that capture.
- An expired, evicted or foreign cursor returns an error. The server never
substitutes a fresh listing.
### [`tmux_capture`][tool-tmux_capture]: a pane's screen
Enable the screen tools together:
```console
$ libtmux-mcp \
--socket "$TMUX_SOCKET" \
--enable-tool tmux_capture \
--enable-tool tmux_wait
```
- It reads a bounded screen and keeps its line endings. Bytes that are not
valid UTF-8 come back base64-encoded.
- With tracking, a call returns a cursor, and later calls return a splice
against that exact captured state. A cursor from another server generation
or from a respawned pane is refused.
- It refuses a pane whose effective [`after-capture-pane`](https://libtmux.org/en/tmux/latest/catalog/hooks/after-capture-pane/) hook is not empty,
including inherited entries.
- On tmux 3.3a to 3.4 the hook is checked before the capture command runs, so
keep hook configuration stable while observing.
### [`tmux_wait`][tool-tmux_wait]: wait for text or exit
- It waits for screen text, or for the pane process to exit. Screen text
comes from control events on tmux 3.7 and newer, and from polling the pane
every 50 ms on older daemons, which take no control client. Process exit
uses process descriptors.
- Wrapped rows are joined, so text that the pane width split across rows
still matches.
- If the pane, or the tmux server holding it, ends before the text appears,
the call fails with `pane_died`, `delivery: observed` and the last rows it
read in the error's [`capture`](). If only the control stream ends while the
pane lives, such as after the client detaches, the failure is
`observation_lost`.
- A cancelled or expired wait closes its observers and never signals the pane
program.
- Process tracking needs a native identity backend: Linux peer pidfds with
matching PID namespaces, or Darwin kqueue. Without one, the call is refused.
### [Resource templates][mcp-resources]: the same data as URIs
[`tmux_metadata`][resource-tmux_metadata],
[`tmux_metadata_page`][resource-tmux_metadata_page] and
[`tmux_screen`][resource-tmux_screen] expose metadata pages and pane screens
under endpoint and generation URIs, with the same policy and limits as their
tools.
- The server does not advertise resource subscriptions.
- [Snapshots, cursors and references][mcp-snapshots-topic] has the full
contract.
## Create, type and close
### [`tmux_create`][tool-tmux_create]: new sessions, windows and panes
Enable the three tools together:
```console
$ libtmux-mcp \
--socket-name agent \
--enable-tool tmux_create \
--enable-tool tmux_send \
--enable-tool tmux_close
```
- It takes argument arrays as [`argv`]().
- Results carry the references tmux returned.
### [`tmux_send`][tool-tmux_send]: literal text or named keys
- Text and keys are separate variants.
- It reports `dispatch_only`: the input was dispatched, and the command has not
necessarily finished.
- After a cancellation, the effect stays unknown and is not reported as none.
### [`tmux_close`][tool-tmux_close]: an exact target
- It takes an exact session, window or pane reference, and never selects by
name.
## Run a script in a pane
### [`tmux_run`][tool-tmux_run]: authored commands in an enrolled zsh
[`tmux_run`][tool-tmux_run] runs a POSIX script in a pane's interactive zsh
5.9. It needs both the tool and an enrolled pane.
List the pane IDs of the server:
```console
$ tmux -L agent list-panes -a -F '#{pane_id}'
```
```text
%0
```
Enable the tool and write a setup file for one exact pane:
```console
$ libtmux-mcp \
--socket-name agent \
--enable-tool tmux_run \
--enroll-pane %0=enroll.zsh
```
Then, in that pane's zsh, run `source enroll.zsh`. A relative path resolves
from the directory where the server starts.
- `--enroll-pane` requires `--enable-tool `[`tmux_run`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/), and each pane and each
file may appear once.
- The server writes a private file (mode `0600`) and never types into the
terminal. It refuses an existing file or a symlink.
- Setup files expire. `--enrollment-timeout SECONDS` sets the lifetime, at most
300.
- EOF retires pending enrollment and removes only the files the server wrote.
- A call takes an exact pane [`target`](), a POSIX `script`, and optional
`stdout_limit` and `stderr_limit` byte counts.
- The script runs with the shell's working directory and exported environment.
- Stdout and stderr come back separately, as UTF-8 or base64.
- A nonzero exit or a signal is a completion result. Output over its limit is
an error with completion unobserved, and never a truncated success.
- Cancelling a run does not prove that its child processes stopped.
## Embed it in Ruby
Require `libtmux/mcp`. Imports start no tmux process, scheduler or MCP server.
The [execution guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/transports/) covers result and ownership
boundaries.
### [`LibTmux::MCP::Application`][mcp-application]: serve from your own program
[`Application`][mcp-application] borrows an application-owned
[`LibTmux::Async::Server`][async-server]. Its
[`sdk_server`][mcp-application-sdk_server] supplies the SDK server that
[`StdioTransport`][mcp-stdiotransport] consumes:
```ruby
application = LibTmux::MCP::Application.new(server: scope.server, endpoint_name: "example")
sdk = application.sdk_server
input, client_input = IO.pipe
client_output, output = IO.pipe
transport = LibTmux::MCP::StdioTransport.new(server: sdk, parent: parent, input: input, output: output)
runner = parent.async { transport.run }
```
The [complete program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/mcp_protocol.rb) runs this excerpt inside
an Async task with an open [`LibTmux::Async`][async] scope. It sends real
JSON-RPC messages through the pipes, checks the replies, and prints
`PASS mcp_protocol`.
### [`Application#invite_shell`][mcp-application-invite_shell]: enroll a shell from Ruby
Call [`invite_shell`]() with a pane reference, `timeout:` and `expires_in:`, then
pass the invitation to [`accept_shell`][mcp-application-accept_shell].
- The invitation's `shell_arguments` make up the setup command to source in
that pane's zsh.
- `timeout:` bounds acquisition, and `expires_in:` sets the enrollment
lifetime.
- The application owns invitations and accepted connections until
[`close`][mcp-application-close]. Direct enrollment calls enforce tool
policy.
## What it leaves out
- **Tools you have not enabled.** Disabled tools are absent from discovery,
and a direct application call is denied. See [The tools](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/#the-tools).
- **Resource subscriptions.** The server does not advertise them. See the
[resource templates][mcp-resources].
- **Typing into your terminal.** The server writes a private setup file and
never types into a pane's terminal to enroll it. See
[`tmux_run`][tool-tmux_run].
- **A guaranteed stop.** Cancelling a run does not prove that its child
processes stopped. See [`tmux_run`][tool-tmux_run].
## Support and status
**Alpha.** APIs may change between releases.
- **Ruby 3.3 or newer.** The gem depends on `libtmux` and `libtmux-async` at
the same version, the `mcp` SDK 1.5, `digest` and `optparse`.
- **tmux 3.3a or newer.** The server refuses an older daemon when it starts,
before it serves any tool, and prints the reason and the remedy on stderr.
- **A daemon that changes while it runs.** A tool call returns an
`unsupported` result with `delivery: not_sent`. The result names the floor
and says to upgrade tmux and restart the server.
- **The `screen_contains` wait.** It uses control events on tmux 3.7 and
newer and polls the pane screen on older daemons, which take no control
client.
- **Linux, including WSL, and macOS.** The core
[compatibility workflow][compat] runs Ruby 3.3, 3.4 and 4.0 with tmux 3.3a
through 3.8 on Ubuntu 24.04. macOS is supported on a best-effort basis, and
CI coverage for it is highly limited.
## Documentation
| | |
| --- | --- |
| [Reference](https://libtmux.org/en/ruby/latest/mcp/reference/) | The embedding types and methods |
| [Tools](https://libtmux.org/en/ruby/latest/mcp/tools/) | One page per tool, with arguments, limits and result schema |
| [Guides][mcp-guides] | Connect a client to a private tmux server and select its tools |
| [Resources][mcp-resources] | Metadata pages and pane screens as URIs |
| [Public behavior][behavior-mcp-application] | The application, transport and command |
[async]: https://libtmux.org/en/ruby/latest/reference/libtmux-async/
[async-server]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-server/
[behavior-mcp-application]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#mcp-application
[compat]: https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml
[mcp-application]: https://libtmux.org/en/ruby/latest/mcp/reference/libtmux-mcp-application/
[mcp-application-accept_shell]: https://libtmux.org/en/ruby/latest/mcp/reference/libtmux-mcp-application-accept_shell/
[mcp-application-close]: https://libtmux.org/en/ruby/latest/mcp/reference/libtmux-mcp-application-close/
[mcp-application-invite_shell]: https://libtmux.org/en/ruby/latest/mcp/reference/libtmux-mcp-application-invite_shell/
[mcp-application-sdk_server]: https://libtmux.org/en/ruby/latest/mcp/reference/libtmux-mcp-application-sdk_server/
[mcp-guides]: https://libtmux.org/en/ruby/latest/mcp/guides/
[mcp-resources]: https://libtmux.org/en/ruby/latest/mcp/resources/
[mcp-snapshots-topic]: https://libtmux.org/en/ruby/latest/mcp/topics/snapshots-and-references/
[mcp-stdiotransport]: https://libtmux.org/en/ruby/latest/mcp/reference/libtmux-mcp-stdiotransport/
[resource-tmux_metadata]: https://libtmux.org/en/ruby/latest/mcp/resources/templates/tmux_metadata/
[resource-tmux_metadata_page]: https://libtmux.org/en/ruby/latest/mcp/resources/templates/tmux_metadata_page/
[resource-tmux_screen]: https://libtmux.org/en/ruby/latest/mcp/resources/templates/tmux_screen/
[tool-tmux_capabilities]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_capabilities/
[tool-tmux_capture]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_capture/
[tool-tmux_close]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_close/
[tool-tmux_create]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_create/
[tool-tmux_run]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_run/
[tool-tmux_send]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_send/
[tool-tmux_snapshot]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_snapshot/
[tool-tmux_wait]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_wait/
---
# Workspace guide
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/
> Workspace guide: libtmux documentation.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
[Load][workspace-load] bounded YAML or JSON, inspect an immutable
[creation plan][workspace-plan-class], then explicitly
[apply][workspace-plan-apply] it to an open libtmux server.
[API reference](https://libtmux.org/en/ruby/latest/workspace/reference/) ·
[Command reference](https://libtmux.org/en/ruby/latest/workspace/cli/) ·
[Guides](https://libtmux.org/en/ruby/latest/workspace/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux-workspace)
Part of [libtmux for Ruby](https://github.com/libtmux/libtmux-ruby#readme).
Built on [libtmux](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux).
Check a workspace file, see the ordered steps a load would run, and create the
session on a running tmux server, from the `libtmux-workspace` command or from
Ruby.
Validation and offline planning need no running daemon, and imports start no
tmux process.
**Contents** — [Quick start](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#quick-start) ·
[Write the file](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#write-the-file) ·
[Create the session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#create-the-session) ·
[Failed apply](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#recover-from-a-failed-apply) ·
[Attach or switch](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#attach-or-switch-to-the-new-session) ·
[Scripts](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#script-it) · [Leaves out](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#what-it-leaves-out) ·
[Support](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#support-and-status) · [Documentation](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#documentation)
## Quick start
Install the alpha and its `libtmux-workspace` executable. It needs Ruby 3.3 or
newer, and tmux 3.3a or newer to load a plan:
```console
$ gem install libtmux-workspace --pre
```
Save this declared subset of tmuxp-style data as `workspace.yaml`. Relative
directories resolve against the configuration file's directory.
```yaml
session_name: work
environment:
PROJECT_MODE: development
windows:
- window_name: editor
window_index: 1
layout: tiled
panes:
- shell_command: printf 'editor ready\n'
- {}
```
Check the file. [`validate`][cli-validate] reads no tmux state:
```console
$ libtmux-workspace validate workspace.yaml
```
```text
Workspace configuration is valid.
```
Print the ordered operations a load would run. Offline [`plan`][cli-plan] does
not contact tmux either:
```console
$ libtmux-workspace plan workspace.yaml
```
```text
offline_create: 11 ordered steps
1. create_session session (creation)
2. set_session_option session (configuration)
3. set_window_option window:0 (configuration)
4. move_initial_window window:0 (configuration)
5. split_pane pane:0:0 (creation)
6. select_layout window:0 (configuration)
7. send_command pane:0:0 (dispatch_only)
8. unset_window_option window:0 (configuration)
9. select_pane pane:0:0 (configuration)
10. select_window window:0 (configuration)
11. unset_session_option session (configuration)
```
## Write the file
### [`Workspace.load`][workspace-load]: the declared subset
[`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) reads a regular file of bounded size and infers JSON or YAML from its
extension. [`Workspace.parse`][workspace-parse] takes the text and a base
directory instead. Both return an immutable workspace:
- Root: [`session_name`](https://libtmux.org/en/tmux/latest/catalog/formats/session_name/), nonempty `windows`, `options`, `window_options`.
- Window: [`window_name`](https://libtmux.org/en/tmux/latest/catalog/formats/window_name/), nonempty `panes`, [`window_index`](https://libtmux.org/en/tmux/latest/catalog/formats/window_index/), `focus`, [`layout`](),
`options`.
- Pane: a command string, or a mapping with `focus`, `split` and [`size`]().
- Root, windows and panes accept `start_directory`, `environment`,
`shell_command` and `shell_command_before`.
- Layouts are `even-horizontal`, `even-vertical`, `main-horizontal`,
`main-vertical` and `tiled`.
- At most one window and one pane per window declare focus.
- Without a filename, the command looks for exactly one `.tmuxp.yaml`,
`.tmuxp.yml` or `.tmuxp.json` in the current directory.
- An unknown field or an unsupported feature fails with a
[`ConfigError`][workspace-configerror] that names its position in the file.
- YAML tags, anchors and aliases are rejected, and no Ruby, ERB, plugins or
callbacks run.
- `${NAME}` substitution is opt-in: pass
`expand_environment: true, environment: {"NAME" => "value"}` to [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) or
[`parse`](), or `--expand-environment --env NAME=VALUE` to the command.
- [`workspace.to_h`][workspace-to_h] exports an immutable, normalized and
reloadable configuration, with expanded values and absolute directories.
The full field, option and limit lists are in
[Workspace parsing][behavior-workspace-parsing].
## Create the session
### [`libtmux-workspace load`][cli-load]: build it on a running server
[`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) needs a running server. It never starts one, so start a private server
with a keepalive session and no user configuration:
```console
$ WORKSPACE_TMP=$(mktemp -d)
```
```console
$ tmux -S "$WORKSPACE_TMP/tmux.sock" -f /dev/null new-session -d -s keepalive
```
Create the workspace's session on that socket. It stays detached:
```console
$ libtmux-workspace load \
--socket "$WORKSPACE_TMP/tmux.sock" \
workspace.yaml
```
```text
Workspace created; 11 steps completed. Shell commands were dispatched.
```
The new `work` session holds the `editor` window:
```console
$ tmux -S "$WORKSPACE_TMP/tmux.sock" list-windows -t work
```
Stop only the private server and remove its directory:
```console
$ tmux -S "$WORKSPACE_TMP/tmux.sock" kill-server
```
```console
$ rm -rf "$WORKSPACE_TMP"
```
Loading the same file again fails with status 1: a plan creates a new session
and never reconciles an existing one.
### [`Plan#apply`][workspace-plan-apply]: the same from Ruby
[`Workspace.load`][workspace-load] reads the file,
[`workspace.plan`][workspace-plan-method] plans it against a snapshot, and
[`apply`]() creates the session. Calling [`apply`]() authorizes the configuration's
shell commands:
```ruby
require "libtmux"
require "libtmux/workspace"
LibTmux::Server.start do |server|
workspace = LibTmux::Workspace.load(File.expand_path("../workspace.yaml", __dir__))
plan = workspace.plan(snapshot: server.snapshot)
puts "planned steps: #{plan.steps.length}"
result = plan.apply(server: server)
puts "applied: #{result.success?}"
puts "sessions: #{server.list_sessions.map { |session| session.snapshot.name }.join(', ')}"
end
```
The program runs next to the [`workspace.yaml`]() above, on a private server, and
prints:
```text
planned steps: 11
applied: true
sessions: work
```
- A snapshot makes the plan reject a name that already exists, and every
[`apply`]() takes a fresh snapshot and checks again.
- The plan creates a new session. It does not reconcile, replace or remove an
existing one.
- Success shows that tmux accepted the dispatch of each shell command. It does
not show that the command finished.
The [complete program](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/workspace_apply.rb) also runs the
installed command with `--switch`. The contract is in
[Workspace apply][behavior-workspace-apply].
## Recover from a failed apply
### [`ApplyError#result`][workspace-applyerror-result]: what exists after a failure
A failed apply raises [`ApplyError`][workspace-applyerror]. Its immutable
[`result`]() holds the completed step IDs, the
[`created_refs`][workspace-applyresult-created_refs] tmux returned, the
effects it observed, and the failed action. Pass `compensate: true` to remove
only the session the apply created:
```ruby
require "json"
require "libtmux"
require "libtmux/workspace"
LibTmux::Server.start do |server|
server.new_session(name: "borrowed", command: ["/bin/cat"])
crowded = LibTmux::Workspace.parse(
JSON.generate({session_name: "crowded", windows: [{window_name: "small", panes: Array.new(40) { {} }}]}),
format: :json, base_directory: __dir__
)
begin
crowded.plan.apply(server: server, compensate: true)
rescue LibTmux::Workspace::ApplyError => error
puts "failed action: #{error.result.failed_action}"
puts "created a session: #{error.result.created_refs.key?('session')}"
puts "compensation: #{error.result.compensation}"
end
puts "sessions: #{server.list_sessions.map { |session| session.snapshot.name }.join(', ')}"
end
```
That many panes do not fit in one window, so tmux refuses a split after the
session exists. It prints:
```text
failed action: split_pane
created a session: true
compensation: completed
sessions: borrowed
```
- Compensation removes the new session only after a tmux guard shows that
every window and pane in it has a positively identified created reference.
- An unknown initial entity, or a borrowed entity moved into the session,
makes it refuse.
- Compensation cannot undo what shell commands did. Without it, the partial
state stays for you to inspect.
- Diagnostics omit command payloads and paths. Names are never used to guess
ownership.
The command takes `--compensate`. The contracts are in
[Workspace results][behavior-workspace-results].
## Attach or switch to the new session
### [`load --switch`][cli-load]: move a client to the session
- [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/)` `[`--attach`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/#options-attach) opens the CLI's `/dev/tty` after creation and runs an owned
terminal client until you detach. It requires a valid `TERM`.
- [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/)` `[`--switch`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/#options-switch-client)` CLIENT` switches a current tmux client to the created session
after apply, keeping the session's environment.
- `CLIENT` is a client name, a full TTY path or a TTY path without `/dev/`.
Use `--switch=VALUE` for a selector that begins with `-`.
- A missing client, or a failure to open or attach the terminal, keeps the
created session and returns status 3.
- Attach and switch are mutually exclusive, and neither infers a latest
client. The library's [`Plan#apply`][workspace-plan-apply] does neither.
The selector rules are in [Client switching][behavior-client-switching].
## Script it
### [`--json`][cli-load]: one object on stdout
Check the installed gem version without reading a configuration or contacting
tmux:
```console
$ libtmux-workspace --version
```
Human plans list ordered operations and their effects. `--json` prints the
same plan data as [`Plan#to_h`][workspace-plan-to_h], including configured
command text and paths:
```console
$ libtmux-workspace plan \
--json \
workspace.yaml
```
[`load`][cli-load] and [`plan --live`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/) require `--socket` for an existing
server. This detached creation example uses an explicitly supplied
`TMUX_SOCKET` value:
```console
$ libtmux-workspace load \
--socket "$TMUX_SOCKET" \
--json \
workspace.yaml
```
`libtmux-workspace --help` lists every option. The
[command reference][ws-cli] has a page for each command.
| Option | Effect |
| --- | --- |
| `--json` | Write one structured result or error object to stdout |
| `--socket PATH` | Select the existing server's socket for [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) or [`plan --live`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/) |
| `--live` | Capture a snapshot before planning |
| `--timeout SECONDS` | Bound each apply, live capture or switch operation; the default is 5 |
| `--compensate` | Run guarded cleanup after an apply failure |
| `--attach` | Attach this CLI's terminal after a successful [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) |
| `--switch CLIENT` | Switch an explicit current client to the new session after [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) |
| `--expand-environment` | Expand `${NAME}` in directories and environment values; requires `--env` |
| `--env NAME=VALUE` | Supply a value for expansion; ambient environment variables are not copied |
| Exit status | Meaning |
| --- | --- |
| 0 | Validation, planning or apply succeeded; requested attach/switch succeeded |
| 1 | Execution failed before known application effects |
| 2 | Configuration or arguments are invalid |
| 3 | Application was partial or uncertain, or a later attach/switch/cleanup failed |
| 130 | Interrupted; available effect ledger is retained |
Apply errors include [`ApplyResult#to_h`][workspace-applyresult-to_h]. Human
errors write the diagnostic and any ledger to stderr. Diagnostics omit
configuration payloads; plan rendering and canonical export contain those
values by design.
## What it leaves out
- **Reconciliation.** A plan creates a new session and never replaces or
removes an existing workspace. The contract is in
[Workspace plans][behavior-workspace-plans].
- **Shell command completion.** Apply records a shell command as dispatched.
Embedded newlines can execute while the text is inserted. See
[Workspace apply][behavior-workspace-apply].
- **Rollback of shell effects.** Compensation removes only tmux objects the
apply created. See [Workspace results][behavior-workspace-results].
- **Features beyond the declared subset.** Plugins, ERB and callbacks are
rejected, and a [`ConfigError`][workspace-configerror] names the position.
- **A guessed client.** Attach and switch need an explicit client. See
[Client switching][behavior-client-switching].
## Support and status
**Alpha.** APIs may change between releases.
- **Ruby 3.3 or newer.** The gem depends on the same version of `libtmux`,
JSON 3.0 and Psych 5.5.
- **tmux 3.3a or newer** to load or apply a plan.
- **Older daemons.** [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) creates nothing and prints the refusal with the
floor and the remedy. With `--json`, the refusal is in `error.message` and
`error.kind` is `tmux_unsupported`.
- **Linux, including WSL, and macOS.** The library and the command share the
core [compatibility workflow][compat]: Ruby 3.3, 3.4 and 4.0 with tmux 3.3a
through 3.8 on Ubuntu 24.04, with per-revision results. macOS is supported on
a best-effort basis, and CI coverage for it is highly limited.
- **History limit.** On tmux 3.3a to 3.6 the reused initial pane keeps the
global [`history-limit`](https://libtmux.org/en/tmux/latest/catalog/options/history-limit/). Set the server's global value before you apply to
get one history size.
## Documentation
| | |
| --- | --- |
| [Reference](https://libtmux.org/en/ruby/latest/workspace/reference/) | Every public workspace class and method |
| [Command reference][ws-cli] | A page for [`validate`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/validate/), [`plan`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/) and [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) |
| [Guides][workspace-guides] | Validate, inspect and explicitly apply a plan |
| [Topics][workspace-topics] | Format, planning boundaries, effects and failure ledgers |
| [Public behavior][behavior-workspace-parsing] | Parsing, plans, apply, results and the command |
| [Recipes][doc-recipes] | The workspace plan, load and failure program |
[behavior-client-switching]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#client-switching
[behavior-workspace-apply]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#workspace-apply
[behavior-workspace-parsing]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#workspace-parsing
[behavior-workspace-plans]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#workspace-plans
[behavior-workspace-results]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#workspace-results
[cli-load]: https://libtmux.org/en/ruby/latest/workspace/cli/load/
[cli-plan]: https://libtmux.org/en/ruby/latest/workspace/cli/plan/
[cli-validate]: https://libtmux.org/en/ruby/latest/workspace/cli/validate/
[compat]: https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml
[doc-recipes]: https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/
[workspace-applyerror]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-applyerror/
[workspace-applyerror-result]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-applyerror-result/
[workspace-applyresult-created_refs]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-applyresult-created_refs/
[workspace-applyresult-to_h]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-applyresult-to_h/
[workspace-configerror]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-configerror/
[workspace-guides]: https://libtmux.org/en/ruby/latest/workspace/guides/
[workspace-load]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-load/
[workspace-parse]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-parse/
[workspace-plan-apply]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-plan-apply/
[workspace-plan-class]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-plan-1qko/
[workspace-plan-method]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-plan-1c5c/
[workspace-plan-to_h]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-plan-to_h/
[workspace-to_h]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace-to_h/
[workspace-topics]: https://libtmux.org/en/ruby/latest/workspace/topics/
[ws-cli]: https://libtmux.org/en/ruby/latest/workspace/cli/
---
# Server bindings
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/
> Own a private server or connect to an existing socket.
Drive tmux from Ruby: [sessions][session], [windows][window] and [panes][pane]
as handles, [snapshots][snapshot] you filter in plain Ruby, and
[control connections][controlconnection] that report what tmux does.
[API reference](https://libtmux.org/en/ruby/latest/reference/) ·
[Guides](https://libtmux.org/en/ruby/latest/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux)
Part of [libtmux for Ruby](https://github.com/libtmux/libtmux-ruby#readme).
This gem is the core; the [packages below](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#packages) build on it.
[Create][server-new_session] and [split][pane-split] windows,
[read][server-snapshot] and [filter][selection-where] what a server holds, and
[type into a pane][pane-send_text] and capture what it shows.
It suits scripts, tests that need a real tmux, and tools that drive a terminal
program. [Cancel][cancellation-cancel] a request that is waiting, and
[follow events][controlconnection-subscribe] as tmux emits them.
**Contents** — [Quick start](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#quick-start) ·
[Find things](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#find-sessions-windows-and-panes) ·
[Create](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#create-sessions-windows-and-panes) ·
[Type and read](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#type-into-a-pane-and-read-it-back) ·
[Your own server](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#use-the-tmux-server-you-already-run) ·
[Cancel](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#wait-time-out-and-cancel) ·
[Link windows](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#link-a-window-into-several-sessions) ·
[Options](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#read-and-set-options-and-hooks) ·
[Watch tmux](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#watch-tmux-change) ·
[Groups](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#run-several-commands-in-order) ·
[Packages](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#packages) · [Leaves out](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#what-it-leaves-out) ·
[Support](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#support-and-status) · [Documentation](https://libtmux.org/en/ruby/v0.1.0.alpha.3/guides/core/#documentation)
## Quick start
Install the alpha. It needs Ruby 3.3 or newer and tmux 3.3a or newer on
`PATH`:
```console
$ gem install libtmux --pre
```
This program creates a session, adds a window, splits it, and prints each
window with its panes. [`Server.start`][server-start] closes its private tmux
server when the block exits, and the snapshot stays readable afterward:
```ruby
require "libtmux"
snapshot = LibTmux::Server.start do |server|
session = server.new_session(name: "work", window_name: "main", command: ["/bin/cat"])
window = session.new_window(name: "logs", command: ["/bin/cat"])
window.split(direction: :horizontal, size: "40%", command: ["/bin/cat"])
server.snapshot
end
snapshot.windows.each do |window|
puts "#{window.name}: #{window.panes.map(&:id).join(', ')}"
end
```
It prints:
```text
main: %0
logs: %1, %2
```
Requiring the gem starts no tmux process, scheduler or MCP server.
[`Server.start`][server-start] gives its tmux server a socket and an empty
configuration of its own, so it never touches a tmux you already use.
## Find sessions, windows, and panes
### [`Server#list_sessions`][server-list_sessions]: what tmux has now
One call asks tmux for every session and returns frozen handles in numeric ID
order. [`list_windows`][server-list_windows] and
[`list_panes`][server-list_panes] are its siblings, and
[`Session#list_windows`][session-list_windows] and
[`Window#list_panes`][window-list_panes] narrow them:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
server.new_session(name: "work", command: ["/bin/cat"])
server.new_session(name: "logs", command: ["/bin/cat"])
sessions = server.list_sessions
puts "sessions: #{sessions.map(&:id).sort.join(', ')}"
end
```
It runs on a private server and prints:
```text
sessions: $0, $1
```
An empty array means tmux answered with nothing to list. A listing that fails
raises [`CommandError`][commanderror].
### [`Server#snapshot`][server-snapshot]: one read, many queries
Read the server once, then filter that read with
[`where`][selection-where], [`select`][selection-select],
[`one`][selection-one] and [`one_or_nil`][selection-one_or_nil]. These queries
make no tmux calls. Continue with the snapshot from the quick start:
```ruby
panes = snapshot.panes
active_ids = panes.where(active: true).map(&:id)
wide_panes = panes.select { |pane| pane.width >= 40 }
panes_by_window = panes.group_by { |pane| pane.window.name }
logs = snapshot.windows.one(name: "logs")
missing = snapshot.windows.one_or_nil(name: "missing")
```
[`one`]() raises [`NoMatchError`][nomatcherror] or
[`MultipleMatchesError`][multiplematcheserror] unless exactly one record
matches. [`one_or_nil`]() returns `nil` for no match and still rejects duplicates.
A selection keeps the membership it captured, so call [`server.snapshot`]() again
to read later changes. The [field catalog](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/fields.md)
lists every query field and wire name.
### [`Server#search_panes`][server-search_panes]: the matching panes in one call
`search_panes` captures the server and answers a selection of the panes whose
fields match `where:`. [`explain_panes`][server-explain_panes] shows the plan
without running tmux. This program also uses the snapshot queries above:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
work = server.new_session(name: "work", command: ["/bin/cat"], receipt: true)
server.new_session(name: "logs", command: ["/bin/cat"])
snapshot = server.snapshot
session = snapshot.sessions.where(name: "work").one
puts "matching session: #{session.name}"
missing = snapshot.sessions.one_or_nil(name: "missing")
puts "missing session: #{missing.nil?}"
panes = server.search_panes(where: {id: work.pane.id})
puts "matching pane: #{panes.one.id}"
end
```
It prints:
```text
matching session: work
missing session: true
matching pane: %0
```
## Create sessions, windows, and panes
### [`Server#new_session`][server-new_session]: a session and its first window
`new_session` starts a detached session that runs `command:`, an argv array.
Ask for a receipt to read the IDs tmux assigned to the session, window and
pane:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
created = server.new_session(
name: "work", window_name: "main", command: ["/bin/cat"], receipt: true
)
puts "session: #{created.entity.id}"
puts "window: #{created.window.id}"
puts "pane: #{created.pane.id}"
end
```
It prints:
```text
session: $0
window: @0
pane: %0
```
Creation returns once tmux has assigned the IDs. It says nothing about whether
the program started or exited cleanly.
### [`Session#new_window`][session-new_window]: add a window
[`Pane#split`][pane-split] and [`Window#split`][window-split] add panes the
same way. A new window takes a `name:` and the same `command:` as a session:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
session = server.new_session(name: "work", command: ["/bin/cat"])
window = session.new_window(name: "logs", command: ["/bin/cat"])
puts "window: #{window.snapshot.name}"
puts "session windows: #{session.list_windows.length}"
end
```
It prints:
```text
window: logs
session windows: 2
```
- `cwd:` names a directory on the machine running Ruby, and is checked before
the command is sent.
- `environment:` is a String-to-String map of literal values.
- [`new_window(index:)`]() refuses a slot that is taken.
- [`Pane#split`][pane-split] targets that exact pane, and `size:` is a cell
count or a percentage string such as `"40%"`.
- New windows and splits keep focus unless you pass `focus: true`.
The full contract is in [Creation][behavior-creation].
## Type into a pane and read it back
### [`Pane#send_text`][pane-send_text]: type, then read what the pane showed
[`send_text`]() types literal text, and [`send_keys`][pane-send_keys] sends tmux key
names such as `Enter`. [`Pane#capture`][pane-capture] reads the screen.
To wait for output, poll the pane until the line appears. A
[control connection][server-open_control] reports it as an event instead, but
needs tmux 3.7 or newer:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
created = server.new_session(
name: "capture", command: ["/bin/sh"],
environment: {"ENV" => "/dev/null"}, receipt: true
)
pane = created.pane
pane.send_text("printf '\\nlibtmux capture ready\\n'")
pane.send_keys("Enter")
deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
captured = pane.capture.stdout.lines(chomp: true)
until captured.include?("libtmux capture ready")
raise "Output did not arrive within five seconds" if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
sleep 0.05
captured = pane.capture.stdout.lines(chomp: true)
end
raise "Expected output is absent from the pane" unless captured.include?("libtmux capture ready")
puts "libtmux capture ready"
end
```
It prints:
```text
libtmux capture ready
```
- Sending input does not show that the shell finished the command.
- [`capture`]() returns the visible screen. `start:` and `finish:` choose a range,
and `join:` joins wrapped lines.
- `escapes:`, `escape_bytes:`, `preserve_trailing:` and `trim_trailing:` change
the bytes it returns.
- `mode_screen:`, `alternate:` and `pending:` read a copy-mode screen, the saved
screen and an unfinished escape sequence. Pass at most one.
- Binary buffers keep their trailing newlines. See
[`write_buffer`][server-write_buffer] and
[`read_buffer`][server-read_buffer] in the
[layout and bytes recipe](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/#layout-and-bytes).
The full contract is in [Pane input and capture][behavior-capture].
## Use the tmux server you already run
### [`Server.new`][server-new]: borrow a daemon
[`Server.open`][server-open] and [`Server.new`][server-new] bind an endpoint
that already exists. Closing the binding retires its clients and leaves the
daemon running; [`Server#kill`][server-kill] stops it.
The outer [`Server.start`][server-start] block here only supplies a daemon to
borrow:
```ruby
require "libtmux"
LibTmux::Server.start do |owner|
owner.new_session(name: "work", command: ["/bin/cat"])
server = LibTmux::Server.new(endpoint: owner.endpoint)
begin
puts "connected sessions: #{server.list_sessions.length}"
ensure
server.close
end
puts "sessions after client close: #{owner.list_sessions.length}"
end
```
It prints:
```text
connected sessions: 1
sessions after client close: 1
```
- [`Endpoint.new`][endpoint-new] takes an explicit socket path or socket name.
[`Endpoint.from_env`][endpoint-from_env] is the opt-in for `$TMUX`.
- A binding keeps a private link to the socket it bound, so commands never
reach a different daemon that later takes the same path.
- A ref is valid on the server that issued it. Another server raises
[`TargetNotFoundError`][targetnotfounderror].
See [ownership and errors](https://libtmux.org/en/ruby/v0.1.0.alpha.3/topics/errors-and-exceptions/).
## Wait, time out, and cancel
### [`Cancellation.new`][cancellation-new]: wake a request that is waiting
Typed operations take `timeout:` and `cancel:`. Pass a
[`Cancellation`][cancellation] token as `cancel:`, call
[`cancel`][cancellation-cancel] from another thread to wake the request, join
its callers, then [`close`][cancellation-close] the token:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
server.new_session(name: "work", command: ["/bin/cat"])
cancellation = LibTmux::Cancellation.new
waiting = Thread.new do
server.run(["wait-for", "-S", "ready", ";", "wait-for", "held"], timeout: 5, cancel: cancellation)
rescue LibTmux::Cancelled => error
error
end
server.wait_for("ready", timeout: 5)
cancellation.cancel
failure = waiting.value
puts "request: #{failure.class}"
puts "delivery: #{failure.delivery}"
cancellation.close
end
```
It prints:
```text
request: LibTmux::Cancelled
delivery: possibly_sent
```
[`Cancelled`][cancelled] reports `delivery` as `:not_sent` or `:possibly_sent`.
Cancelling does not undo what tmux already queued.
The [plain-Ruby recipe](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/cancel.rb) also checks that the client
was reaped. The contracts are in
[Cancellation tokens][behavior-cancellation] and
[ownership and errors](https://libtmux.org/en/ruby/v0.1.0.alpha.3/topics/errors-and-exceptions/).
## Link a window into several sessions
### [`Session#link_window`][session-link_window]: one window at several indexes
A [`WindowLink`][windowlink] keeps a session, an index and a window ID
together, so a window linked twice stays one window. [`link_window`]() needs an
explicit `index:`:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
session = server.new_session(name: "links", command: ["/bin/cat"])
window = session.list_windows.fetch(0)
session.link_window(window.ref, index: 4)
session.link_window(window.ref, index: 9)
links = session.list_window_links
puts "indexes: #{links.map(&:index).join(', ')}"
puts "windows: #{links.map { |link| link.window.id }.uniq.join(', ')}"
end
```
It prints:
```text
indexes: 0, 4, 9
windows: @0
```
- Select, unlink, move, swap and display check the whole link identity in the
same tmux queue turn as the operation.
- A hook that waits before dispatch cannot turn a stale link into its
replacement.
- Rewriting command aliases during an operation is outside that guarantee, so
coordinate configuration changes.
The contract is in [Window links][behavior-window-links], and the
[linked-windows recipe](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/#one-window-at-three-indexes)
runs this at three indexes.
## Read and set options and hooks
### [`Session#options`][session-options]: a value with its inheritance
[`Options#set`][options-set] writes an option at the scope of its accessor.
[`Options#get`][options-get] reads it back as an
[`OptionValue`][optionvalue], and [`as`][optionvalue-as] converts it strictly.
[`Hooks#set`][hooks-set] stores a tmux command:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
session = server.new_session(name: "work", command: ["/bin/cat"])
session.options.set("history-limit", 5000)
limit = session.options.get("history-limit")
puts "history-limit: #{limit.as(:integer)}"
puts "inherited: #{limit.inherited?}"
session.hooks.set("after-new-window", command: "display-message created")
puts "hook: #{session.hooks.get('after-new-window').as(:string)}"
end
```
It prints:
```text
history-limit: 5000
inherited: false
hook: display-message created
```
- An [`OptionValue`][optionvalue] keeps the raw bytes, whether the value is
inherited, and the array index. [`as`]() takes `:bytes`, `:string`, `:integer` or
`:boolean`.
- A missing array index raises [`NoMatchError`][nomatcherror], and a present
empty value stays present.
- Reading an array without an index raises
[`MultipleMatchesError`][multiplematcheserror] when it has several entries.
- Hook values stay tmux command strings, and indexed hooks run in index order.
The contracts are in [Options and hooks][behavior-options] and
[Option values][behavior-option-values].
## Watch tmux change
### [`Server#open_control`][server-open_control]: events as they happen
A [`ControlConnection`][controlconnection] runs a command with
[`exchange`][controlconnection-exchange] and streams what tmux reports through
[`subscribe`][controlconnection-subscribe]. The subscription's
[`next`][controlsubscription-next] waits for the next
[`ControlEvent`][controlevent]:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
session = server.new_session(name: "work", command: ["/bin/cat"])
window = session.list_windows.fetch(0)
server.open_control(session: session.ref) do |control|
reply = control.exchange("display-message -p ready", timeout: 5)
puts "reply: #{reply.blocks.last.body.strip}"
events = control.subscribe(max_events: 64, max_bytes: 65_536)
window.rename("renamed")
event = events.next(timeout: 5) until event&.raw&.start_with?("%window-renamed")
puts "event: #{event.raw.strip}"
end
end
```
It prints:
```text
reply: ready
event: %window-renamed @0 renamed
```
- `exchange` answers a [`GuardedReply`][guardedreply]. It holds the blocks seen
between two boundaries, and a hook can print into the same interval.
- A subscription is bounded. A reliable one raises
[`SubscriptionOverflow`][subscriptionoverflow] when it falls behind, and a
tail one reports the lost range as a `:gap` event.
- [`pause_output`][controlconnection-pause_output] and
[`resume_output`][controlconnection-resume_output] return a
[`GuardedReply`][guardedreply]. A reply does not show that the action took
effect.
- To reconnect, close the old connection and pass it as
`open_control(session: ref, reconnect: old_connection)`. The replacement has
a new `generation`, and every new subscription starts with a `:reconnect`
gap. Nothing is replayed.
The contracts are in [Control connections][behavior-control], and the
[control overflow recipe](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/#control-overflow) runs both
subscription modes.
## Run several commands in order
### [`Server#run_group`][server-run_group]: several commands through one client
A group submits several tmux commands in order through one client. The
[`GroupResult`][groupresult] holds one aggregate status, and each step reports
`unknown`:
```ruby
require "libtmux"
LibTmux::Server.start do |server|
server.new_session(name: "work", command: ["/bin/cat"])
group = server.run_group([
["set-option", "-g", "@before", "kept"],
["select-pane", "-t", "%4294967294"],
["set-option", "-g", "@after", "never run"]
])
puts "success: #{group.success?}"
puts "steps: #{group.steps.map { |step| step.fetch(:outcome) }.join(', ')}"
puts "@before: #{server.options(scope: :session).get('@before').as(:string)}"
end
```
It prints:
```text
success: false
steps: unknown, unknown, unknown
@before: kept
```
The first command keeps its effect when the second fails, and the third never
runs. The [group recipe](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/#failure-inside-a-group) checks
the same.
## Packages
Start with `libtmux`. Add the companion for your caller:
| Gem | Require | Use it for |
| --- | --- | --- |
| [libtmux](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux) | `libtmux` | Blocking scripts, snapshots, and control connections |
| [libtmux-async](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-async) | `libtmux/async` | Concurrent commands and bounded streams in Async tasks |
| [libtmux-mcp](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-mcp) | `libtmux/mcp` | An MCP server with explicit endpoints and tool policy |
| [libtmux-workspace](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-workspace) | `libtmux/workspace` | YAML/JSON workspace plans and a CLI to apply them |
### [libtmux](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux): the core
This gem: blocking [server][server], [session][session], [window][window] and
[pane][pane] handles, immutable [snapshots][snapshot], and
[control connections][controlconnection]. The sections above run against it.
[API reference](https://libtmux.org/en/ruby/latest/reference/) ·
[Guides](https://libtmux.org/en/ruby/latest/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux)
### [libtmux-async](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-async): concurrent commands
Concurrent commands and bounded control streams inside an Async task that your
application owns. Require `libtmux/async`, then open a scope with
[`LibTmux::Async.open`][async-open].
[API reference](https://libtmux.org/en/ruby/latest/reference/libtmux-async/) ·
[Guide](https://libtmux.org/en/ruby/latest/guides/async/) ·
[RubyGems](https://rubygems.org/gems/libtmux-async)
```console
$ gem install libtmux-async --pre
```
Capture every pane concurrently with [`Scope#map`][async-scope-map]. `server`
is an open [`LibTmux::Server`][server]:
```ruby
Async do |parent|
LibTmux::Async.open(parent: parent, server: server) do |scope|
refs = scope.server.list_panes.map(&:ref)
screens = scope.map(refs, concurrency: 2) { |ref| scope.server.pane(ref).capture }
Example.check(screens.length == refs.length && screens.all?(&:success?), "concurrent captures failed")
end
end.wait
```
### [libtmux-mcp](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-mcp): a tmux server for MCP clients
An MCP server over stdio for one tmux server, with an explicit tool policy.
Installs `libtmux-mcp`; require `libtmux/mcp` to embed it through
[`LibTmux::MCP::Application`][mcp-application].
[API reference](https://libtmux.org/en/ruby/latest/mcp/reference/) ·
[Tools](https://libtmux.org/en/ruby/latest/mcp/tools/) ·
[Guides](https://libtmux.org/en/ruby/latest/mcp/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux-mcp)
```console
$ gem install libtmux-mcp --pre
```
The server borrows a tmux server that is already running. Start one on a
socket of its own:
```console
$ tmux -L agent new-session -d -s work
```
Add the server to Claude Code. Until you enable more tools, it serves
[`tmux_capabilities`][tool-tmux_capabilities] and
[`tmux_snapshot`][tool-tmux_snapshot]:
```console
$ claude mcp add tmux -- libtmux-mcp --socket-name agent --endpoint dev
```
The [MCP README](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/) covers other clients, every tool and
authored shell commands.
### [libtmux-workspace](https://github.com/libtmux/libtmux-ruby/tree/master/gems/libtmux-workspace): YAML workspaces
YAML or JSON workspaces, validated, planned offline and applied to an open
server. Installs `libtmux-workspace`; require `libtmux/workspace` to use it
from Ruby through [`LibTmux::Workspace`][workspace].
[API reference](https://libtmux.org/en/ruby/latest/workspace/reference/) ·
[Command reference](https://libtmux.org/en/ruby/latest/workspace/cli/) ·
[Guides](https://libtmux.org/en/ruby/latest/workspace/guides/) ·
[RubyGems](https://rubygems.org/gems/libtmux-workspace)
```console
$ gem install libtmux-workspace --pre
```
Save this workspace as `workspace.yaml`:
```yaml
session_name: work
environment:
PROJECT_MODE: development
windows:
- window_name: editor
window_index: 1
layout: tiled
panes:
- shell_command: printf 'editor ready\n'
- {}
```
Check it without contacting tmux:
```console
$ libtmux-workspace validate workspace.yaml
```
```text
Workspace configuration is valid.
```
The [workspace README](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/) loads it into a running
server and lists every option.
## What it leaves out
- **Live objects.** A [snapshot record][snapshot] is what tmux said when you
read it, and a [handle][server-list_sessions] reads tmux again each time you
list. See [Captured records][behavior-records] and
[Live handles][behavior-live-handles].
- **A terminal emulator.** [`Pane#capture`][pane-capture] returns the bytes
tmux holds for the screen, with the flags above to shape them.
- **An implied server.** [`Endpoint.new`][endpoint-new] needs an explicit
socket, and no API in the recipes uses the default server.
- **Replay.** A reconnected control connection reports a gap and never replays
requests or missed output. See [Control flow][behavior-control-flow].
- **Transactions.** A [group][server-run_group] runs in order and keeps the
effects of the steps before a failure.
- **Whole-program typing.** RBS declarations ship with the gem and selected
installed calls are checked. See [Signature proof][behavior-signature].
## Support and status
**Alpha.** APIs may change between releases. See the
[initial alpha notes](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/CHANGELOG.md).
- **Ruby 3.3 or newer.** The gem depends on `json`, `tmpdir`, `securerandom`,
`fiddle` and `io-console`.
- **tmux 3.3a or newer.** Unpatched 3.3 is below the minimum. A
[server handle][server] checks the connected daemon's release before it sends
a command, and refuses an older daemon even when its client is newer.
- **Control connections need tmux 3.7 or newer.** An older daemon refuses
[`open_control`][server-open_control] before a control client attaches.
Subprocess operations and snapshots do not need it. The
[optional feature table](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#optional-tmux-features)
lists the other per-release requirements.
- **Linux, including WSL, and macOS.** The [compatibility workflow][compat]
runs Ruby 3.3, 3.4 and 4.0 with tmux 3.3a through 3.8 on Ubuntu 24.04.
macOS is supported on a best-effort basis, and CI coverage for it is highly
limited.
- **tmux master and old daemons.** On Ubuntu the workflow also runs the suite
against a pinned tmux master, and checks that tmux 3.0a, 3.1c, 3.2a and 3.3
daemons are refused.
- **Per-revision results.** Read the workflow's results for your revision
before relying on one combination.
## Documentation
| | |
| --- | --- |
| [Reference](https://libtmux.org/en/ruby/latest/reference/) | Every public class and method, one page each |
| [Guides](https://libtmux.org/en/ruby/latest/guides/) | Getting started, server bindings and the Async scope |
| [Recipes](https://libtmux.org/en/ruby/v0.1.0.alpha.3/examples/recipes/) | Complete programs with checked excerpts |
| [Execution modes](https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/transports/) | Blocking calls, Async tasks and control subscriptions |
| [Ownership and errors](https://libtmux.org/en/ruby/v0.1.0.alpha.3/topics/errors-and-exceptions/) | What close and failure mean |
| [Public behavior](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md) | Defaults, ownership, blocking and failure of each call |
| [Field catalog](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/fields.md) | Query fields and wire names |
| [Public methods](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/api.md) | Each exported method, its source and its contract |
| [Contributing](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/.github/CONTRIBUTING.md) | Local builds, checks and the test loops |
MIT. See [LICENSE](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux/LICENSE).
[async-open]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-open/
[async-scope-map]: https://libtmux.org/en/ruby/latest/reference/libtmux-async-scope-map/
[behavior-cancellation]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#cancellation-tokens
[behavior-capture]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#pane-input-and-capture
[behavior-control]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#control-connections
[behavior-control-flow]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#control-flow
[behavior-creation]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#creation
[behavior-live-handles]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#live-handles
[behavior-option-values]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#option-values
[behavior-options]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#options-and-hooks
[behavior-records]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#captured-records
[behavior-signature]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#signature-proof
[behavior-window-links]: https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/docs/reference/behavior.md#window-links
[cancellation]: https://libtmux.org/en/ruby/latest/reference/libtmux-cancellation/
[cancellation-cancel]: https://libtmux.org/en/ruby/latest/reference/libtmux-cancellation-cancel/
[cancellation-close]: https://libtmux.org/en/ruby/latest/reference/libtmux-cancellation-close/
[cancellation-new]: https://libtmux.org/en/ruby/latest/reference/libtmux-cancellation-new/
[cancelled]: https://libtmux.org/en/ruby/latest/reference/libtmux-cancelled/
[commanderror]: https://libtmux.org/en/ruby/latest/reference/libtmux-commanderror/
[compat]: https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml
[controlconnection]: https://libtmux.org/en/ruby/latest/reference/libtmux-controlconnection/
[controlconnection-exchange]: https://libtmux.org/en/ruby/latest/reference/libtmux-controlconnection-exchange/
[controlconnection-pause_output]: https://libtmux.org/en/ruby/latest/reference/libtmux-controlconnection-pause_output/
[controlconnection-resume_output]: https://libtmux.org/en/ruby/latest/reference/libtmux-controlconnection-resume_output/
[controlconnection-subscribe]: https://libtmux.org/en/ruby/latest/reference/libtmux-controlconnection-subscribe/
[controlevent]: https://libtmux.org/en/ruby/latest/reference/libtmux-controlevent/
[controlsubscription-next]: https://libtmux.org/en/ruby/latest/reference/libtmux-controlsubscription-next/
[endpoint-from_env]: https://libtmux.org/en/ruby/latest/reference/libtmux-endpoint-from_env/
[endpoint-new]: https://libtmux.org/en/ruby/latest/reference/libtmux-endpoint-new/
[groupresult]: https://libtmux.org/en/ruby/latest/reference/libtmux-groupresult/
[guardedreply]: https://libtmux.org/en/ruby/latest/reference/libtmux-guardedreply/
[hooks-set]: https://libtmux.org/en/ruby/latest/reference/libtmux-hooks-set/
[mcp-application]: https://libtmux.org/en/ruby/latest/mcp/reference/libtmux-mcp-application/
[multiplematcheserror]: https://libtmux.org/en/ruby/latest/reference/libtmux-multiplematcheserror/
[nomatcherror]: https://libtmux.org/en/ruby/latest/reference/libtmux-nomatcherror/
[options-get]: https://libtmux.org/en/ruby/latest/reference/libtmux-options-get/
[options-set]: https://libtmux.org/en/ruby/latest/reference/libtmux-options-set/
[optionvalue]: https://libtmux.org/en/ruby/latest/reference/libtmux-optionvalue/
[optionvalue-as]: https://libtmux.org/en/ruby/latest/reference/libtmux-optionvalue-as/
[pane]: https://libtmux.org/en/ruby/latest/reference/libtmux-pane-14z6/
[pane-capture]: https://libtmux.org/en/ruby/latest/reference/libtmux-pane-capture/
[pane-send_keys]: https://libtmux.org/en/ruby/latest/reference/libtmux-pane-send_keys/
[pane-send_text]: https://libtmux.org/en/ruby/latest/reference/libtmux-pane-send_text/
[pane-split]: https://libtmux.org/en/ruby/latest/reference/libtmux-pane-split/
[selection-one]: https://libtmux.org/en/ruby/latest/reference/libtmux-selection-one/
[selection-one_or_nil]: https://libtmux.org/en/ruby/latest/reference/libtmux-selection-one_or_nil/
[selection-select]: https://libtmux.org/en/ruby/latest/reference/libtmux-selection-select/
[selection-where]: https://libtmux.org/en/ruby/latest/reference/libtmux-selection-where/
[server]: https://libtmux.org/en/ruby/latest/reference/libtmux-server/
[server-explain_panes]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-explain_panes/
[server-kill]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-kill/
[server-list_panes]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-list_panes/
[server-list_sessions]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-list_sessions/
[server-list_windows]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-list_windows/
[server-new]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-new/
[server-new_session]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-new_session/
[server-open]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-open/
[server-open_control]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-open_control/
[server-read_buffer]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-read_buffer/
[server-run_group]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-run_group/
[server-search_panes]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-search_panes/
[server-snapshot]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-snapshot/
[server-start]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-start/
[server-write_buffer]: https://libtmux.org/en/ruby/latest/reference/libtmux-server-write_buffer/
[session]: https://libtmux.org/en/ruby/latest/reference/libtmux-session-nvps/
[session-link_window]: https://libtmux.org/en/ruby/latest/reference/libtmux-session-link_window/
[session-list_windows]: https://libtmux.org/en/ruby/latest/reference/libtmux-session-list_windows/
[session-new_window]: https://libtmux.org/en/ruby/latest/reference/libtmux-session-new_window/
[session-options]: https://libtmux.org/en/ruby/latest/reference/libtmux-session-options/
[snapshot]: https://libtmux.org/en/ruby/latest/reference/libtmux-snapshot/
[subscriptionoverflow]: https://libtmux.org/en/ruby/latest/reference/libtmux-subscriptionoverflow/
[targetnotfounderror]: https://libtmux.org/en/ruby/latest/reference/libtmux-targetnotfounderror/
[tool-tmux_capabilities]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_capabilities/
[tool-tmux_snapshot]: https://libtmux.org/en/ruby/latest/mcp/tools/tmux_snapshot/
[window]: https://libtmux.org/en/ruby/latest/reference/libtmux-window-1vfx/
[window-list_panes]: https://libtmux.org/en/ruby/latest/reference/libtmux-window-list_panes/
[window-split]: https://libtmux.org/en/ruby/latest/reference/libtmux-window-split/
[windowlink]: https://libtmux.org/en/ruby/latest/reference/libtmux-windowlink-tusj/
[workspace]: https://libtmux.org/en/ruby/latest/workspace/reference/libtmux-workspace/
---
# Connect a Ruby MCP client
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/connect-client/
> Launch a pinned Ruby MCP server on its own private tmux socket, inspect the default tools, and close it with the client.
**MCP concept example** A working example of the core library. It can change without notice.
Let your MCP client launch the Ruby server on a private tmux socket. The
launcher below creates one `mcp-example` session, offers capability discovery
and metadata snapshots, and stops its owned tmux daemon when the client closes
the connection.
## Prepare the project
Use Ruby 4.0.7 with its development headers, Bundler, Git, a C compiler and
Make, and tmux 3.3a or newer on a Unix host. The bundle includes native
extensions such as `io-event`, `json`, and `fiddle`. This recipe uses the
source revision whose MCP contract is documented here; it does not
assume that a newer checkout and an installed prerelease have identical APIs.
Create an empty directory:
```console
$ mkdir ruby-mcp-client && cd ruby-mcp-client
```
Fetch the source:
```console
$ git clone https://github.com/libtmux/libtmux-ruby libtmux-source
```
Select the documented revision:
```console
$ git -C libtmux-source checkout 9b1545562a112353c2c893a1d3e8c0d9b4b51f8d
```
Install the dependencies from its lockfile:
```console
$ BUNDLE_FROZEN=true BUNDLE_GEMFILE=./libtmux-source/Gemfile bundle install
```
This installs the source checkout's core and MCP gems together. Keep the
checkout beside the launcher so the client's working directory does not affect
which gems it loads.
## Save the launcher
Save this complete program as `run-mcp.rb` in the project directory:
```ruby title="run-mcp.rb"
# frozen_string_literal: true
ENV["BUNDLE_GEMFILE"] = File.expand_path("libtmux-source/Gemfile", __dir__)
require "bundler/setup"
require "libtmux/mcp/cli"
def describe_failure(error)
details = ["#{error.class}: #{error.message}"]
if error.is_a?(LibTmux::Error)
details.concat(error.cleanup_errors.map { |message| "Cleanup: #{message}" })
end
details.join("\n")
end
server = nil
failures = []
begin
server = LibTmux::Server.start(timeout: 5.0)
server.new_session(name: "mcp-example", command: ["/bin/cat"], timeout: 5.0)
status = LibTmux::MCP::CLI.run([
"--socket", server.endpoint.socket_path,
"--endpoint", "docs",
"--timeout", "5"
])
failures << "MCP stopped with status #{status}" unless status.zero?
rescue StandardError => error
failures << describe_failure(error)
ensure
begin
server&.close
rescue StandardError => error
failures << "Cleanup failed: #{describe_failure(error)}"
end
end
abort failures.join("\n") unless failures.empty?
```
`Server.start` owns a new socket directory and foreground daemon with an empty
tmux configuration. It starts no session by itself; `new_session` creates the
example's pane running `cat`. Closing this owned server stops its daemon.
The MCP command borrows that endpoint and closes its own clients when stdin
ends. The outer launcher then closes the daemon it created.
The five-second startup deadline, five-second session-creation deadline, and
five-second MCP request deadline govern separate operations. The server keeps
serving while the client remains connected. Diagnostics go to stderr; stdout
contains MCP messages only. Operation and cleanup failures are both reported.
Run it directly to check startup:
```console
$ ruby -W:no-experimental run-mcp.rb
```
It waits for a client. Send EOF to close it. The Ruby option suppresses the
runtime's experimental [`IO::Buffer`](https://docs.ruby-lang.org/en/4.0/IO/Buffer.html) warning; it does not suppress exceptions.
## Configure a client
For a client that accepts an `mcpServers` configuration, generate the entry
using this project's absolute launcher path and the current Ruby executable:
```console
$ ruby -rjson -rrbconfig -e '
puts JSON.pretty_generate(
"mcpServers" => {
"tmux-ruby" => {
"command" => RbConfig.ruby,
"args" => ["-W:no-experimental", File.expand_path("run-mcp.rb")]
}
}
)
'
```
Add that entry to the client's existing configuration and reconnect. Other
clients ask for a command and argument list separately; use the same values.
The client needs tmux available on its process `PATH`. If its environment
cannot find the intended executable, give the launcher an absolute `executable:`
argument in `Server.start` and pass that same path with the MCP CLI's `--tmux`
option.
## Verify the connection
List the tools. The default catalog contains exactly [`tmux_capabilities`]() and
[`tmux_snapshot`](). Capture, wait, create, send, close, and authored-run tools are
absent until explicitly enabled.
Call [`tmux_capabilities`]() with an empty argument object. Its successful
`structuredContent` has `ok: true`; `data.endpoint` is `docs`. That alias labels
discovery and resource URIs. The `--socket` argument selects the actual daemon.
Call [`tmux_snapshot`]() with this argument object:
```json
{"entity": "session"}
```
The successful result has one item in [`structuredContent.data.items`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/). Its
`fields.name` is `mcp-example`, and its `ref` includes the session identity and
server generation. Check `ok` before reading successful data; a JSON-RPC
response alone does not establish that the tool succeeded.
Close the MCP connection. The launcher exits, stops its private daemon, and
removes its owned socket directory. Reconnecting runs the launcher again and
creates a fresh session, so do not reuse references from the previous server.
## Connect to a server your application owns
When the application already owns a tmux daemon, use the installed
`libtmux-mcp` executable with one explicit `--socket PATH` or `--socket-name NAME`
selector. It borrows the daemon: EOF closes the MCP clients without stopping
that daemon. The application's lifecycle remains responsible for it.
[Tool reference](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/) describes the argument and result schemas.
[Source-owned MCP guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/) explains policy, observation and
shell enrollment. The pinned [CLI implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-mcp/lib/libtmux/mcp/cli.rb)
and [owned-server implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux/lib/libtmux/owned.rb)
define these lifecycle boundaries.
---
# Third-party notices
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/meta/third-party-notices/
> Thanks to tmux's creator and contributors, with licences and attribution for the software behind libtmux.org.
## tmux
First and foremost, thank you to **[Nicholas Marriott (nicm)](https://github.com/nicm)**,
the creator of tmux, and to the many
[tmux contributors](https://github.com/tmux/tmux/graphs/contributors).
We are grateful for the work that makes tmux possible.
libtmux is a separate project. Our libraries and supporting tools control a
real tmux server; tmux itself provides the terminal multiplexer. This is the
libtmux website. Visit the [official tmux website](https://github.com/tmux/tmux/wiki)
for the upstream project and its documentation.
See tmux's [COPYING file](https://github.com/tmux/tmux/blob/master/COPYING)
and the copyright and permission notices in its source files for its licensing.
### tmux artwork
The tmux logomark is by Jason Long. The site uses the unmodified
[upstream SVG](https://github.com/tmux/tmux/blob/8f25579c5aef8d93924a20681f394e2a582fd3ad/logo/tmux-logomark.svg)
under its [copyright and permission notice](https://libtmux.org/en/brand/tmux/LICENSE.txt).
## Programming-language artwork
The homepage language selector uses local copies of the following artwork
to identify the selected language. Each source record includes the download
URL, retrieval time, file hash, copyright information and usage terms.
These marks identify their respective languages and do not imply endorsement
of libtmux.
The SVG files are copied unchanged except for Scala, whose empty surrounding
canvas is cropped. Its paths, gradients and colors are preserved, and the
original SVG is retained beside the cropped copy. Rust's supplied SVG includes
its own dark-theme colors.
| Language | Credit and terms | Local source record |
|---|---|---|
| Python | Python Software Foundation. The [PSF logo terms](https://www.python.org/psf/trademarks/) permit the unaltered mark to identify Python. | [Python provenance](https://libtmux.org/en/brand/languages/py/provenance.json) |
| Ruby | Copyright © 2006, Yukihiro Matsumoto. The [Ruby logo](https://www.ruby-lang.org/en/about/logo/) is licensed under [CC BY-SA 2.5](https://creativecommons.org/licenses/by-sa/2.5/). | [Ruby provenance](https://libtmux.org/en/brand/languages/ruby/provenance.json) |
| Lua | Copyright © 1998 Lua.org; graphic design by Alexandre Nakonechnyj. The Devicon copy carries its [MIT notice](https://libtmux.org/en/brand/languages/lua/LICENSE.txt); [Lua's logo terms](https://www.lua.org/images/) also apply. Visit [Lua.org](https://www.lua.org/). | [Lua provenance](https://libtmux.org/en/brand/languages/lua/provenance.json) |
| TypeScript | Microsoft. The [official branding terms](https://www.typescriptlang.org/branding/) govern the mark; the website repository licenses exclude logo and trademark rights. | [TypeScript provenance](https://libtmux.org/en/brand/languages/ts/provenance.json) |
| Rust | The Rust Foundation. [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) and the [Rust trademark policy](https://rustfoundation.org/policy/rust-trademark-policy/) apply. | [Rust provenance](https://libtmux.org/en/brand/languages/rs/provenance.json) |
| Go | The [Go gopher](https://go.dev/blog/gopher) is by Renee French, licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). | [Go provenance](https://libtmux.org/en/brand/languages/go/provenance.json) |
| C++ | Created by Jeremy Kratz and licensed by the Standard C++ Foundation under its [logo-use terms](https://isocpp.org/home/terms-of-use). | [C++ provenance](https://libtmux.org/en/brand/languages/cxx/provenance.json) |
| Swift | Apple Inc., under the [Swift Logo Guidelines](https://developer.apple.com/swift/downloads/swift-logo.zip). Swift and the Swift logo are trademarks of Apple Inc. | [Swift provenance](https://libtmux.org/en/brand/languages/swift/provenance.json) |
| Java | Devicon collection copyright (c) 2015 konpa, with its [MIT notice](https://libtmux.org/en/brand/languages/java/LICENSE.txt). This does not establish unrestricted rights to the underlying Java logo; [Oracle's logo terms](https://www.oracle.com/legal/logos/) apply. | [Java provenance](https://libtmux.org/en/brand/languages/java/provenance.json) |
| Kotlin | Kotlin Foundation brand guidelines preserve JetBrains copyrights. The [icon-use terms](https://kotlinfoundation.org/guidelines/) permit identifying Kotlin alongside other programming-language icons. | [Kotlin provenance](https://libtmux.org/en/brand/languages/kotlin/provenance.json) |
| Scala | Copyright EPFL. [Historical permission](https://groups.google.com/g/scala-user/c/bCC-R0FQn1w) covers noncommercial Scala promotion; the [general artwork-license question](https://github.com/scala/scala-lang/issues/1040) remains unresolved. | [Scala provenance](https://libtmux.org/en/brand/languages/scala/provenance.json) |
| C# | Copyright the .NET authors. [Brand-use permission](https://github.com/dotnet/brand/issues/10#issuecomment-669465301) allows the unmodified logo to represent .NET. The repository's CC0 statement covers illustrations; no blanket CC0 claim is made for the logo. | [.NET provenance](https://libtmux.org/en/brand/languages/csharp/provenance.json) |
| F# | The F# Software Foundation. Its [logo terms](https://foundation.fsharp.org/logo) require unchanged shape, colors and proportions, without implying Foundation representation. | [F# provenance](https://libtmux.org/en/brand/languages/fsharp/provenance.json) |
## Terminal artwork
The tmux CLI selector displays the Windows Terminal artwork by Microsoft
Corporation, licensed under [CC BY-ND 4.0](https://creativecommons.org/licenses/by-nd/4.0/).
The SVG is unmodified. See the [source and provenance](https://libtmux.org/en/brand/tools/terminal/provenance.json)
and [copyright and license](https://libtmux.org/en/brand/tools/terminal/LICENSE.txt).
## Documentation toolchain
libtmux and this site are built with open-source software. The following
tools have their own licences and attribution requirements.
| Tool | Licence | Role |
|---|---|---|
| [Astro](https://astro.build/) | MIT | The site shell |
| [Tailwind CSS](https://tailwindcss.com/) | MIT | Styling |
| [Pagefind](https://pagefind.app/) | MIT | Site-wide search |
| [Expressive Code](https://expressive-code.com/) | MIT | Code blocks |
| [Sphinx](https://www.sphinx-doc.org/) | BSD-2-Clause | Python and C++ reference |
| [Furo](https://github.com/pradyunsg/furo) | MIT | Sphinx theme |
| [Breathe](https://github.com/breathe-doc/breathe) | BSD-3-Clause | Doxygen XML into Sphinx |
| [Doxygen](https://www.doxygen.nl/) | GPL-2.0-only | Parses C++ headers to XML |
| [API Extractor](https://api-extractor.com/) | MIT | TypeScript API model |
| [IBM Plex](https://github.com/IBM/plex) | OFL-1.1 | Typeface |
### A note on Doxygen
Doxygen is licensed GPL-2.0-only. It runs as a build step that reads libtmux's
own headers and emits XML; that XML is rendered by Breathe and Sphinx, and no
Doxygen-generated HTML is published. Running a GPL program over your own input
does not place its licence on the output, and libtmux does not distribute
Doxygen or any modified version of it.
## Reference hosting
The [PyPI blocks logo](https://pypi.org/trademarks/) is a trademark of the
Python Software Foundation and identifies links to the Python Package Index.
Other package-host icons use [Simple Icons](https://simpleicons.org/)
(CC0-1.0). The docs.rs mark is its
[`docsdotrs` icon](https://github.com/simple-icons/simple-icons/blob/16.35.0/icons/docsdotrs.svg),
inlined unchanged. The book beside javadoc.io links is original artwork for
this site: the host publishes no vector logo, and the mark does not imitate
its favicon.
Some ports deep-link to the canonical host their ecosystem already uses,
rather than duplicating it here:
- Rust: [docs.rs](https://docs.rs/libtmux), for each published crate
- Go: [pkg.go.dev](https://pkg.go.dev/github.com/libtmux/libtmux-go/tmux)
- Java, Kotlin and Scala: [javadoc.io](https://javadoc.io/doc/io.github.libtmux/libtmux)
- Swift: the [Swift Package Index](https://swiftpackageindex.com/libtmux/libtmux-swift/documentation/libtmux)
copy of the DocC reference
Those sites are operated independently of this project and carry their own
terms.
## libtmux itself
Each port is MIT licensed. See the `LICENSE` file in that port's repository
for the authoritative text.
---
# API glossary
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/reference/glossary/
> Kinds, modifiers and package labels in the Ruby API reference.
## Symbol kinds
Kinds identify declarations in the Ruby API reference.
### module
A Ruby namespace that can also supply instance methods as a mixin.
References: [Ruby modules](https://docs.ruby-lang.org/en/3.4/syntax/modules_and_classes_rdoc.html).
### class
A Ruby object type defining instance behavior and inheriting from a superclass.
References: [Ruby classes](https://docs.ruby-lang.org/en/3.4/syntax/modules_and_classes_rdoc.html).
### method
A Ruby operation called on a receiver, usually declared with def.
Instance methods act on instances; singleton methods act on a particular object, including a class object.
References: [Ruby methods](https://docs.ruby-lang.org/en/3.4/syntax/methods_rdoc.html).
### typealias
An RBS type alias used to describe Ruby values for tooling. It does not define a runtime class.
References: [RBS type aliases](https://github.com/ruby/rbs/blob/master/docs/syntax.md#type-alias-declaration).
## Modifiers
Modifiers add information about calling, implementing, or accessing a declaration. Their precise effect follows the language and the signature.
### static
A Ruby class-level or module-level singleton method, called on that object.
References: [Ruby singleton methods](https://docs.ruby-lang.org/en/3.4/syntax/methods_rdoc.html).
## Package context
Package labels identify where an API is supplied.
### package
The Ruby gem supplying this API. Gem names identify distributions; require loads Ruby files.
References: [Ruby gems](https://guides.rubygems.org/what-is-a-gem/).
---
# tmux MCP for Ruby
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/
> Run the libtmux-mcp server with an explicit tmux endpoint and tool policy.
**MCP concept example** A working example of the core library. It can change without notice.
`libtmux-mcp` exposes one existing tmux server over MCP standard input and
output. Requiring `libtmux/mcp` starts no server; the installed
`libtmux-mcp` executable owns the protocol transport and borrows the selected
tmux daemon.
The default catalog contains [`tmux_capabilities`]() and [`tmux_snapshot`]().
Observation and mutation tools are opt-in, so a client cannot acquire them by
calling an undisclosed name.
## Start here
- [Install](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/#install) configures an MCP client to launch the Ruby server.
- [Tools](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/) records the actual wire schemas and per-tool policy.
- [Guides](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/) connect a client to a private tmux server.
- [Topics](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/topics/) explain captures, cursors, references, and tool policy.
- [Examples](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/examples/) run a client launcher or embed the MCP application.
- [Language API](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/) documents the Ruby embedding surface.
The server requires Ruby 3.3 or newer. Strong process tracking for waits and
authored runs requires tmux 3.3 or newer plus native process identity support.
The [MCP server guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/) is staged from the same revision
as the generated reference.
---
# Ruby MCP API reference
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/
> Public libtmux-mcp embedding types and methods.
**MCP concept example** A working example of the core library. It can change without notice.
Require `libtmux/mcp` to embed the server. Imports start no tmux process,
scheduler, or protocol transport. [`Application`]() borrows an
application-owned [`LibTmux::Async::Server`](); its SDK server and stdio transport
remain on that application's reactor thread.
The declarations below come from the public Ruby inventory, enriched with RBS
signatures, YARD documentation, behavior contracts, and source coordinates at
the selected revision.
## API declarations
- [LibTmux::MCP](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/libtmux-mcp/)
[Protocol catalog](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools.json)
---
# MCP API glossary
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/
> What MCP tool annotations tell clients about a tool.
## MCP tool annotations
These are server-supplied hints, not enforced guarantees. Clients must not base tool-use decisions on annotations from untrusted servers.
### readOnlyHint
True indicates that the tool leaves its environment unchanged.
Defaults to false when omitted.
References: [MCP ToolAnnotations](https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations).
### destructiveHint
True indicates potentially destructive changes; false indicates additive changes only.
Defaults to true. Meaningful only when readOnlyHint is false.
References: [MCP ToolAnnotations](https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations).
### idempotentHint
True indicates that repeating a call with identical arguments adds no further effects.
Defaults to false. Meaningful only when readOnlyHint is false. It does not promise identical responses.
References: [MCP ToolAnnotations](https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations).
### openWorldHint
True indicates possible interaction with external entities; false indicates a closed interaction domain.
Defaults to true. This describes the interaction domain, not whether the tool writes data.
References: [MCP ToolAnnotations](https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations).
### title
A display title for the tool.
The tool’s top-level title takes precedence, followed by annotations.title, then name.
References: [MCP ToolAnnotations](https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations).
## Symbol kinds
Kinds identify declarations in the Ruby API reference.
### module
A Ruby namespace that can also supply instance methods as a mixin.
References: [Ruby modules](https://docs.ruby-lang.org/en/3.4/syntax/modules_and_classes_rdoc.html).
### class
A Ruby object type defining instance behavior and inheriting from a superclass.
References: [Ruby classes](https://docs.ruby-lang.org/en/3.4/syntax/modules_and_classes_rdoc.html).
### method
A Ruby operation called on a receiver, usually declared with def.
Instance methods act on instances; singleton methods act on a particular object, including a class object.
References: [Ruby methods](https://docs.ruby-lang.org/en/3.4/syntax/methods_rdoc.html).
### typealias
An RBS type alias used to describe Ruby values for tooling. It does not define a runtime class.
References: [RBS type aliases](https://github.com/ruby/rbs/blob/master/docs/syntax.md#type-alias-declaration).
## Modifiers
Modifiers add information about calling, implementing, or accessing a declaration. Their precise effect follows the language and the signature.
### static
A Ruby class-level or module-level singleton method, called on that object.
References: [Ruby singleton methods](https://docs.ruby-lang.org/en/3.4/syntax/methods_rdoc.html).
## Package context
Package labels identify where an API is supplied.
### package
The Ruby gem supplying this API. Gem names identify distributions; require loads Ruby files.
References: [Ruby gems](https://guides.rubygems.org/what-is-a-gem/).
---
# tmux workspace manager for Ruby
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/
> Validate, plan, and load bounded YAML or JSON workspaces with libtmux-workspace.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
`libtmux-workspace` parses bounded YAML or JSON into an immutable creation
plan. [`validate`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/validate/) and offline [`plan`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/) do not contact tmux. [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/) and
[`plan --live`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/) borrow an existing server selected with `--socket`.
The manager creates a new session. It does not reconcile, replace, or delete a
preexisting workspace. Applying a plan authorizes declared shell commands;
their delivery does not prove that the pane programs completed.
## Start here
- [Guides](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/guides/) covers [`validate`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/validate/), [`plan`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/), and [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/).
- [Topics](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/topics/) explains the supported format and creation-only model.
- [Examples](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/examples/) provides a bounded YAML configuration.
- [CLI Manual](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/) documents commands, flags, output and exit statuses.
- [Language API](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/reference/) documents the workspace gem.
The [source-owned workspace guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/) is staged from the same
revision as the generated reference.
---
# Ruby workspace guides
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/guides/
> Validate, inspect, and explicitly apply a Ruby workspace plan.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
## Validate without tmux
Validation reads and bounds the configuration without starting or contacting a
tmux server.
```console
$ libtmux-workspace validate workspace.yaml
```
## Inspect an offline plan
An offline plan lists the ordered creation operations. JSON output includes
configured commands and paths, so treat it as application data rather than a
redacted diagnostic.
```console
$ libtmux-workspace plan \
--json \
workspace.yaml
```
## Load on an explicit socket
Start an application-owned server, then pass its socket path to [`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/).
```console
$ libtmux-workspace load \
--socket "$TMUX_SOCKET" \
--json \
workspace.yaml
```
[`plan --live`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/) requires the same selector. `--compensate` enables guarded
cleanup of positively identified created state after failure; it cannot undo
shell effects. Attach and client switching are explicit post-apply choices,
not defaults.
[Source-owned CLI guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/#command-line-interface)
---
# Ruby workspace topics
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/topics/
> Workspace format, planning boundaries, application effects, and failure ledgers.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
## Configuration boundary
The supported format describes one session with windows, panes, options,
directories, environment values, and shell commands. YAML tags, aliases,
duplicate keys, ERB, plugins, and callbacks are rejected. Environment
substitution is opt-in and consults only the explicitly supplied mapping.
## Creation-only plans
Plans create new state and reject a captured session-name conflict. They do
not reconcile an existing workspace. Every apply takes a fresh snapshot and
rechecks its binding and the target name before the first creation command.
## Effects and failure
Shell commands are dispatched as literal text followed by Enter. Success means
tmux accepted the dispatch, not that the shell command finished. An apply
failure retains completed steps, positively identified created references,
observed or dispatch-only effects, uncertainty, and cleanup diagnostics.
Optional compensation kills only a positively returned new session after an
atomic guard proves ownership of every current window and pane. Unknown or
borrowed entities cause cleanup refusal.
[Source-owned workspace guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/)
---
# Ruby workspace examples
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/examples/
> A bounded creation-only workspace for libtmux-workspace.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
Save this as `workspace.yaml`:
```yaml
session_name: work
environment:
PROJECT_MODE: development
windows:
- window_name: editor
window_index: 1
layout: tiled
panes:
- shell_command: printf 'editor ready\n'
- {}
```
Run [`libtmux-workspace validate workspace.yaml`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/validate/), inspect
[`libtmux-workspace plan`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/plan/)` `[`--json`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/#input-and-common-options-json)` workspace.yaml`, then pass an owned socket to
[`load`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/cli/load/). Relative directories resolve against the configuration file.
The [source-owned workspace guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/) links the installed-package
example that checks inert planning, apply, and guarded compensation.
---
# Ruby workspace API reference
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/reference/
> Public libtmux-workspace parsing, planning, application, and CLI types.
**Workspace Manager concept example** A working example of the core library. It can change without notice.
Require `libtmux/workspace` for library use. Parsing and planning do not start
tmux or execute commands. `Plan#apply` requires an explicitly opened core
server and leaves that binding open.
The declarations below come from the public Ruby inventory, enriched with RBS
signatures, YARD documentation, behavior contracts, and source coordinates at
the selected revision.
## API declarations
- [LibTmux::Workspace](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/reference/libtmux-workspace/)
---
# API glossary
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/reference/glossary/
> Kinds, modifiers and package labels in the Ruby API reference.
## Symbol kinds
Kinds identify declarations in the Ruby API reference.
### module
A Ruby namespace that can also supply instance methods as a mixin.
References: [Ruby modules](https://docs.ruby-lang.org/en/3.4/syntax/modules_and_classes_rdoc.html).
### class
A Ruby object type defining instance behavior and inheriting from a superclass.
References: [Ruby classes](https://docs.ruby-lang.org/en/3.4/syntax/modules_and_classes_rdoc.html).
### method
A Ruby operation called on a receiver, usually declared with def.
Instance methods act on instances; singleton methods act on a particular object, including a class object.
References: [Ruby methods](https://docs.ruby-lang.org/en/3.4/syntax/methods_rdoc.html).
### typealias
An RBS type alias used to describe Ruby values for tooling. It does not define a runtime class.
References: [RBS type aliases](https://github.com/ruby/rbs/blob/master/docs/syntax.md#type-alias-declaration).
## Modifiers
Modifiers add information about calling, implementing, or accessing a declaration. Their precise effect follows the language and the signature.
### static
A Ruby class-level or module-level singleton method, called on that object.
References: [Ruby singleton methods](https://docs.ruby-lang.org/en/3.4/syntax/methods_rdoc.html).
## Package context
Package labels identify where an API is supplied.
### package
The Ruby gem supplying this API. Gem names identify distributions; require loads Ruby files.
References: [Ruby gems](https://guides.rubygems.org/what-is-a-gem/).
---
# Topics
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/topics/
> Topics for libtmux.
Understand object ownership, state, and operation behavior.
- [Ownership and errors](https://libtmux.org/en/ruby/v0.1.0.alpha.3/topics/errors-and-exceptions/): Understand server ownership, immutable references, and operation failures.
---
# Ownership and errors
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/topics/errors-and-exceptions/
> Understand server ownership, immutable references, and operation failures.
An entity reference contains a binding identity, kind and tmux-assigned ID.
Window links also retain session and index context. A snapshot can describe
one window at several indexes without creating several window identities.
Names are query values, not substitutes for stable command targets.
A borrowed binding retains its private socket route. Replacing the public
socket does not authorize following a new server. Closing the binding retires
owned clients and pipes and preserves the borrowed daemon. A server started
with `Server.start` owns its daemon and temporary directory as well. Handles,
Async tasks and subscriptions cannot be transferred to another process or
scheduler as if their ownership were unchanged.
| Failure or empty value | Meaning |
| --- | --- |
| Empty [`Selection`]() / [`one_or_nil`]() returns `nil` | A valid complete local selection has no matching record |
| [`NoMatchError`]() / [`MultipleMatchesError`]() | [`one`]() cannot establish exactly one match |
| [`InvalidFilterError`]() / [`FieldDecodeError`]() | Criteria or wire values do not satisfy the declared schema |
| [`IncompleteSnapshotError`]() | Required coverage is unavailable; do not infer absence |
| [`TargetNotFoundError`]() | The guarded target no longer matches its identity/context |
| [`Cancelled`]() / [`DeadlineExceeded`]() | The requested wait ended; delivery evidence determines possible effects |
| [`SubscriptionOverflow`]() / gap event | A bounded stream cannot establish uninterrupted delivery |
| [`Workspace::ApplyError`]() | Inspect its immutable result ledger before deciding whether to compensate |
Operation errors report a phase and delivery evidence: `not_sent`,
`possibly_sent`, or `observed`. An observed nonzero exit still needs its
command result. Cleanup diagnostics accompany failures; cleanup failure is
not a successful close. A cancelled mutating request can already have effects.
A timed-out WAIT lock request can still acquire its queued remote lock after
a later unlock; retiring the client does not roll back tmux's command queue.
Client cancellation sends TERM, then KILL if exit is still unobserved, and
uses the remaining cleanup deadline to reap the owned child. There is no
scheduled grace period for a TERM handler. This policy applies to owned
command clients; cancelling their requests does not terminate borrowed panes
or daemons.
Create [`LibTmux::Cancellation.new`]() for blocking requests and pass it as `cancel:`.
Calling [`cancel`]() from another thread wakes current users of that token and makes
`cancelled?` true permanently; later requests with the same token refuse before
dispatch. A token can cancel several requests. It owns a pipe, starts no thread,
and must remain open until every request using it has returned. Join those
callers before calling `close`; closing a token does not join them. Both methods
are idempotent and their return values are unspecified. [`reader`]() belongs to the
token: do not consume its bytes or close it separately. After a fork, a child
may close its inherited descriptors but cannot query or cancel the parent's token.
The [plain-Ruby example](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/cancel.rb) proves wakeup, delivery evidence
and client reaping without sleeps. Async tasks can instead use `Task#cancel` as
shown in the [Async example](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/examples/async_cancel.rb).
Workspace compensation is explicit. It removes only a positively created
session whose current windows and panes all belong to the creation ledger,
checked in the same tmux command turn. A borrowed window or pane moved into
that session prevents destructive compensation. Arbitrary shell effects
cannot be rolled back, and an unacknowledged creation is never guessed by name.
Parsing errors and ordinary inspection redact payloads. Explicit results,
captures, plans and canonical exports contain the requested data, including
commands or normalized paths; callers control their storage and display.
See [execution modes](https://libtmux.org/en/ruby/v0.1.0.alpha.3/concepts/transports/) and [workspace details](https://libtmux.org/en/ruby/v0.1.0.alpha.3/workspace/source-guide/).
---
# Ruby MCP topics
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/topics/
> Understand tool policy, retained observations, resources, and authored runs.
**MCP concept example** A working example of the core library. It can change without notice.
The Ruby MCP server exposes selected operations on one tmux endpoint.
Its tool policy controls what clients can request; captured metadata and
references determine what those requests describe.
## Tool policy
[`tmux_capabilities`]() and [`tmux_snapshot`]() are enabled by default. Capture, wait,
create, send, close, and run tools remain absent until the process receives a
matching `--enable-tool` option. Direct application calls enforce the same
policy as protocol discovery.
## Captures and resources
Snapshots and screen captures retain immutable observations. A cursor pages
that retained state; it does not silently substitute a newer live listing.
Resource templates expose metadata pages and pane screens using encoded
endpoint and generation identities. The server advertises neither resource
subscriptions nor resource-list change notifications, and it has no prompt
catalog.
## Authored runs
[`tmux_run`]() needs both `--enable-tool `[`tmux_run`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/) and an exact
`--enroll-pane %ID=FILE` entry. The operator must source the generated file in
that pane's interactive zsh 5.9. Enrollment does not type into the terminal,
and a later pane respawn cannot redirect an authorized request to the
replacement process.
The tool reports stdout and stderr independently. Nonzero exits and signals
are completion results; overflow is an error, not truncated success.
[Source-owned policy and enrollment guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/source-guide/)
- [Snapshots and references](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/topics/snapshots-and-references/): Filter metadata, continue a retained result, and handle expired cursors and stale references.
---
# Snapshots, cursors, and references
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/topics/snapshots-and-references/
> Query Ruby MCP metadata, page a retained result, and use references within the server binding that created them.
**MCP concept example** A working example of the core library. It can change without notice.
Use [`tmux_snapshot`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/) to inspect sessions, windows,
panes, window links, or attached clients. The tool captures metadata and
evaluates the Ruby criteria against that capture. Reading a later page keeps
the original result; starting another query acquires new metadata.
The [client guide](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/connect-client/) provides the complete setup
used below. Its launcher creates a private daemon with one session named
`mcp-example`. These JSON blocks are tool arguments to send through that
connected MCP client.
## Discover the binding and limits
Call [`tmux_capabilities`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/) with an empty
argument object. Read [`structuredContent.ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/) before using `"data"`.
The successful data identifies the selected endpoint, its server generation,
the enabled tools, the criteria schema, and the current limits. `endpoint` is
the public alias chosen by the launcher; the socket was selected separately
when the MCP process started. Requests cannot choose a different socket.
Use the returned generation and references as opaque identities. The tmux
daemon PID, its start time, and an entity's numeric ID are useful context;
they do not replace the generation when constructing a target.
## Read a session listing
Call [`tmux_snapshot`]() with:
```json
{"entity": "session", "limit": 50}
```
The example returns one item whose `fields.name` is `mcp-example`.
Its result has `truncated: false` and no `next_cursor`; pagination applies
when a selection contains more records than its page limit.
Each item has a `kind`, a `fields` object, and a `ref`. The fields describe
the captured state; the reference identifies an entity for a later operation.
Client records have `ref: null`, because clients are not supported mutation
targets. Window-link references additionally identify the session and index
of that particular link.
The result also includes a `capture_id`, `server_identity`, `"coverage"`, and an
`interval`. Acquisition reads several tmux listings. It reports the start,
finish, and number of reads; it does not claim that all fields were observed
at one instant. A complete acquisition can still be old by the time the client
uses it. Unsupported or incomplete acquisition produces an error rather than
silently presenting a partial listing as complete.
## Filter captured metadata
Include the versioned Ruby criteria object to select the example session:
```json
{
"entity": "session",
"criteria": {
"profile": "libtmux-ruby.where",
"version": 1,
"entity": "session",
"where": {"name": "mcp-example"}
}
}
```
This also returns one item. A valid criterion that matches nothing returns
an empty `items` array, not a missing-session exception. Filtering happens
locally after acquisition; selecting one session does not turn the operation
into a tmux query that reads only that session.
Use the schema returned by discovery for field names and operators. The wire
format uses names such as `currentCommand` and `startsWith`, which differ from
Ruby method spelling. The criteria entity must match the outer `entity`.
The decoder also bounds bytes, nesting and nodes, rejects duplicate keys, and
rejects floating-point tokens for integer fields. A generic JSON Schema
validator alone does not establish that the Ruby decoder will accept a value.
## Continue the same result
The default page limit is 50 records; the accepted range is 1 through 200.
When a page has `truncated: true`, its `next_cursor` identifies the next
position in that retained result. Send a new [`tmux_snapshot`]() call with only
the `cursor` property set to that returned string. Do not also send `entity`,
`criteria`, or `limit`: a continuation cannot change its query or page size.
Each page retains the same capture identity, acquisition interval, and
selection, even if tmux changes meanwhile. `truncated` describes whether more
records remain in this result. It does not mean that the tool silently
discarded the rest. Follow the cursor until no next page remains.
Captures are retained for 30 seconds by default, within a shared budget of
16 captures and 8 MiB. Screen tracking also uses that retention budget.
New captures can evict older ones before their lifetime expires. A well-formed
cursor with an unknown or expired capture, or a position outside its result,
produces `stale_cursor`. A malformed cursor produces `invalid_input`. Neither
starts a new listing on the client's behalf. Start a new query and keep its
pages separate from any earlier capture when a current result is needed.
The request deadline is five seconds by default and a structured response is
limited to 1 MiB. A smaller page can reduce response size, but it does not
reduce the work or retained bytes required to acquire and filter the complete
metadata capture. Treat a capacity refusal as a failed request.
## Keep references within their binding
Pass an item's returned `ref` to an enabled operation that accepts that entity
kind. Preserve the whole object, including `generation`. Do not reconstruct a
reference from the visible name, attach a generation from another connection,
or assume a reused tmux ID still describes the same entity.
A reference is not a lease on a live pane process. The entity may disappear
after the snapshot; a pane can remain while its program is replaced. Process
observation uses additional retained identity checks where the platform and
tmux version support them. A metadata snapshot alone does not establish that
a process is still running or that a command has completed.
Reconnecting the client guide's launcher creates a new daemon and binding.
Rediscover capabilities and acquire fresh references. Even when an application
keeps its daemon running between MCP connections, a reference from one binding
must not be transplanted into another.
## Read metadata through resources
Clients that support MCP resource templates can discover [`tmux_metadata`]() and
[`tmux_metadata_page`](). The first acquires a metadata snapshot with the default
page limit; the second reads a retained page. Resource access uses the same
tool policy and response bounds.
Fill the advertised URI template from discovery and the current result,
percent-encoding each component. The endpoint, generation, entity, and cursor
must agree with the retained query. A URI is not a way to bypass the binding
or select another daemon. Resource reads return JSON content containing the
same application result envelope; protocol errors carry the failed operation's
details. The server advertises neither subscriptions nor resource-list change
notifications, so a client must explicitly request a fresh observation.
## Handle errors before reading data
Successful tool responses have `structuredContent.ok: true` and `"data"`.
Application failures set `isError: true` and return `ok: false` with an
`error` object containing a code, message, and delivery evidence. Check this
envelope even when the JSON-RPC request itself completed.
| Error | Reader action |
| --- | --- |
| `invalid_input` | Correct the argument shape, types, page limit, cursor format, or continuation fields. |
| `invalid_filter` | Check the criteria profile, version, fields, and matching entity. |
| `stale_cursor` | Start a fresh query instead of joining pages from different captures. |
| `stale_target` | Rediscover and inspect the entity before deciding whether to retry. |
| `capacity` | Reduce the requested work where possible and inspect the published limits. |
| `deadline`, `transport_error`, `incomplete_snapshot` | Treat the requested observation as unavailable; do not report an empty successful result. |
The pinned [snapshot implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-mcp/lib/libtmux/mcp/application.rb),
[tool schemas](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb),
and [resource implementation](https://github.com/libtmux/libtmux-ruby/blob/9b1545562a112353c2c893a1d3e8c0d9b4b51f8d/gems/libtmux-mcp/lib/libtmux/mcp/resources.rb)
define the behavior described here.
---
# Tools
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/
> Browse the operations the server exposes to MCP clients. Use the registered name and arguments when sending a tools/call request.
Browse the operations the server exposes to MCP clients. Use the registered name and arguments when sending a tools/call request.
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
The reference configuration advertises 8 tools. Your server’s available objects depend on its configuration. [Setup documentation](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/) explains how to connect a client.
## Server2 tools[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/#tools-server)
[tmux_capabilities](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/)
Discover the fixed endpoint, server binding, enabled tools, criteria schema and limits. Acquires metadata; starts no daemon.
[tmux_snapshot](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/)
Capture ordered metadata and evaluate Ruby criteria locally. Pages retain one immutable capture; expired cursors require a new query. Limit defaults to 50 records, maximum 200.
## Pane6 tools[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/#tools-pane)
[tmux_capture](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/)
Read exact-pane screen/history rows preserving LF. Defaults: 200 lines, 65536 bytes, zero history lines, track=false. Limits: 1000 lines/history, 262144 bytes. UTF-8 or base64; truncation is separate from unknown history continuity. Tracked process cursors require tmux>=3.3a and a native process identity backend: Linux peer pidfds with matching PID namespaces, or Darwin kqueue process observation. Continuation returns an exact state row splice, not a live-output journal. Refuses capture after-hooks.
[tmux_close](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/)
Destroy one exact session, window or pane. Opt-in destructive operation; closing a session or window also removes its contained topology. Never selects by name or closes the daemon directly. Returns the final tmux client outcome.
[tmux_create](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/)
Create a session, window in an exact session, or split an exact pane using argv. Opt-in mutation; 64 KiB total string bytes and at most 256 argv entries. Window/pane focus defaults false. Cwd/environment are optional; size is cells or percent. Assigned refs prove creation, not program readiness or completion.
[tmux_run](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/)
Run an authored POSIX script in an explicitly enrolled idle, empty zsh 5.9 editor. Opt-in; no terminal injection. Exact queue authorization binds the existing shell generation; execution may follow a later pane replacement without retargeting it. Inherits cwd/exported environment, closed stdin, separate bounded UTF-8/base64 outputs. Defaults: 65536 bytes per output, 65536 script bytes; overflow refuses completion. Reports native exit/signal only from the helper; cancellation never proves descendants stopped.
[tmux_send](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/)
Send literal UTF-8 text or named keys to one exact pane. Opt-in mutation; 64 KiB total text bytes, at most 256 keys. Reports tmux client completion and input dispatch only; never shell completion.
[tmux_wait](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/)
Wait for observed literal screen text or the initial pane process exit. Deadline in seconds is capped by the application limit. Pane exit is observed through process descriptors. The screen_contains condition joins wrapped rows, uses control events on tmux>=3.7 and polls the pane screen on older daemons, which take no control client. A pane or tmux server that ends first fails with pane_died and the last rows read in error.capture; a lost control stream fails with observation_lost. Requires tmux>=3.3a and Linux peer pidfds with matching PID namespaces or Darwin kqueue process observation. Reports observed evidence, never remote termination caused by cancellation or an inferred process exit status.
## [Resources](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/)
This server does not advertise resources in the reference configuration.
## [Resource templates](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/#resources-resource-templates)
3 advertised in the reference configuration.
## [Prompts](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/prompts/)
This server does not advertise prompts in the reference configuration.
Reference configuration
* `mode`
`explicit CLI options`
* `tools`
`tmux_capabilities,tmux_snapshot,tmux_capture,tmux_wait,tmux_create,tmux_send,tmux_close,tmux_run`
Protocol version: `2025-11-25`. [Download the full protocol catalog](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools.json).
Source: [`libtmux/libtmux-ruby@d8ce4bbee0ca`](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).
The [language API reference](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/) documents embedding and implementation types.
Source revision: [libtmux/libtmux-ruby@d8ce4bbee0ca7748a81929f81f7d8d07f8c51267](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).
---
# tmux_capabilities
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/
> Discover the fixed endpoint, server binding, enabled tools, criteria schema and limits. Acquires metadata; starts no daemon.
tool MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* **tmux_capabilities**()
tool \[[source](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb#L250)][¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities)
Discover the fixed endpoint, server binding, enabled tools, criteria schema and limits. Acquires metadata; starts no daemon.
* MCP request method
`tools/call` Send `tmux_capabilities` as the tool name, with the arguments below.
* Tool selection
Enabled by default.
## Arguments[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.parameters)
No named arguments.
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.result)
Returns [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`authored_run`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`authorization`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run%2Fproperties%2Fauthorization)** ("exact_generation_at_queue_grant")
* **[`availability`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run%2Fproperties%2Favailability)** ("conditional" | "unsupported")
* **[`descendant_termination`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run%2Fproperties%2Fdescendant_termination)** ("unobserved")
* **[`enrollment`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run%2Fproperties%2Fenrollment)** ("explicit_source")
* **[`persistent_shell_changes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run%2Fproperties%2Fpersistent_shell_changes)** (false)
* **[`requirements`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run%2Fproperties%2Frequirements)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* **[`shell_profile`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run%2Fproperties%2Fshell_profile)** ("zsh-5.9-zle")
* **[`stdin`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthored_run%2Fproperties%2Fstdin)** ("closed")
No other properties are accepted.
* **[`criteria_schema`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcriteria_schema)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`enabled_tools`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fenabled_tools)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* **[`endpoint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fendpoint)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`limits`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Flimits)** ([Record](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")\)
* **[`observation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fobservation)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`history_continuity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fobservation%2Fproperties%2Fhistory_continuity)** ("unknown")
* **[`process_cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fobservation%2Fproperties%2Fprocess_cursor)** ("conditional" | "unsupported")
* **[`requirements`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fobservation%2Fproperties%2Frequirements)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* **[`screen`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fobservation%2Fproperties%2Fscreen)** ("bounded_rows")
* **[`wait_conditions`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fobservation%2Fproperties%2Fwait_conditions)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<"screen_contains" | "process_exit">)
No other properties are accepted.
* **[`owns_daemon`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fowns_daemon)** (false)
* **[`resource_subscriptions`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fresource_subscriptions)** (false)
* **[`server_identity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`pid`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity%2Fproperties%2Fpid)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`start_time`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity%2Fproperties%2Fstart_time)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`tmux_version`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity%2Fproperties%2Ftmux_version)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F0%2Fproperties%2Fok)** (true)
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`error`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`code`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcode)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fdelivery)** ("not_sent" | "possibly_sent" | "observed")
* **[`effects`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* maxItems
`3`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fstate)** ("none" | "known" | "unknown")
No other properties are accepted.
* **[`message`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fmessage)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.output%2FoneOf%2F1%2Fproperties%2Fok)** (false)
No other properties are accepted.
## Annotations[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.annotations)
* [`destructiveHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#destructiveHint)
`false`
* [`idempotentHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#idempotentHint)
`false`
* [`openWorldHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#openWorldHint)
`false`
* [`readOnlyHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#readOnlyHint)
`false`
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capabilities/#mcp.tool.tmux_capabilities.schemas)
Use the complete advertised contract for validation and client integration.
Input schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"additionalProperties": false,
"properties": {},
"required": [],
"type": "object"
}
```
Output schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"data": {
"additionalProperties": false,
"properties": {
"authored_run": {
"additionalProperties": false,
"properties": {
"authorization": {
"const": "exact_generation_at_queue_grant"
},
"availability": {
"enum": [
"conditional",
"unsupported"
]
},
"descendant_termination": {
"const": "unobserved"
},
"enrollment": {
"const": "explicit_source"
},
"persistent_shell_changes": {
"const": false
},
"requirements": {
"items": {
"type": "string"
},
"type": "array"
},
"shell_profile": {
"const": "zsh-5.9-zle"
},
"stdin": {
"const": "closed"
}
},
"required": [
"availability",
"shell_profile",
"enrollment",
"authorization",
"stdin",
"persistent_shell_changes",
"descendant_termination",
"requirements"
],
"type": "object"
},
"criteria_schema": {
"type": "object"
},
"enabled_tools": {
"items": {
"type": "string"
},
"type": "array"
},
"endpoint": {
"type": "string"
},
"limits": {
"additionalProperties": {
"type": "number"
},
"type": "object"
},
"observation": {
"additionalProperties": false,
"properties": {
"history_continuity": {
"const": "unknown"
},
"process_cursor": {
"enum": [
"conditional",
"unsupported"
]
},
"requirements": {
"items": {
"type": "string"
},
"type": "array"
},
"screen": {
"const": "bounded_rows"
},
"wait_conditions": {
"items": {
"enum": [
"screen_contains",
"process_exit"
]
},
"type": "array"
}
},
"required": [
"screen",
"history_continuity",
"process_cursor",
"requirements",
"wait_conditions"
],
"type": "object"
},
"owns_daemon": {
"const": false
},
"resource_subscriptions": {
"const": false
},
"server_identity": {
"additionalProperties": false,
"properties": {
"generation": {
"type": "string"
},
"pid": {
"type": "integer"
},
"start_time": {
"type": "integer"
},
"tmux_version": {
"type": "string"
}
},
"required": [
"generation",
"pid",
"start_time",
"tmux_version"
],
"type": "object"
}
},
"required": [
"endpoint",
"server_identity",
"enabled_tools",
"criteria_schema",
"limits",
"owns_daemon",
"resource_subscriptions",
"authored_run",
"observation"
],
"type": "object"
},
"ok": {
"const": true
}
},
"required": [
"ok",
"data"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"error": {
"additionalProperties": false,
"properties": {
"code": {
"type": "string"
},
"delivery": {
"enum": [
"not_sent",
"possibly_sent",
"observed"
]
},
"effects": {
"additionalProperties": false,
"properties": {
"created": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"maxItems": 3,
"type": "array"
},
"state": {
"enum": [
"none",
"known",
"unknown"
]
}
},
"required": [
"state",
"created"
],
"type": "object"
},
"message": {
"type": "string"
}
},
"required": [
"code",
"message",
"delivery"
],
"type": "object"
},
"ok": {
"const": false
}
},
"required": [
"ok",
"error"
],
"type": "object"
}
],
"type": "object"
}
```
---
# tmux_capture
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/
> Read exact-pane screen/history rows preserving LF. Defaults: 200 lines, 65536 bytes, zero history lines, track=false. Limits: 1000 lines/history, 262144 bytes. UTF-8 or base64; truncation is separate from unknown history continuity. Tracked process cursors require tmux>=3.3a and a native process identity backend: Linux peer pidfds with matching PID namespaces, or Darwin kqueue process observation. Continuation returns an exact state row splice, not a live-output journal. Refuses capture after-hooks.
tool MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* **tmux_capture**()
tool \[[source](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb#L240)][¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture)
Read exact-pane screen/history rows preserving LF. Defaults: 200 lines, 65536 bytes, zero history lines, track=false. Limits: 1000 lines/history, 262144 bytes. UTF-8 or base64; truncation is separate from unknown history continuity. Tracked process cursors require tmux>=3.3a and a native process identity backend: Linux peer pidfds with matching PID namespaces, or Darwin kqueue process observation. Continuation returns an exact state row splice, not a live-output journal. Refuses capture after-hooks.
* MCP request method
`tools/call` Send `tmux_capture` as the tool name, with the arguments below.
* Tool selection
Opt in with `--enable-tool tmux_capture`.
## Arguments[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.parameters)
No named arguments.
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`history_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Fhistory_lines)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`max_bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Fmax_bytes)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`262144`
* **[`max_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Fmax_lines)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`1000`
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`track`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F0%2Fproperties%2Ftrack)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F1%2Fproperties%2Fcursor)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^[a-f0-9]{32}$"`
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F1%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.input%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
No other properties are accepted.
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.result)
Returns [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fbytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`encoding`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fencoding)** ("utf-8" | "base64")
* **[`history_continuity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fhistory_continuity)** ("unknown")
* **[`interval`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Finterval)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`clock`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Fclock)** ("monotonic_seconds")
* **[`finished`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Ffinished)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`started`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Fstarted)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
No other properties are accepted.
* **[`mode`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fmode)** ("snapshot")
* **[`next_cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fnext_cursor)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`row_count`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Frow_count)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`rows`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Frows)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1000`
* **[`scope`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fscope)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`history_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fhistory_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`max_bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fmax_bytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`262144`
* **[`max_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fmax_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`1000`
No other properties are accepted.
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftruncated)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`base_capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fbase_capture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fbytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fcapture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`encoding`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fencoding)** ("utf-8" | "base64")
* **[`history_continuity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fhistory_continuity)** ("unknown")
* **[`interval`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Finterval)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`clock`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Fclock)** ("monotonic_seconds")
* **[`finished`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Ffinished)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`started`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Fstarted)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
No other properties are accepted.
* **[`mode`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fmode)** ("delta")
* **[`next_cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fnext_cursor)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`reset`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Freset)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`row_count`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Frow_count)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`scope`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fscope)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`history_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fhistory_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`max_bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fmax_bytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`262144`
* **[`max_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fmax_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`1000`
No other properties are accepted.
* **[`splice`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fsplice)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`delete`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Fdelete)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`rows`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Frows)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1000`
* **[`start`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Fstart)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
No other properties are accepted.
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftruncated)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F0%2Fproperties%2Fok)** (true)
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`error`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`code`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcode)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fdelivery)** ("not_sent" | "possibly_sent" | "observed")
* **[`effects`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* maxItems
`3`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fstate)** ("none" | "known" | "unknown")
No other properties are accepted.
* **[`message`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fmessage)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.output%2FoneOf%2F1%2Fproperties%2Fok)** (false)
No other properties are accepted.
## Annotations[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.annotations)
* [`destructiveHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#destructiveHint)
`false`
* [`idempotentHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#idempotentHint)
`false`
* [`openWorldHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#openWorldHint)
`false`
* [`readOnlyHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#readOnlyHint)
`false`
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/#mcp.tool.tmux_capture.schemas)
Use the complete advertised contract for validation and client integration.
Input schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"history_lines": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"max_bytes": {
"maximum": 262144,
"minimum": 1,
"type": "integer"
},
"max_lines": {
"maximum": 1000,
"minimum": 1,
"type": "integer"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"track": {
"type": "boolean"
}
},
"required": [
"target"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"cursor": {
"maxLength": 32,
"pattern": "^[a-f0-9]{32}$",
"type": "string"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"target",
"cursor"
],
"type": "object"
}
],
"type": "object"
}
```
Output schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"data": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"bytes": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"capture_id": {
"type": "string"
},
"encoding": {
"enum": [
"utf-8",
"base64"
]
},
"history_continuity": {
"const": "unknown"
},
"interval": {
"additionalProperties": false,
"properties": {
"clock": {
"const": "monotonic_seconds"
},
"finished": {
"type": "number"
},
"started": {
"type": "number"
}
},
"required": [
"clock",
"started",
"finished"
],
"type": "object"
},
"mode": {
"const": "snapshot"
},
"next_cursor": {
"type": "string"
},
"process_generation": {
"type": [
"string",
"null"
]
},
"row_count": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"rows": {
"items": {
"type": "string"
},
"maxItems": 1000,
"type": "array"
},
"scope": {
"additionalProperties": false,
"properties": {
"history_lines": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"max_bytes": {
"maximum": 262144,
"minimum": 1,
"type": "integer"
},
"max_lines": {
"maximum": 1000,
"minimum": 1,
"type": "integer"
}
},
"required": [
"max_lines",
"max_bytes",
"history_lines"
],
"type": "object"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"truncated": {
"type": "boolean"
}
},
"required": [
"target",
"capture_id",
"process_generation",
"encoding",
"row_count",
"bytes",
"truncated",
"history_continuity",
"interval",
"scope",
"mode",
"rows"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"base_capture_id": {
"type": "string"
},
"bytes": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"capture_id": {
"type": "string"
},
"encoding": {
"enum": [
"utf-8",
"base64"
]
},
"history_continuity": {
"const": "unknown"
},
"interval": {
"additionalProperties": false,
"properties": {
"clock": {
"const": "monotonic_seconds"
},
"finished": {
"type": "number"
},
"started": {
"type": "number"
}
},
"required": [
"clock",
"started",
"finished"
],
"type": "object"
},
"mode": {
"const": "delta"
},
"next_cursor": {
"type": "string"
},
"process_generation": {
"type": [
"string",
"null"
]
},
"reset": {
"type": "boolean"
},
"row_count": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"scope": {
"additionalProperties": false,
"properties": {
"history_lines": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"max_bytes": {
"maximum": 262144,
"minimum": 1,
"type": "integer"
},
"max_lines": {
"maximum": 1000,
"minimum": 1,
"type": "integer"
}
},
"required": [
"max_lines",
"max_bytes",
"history_lines"
],
"type": "object"
},
"splice": {
"additionalProperties": false,
"properties": {
"delete": {
"minimum": 0,
"type": "integer"
},
"rows": {
"items": {
"type": "string"
},
"maxItems": 1000,
"type": "array"
},
"start": {
"minimum": 0,
"type": "integer"
}
},
"required": [
"start",
"delete",
"rows"
],
"type": "object"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"truncated": {
"type": "boolean"
}
},
"required": [
"target",
"capture_id",
"process_generation",
"encoding",
"row_count",
"bytes",
"truncated",
"history_continuity",
"interval",
"scope",
"mode",
"base_capture_id",
"reset",
"splice",
"next_cursor"
],
"type": "object"
}
]
},
"ok": {
"const": true
}
},
"required": [
"ok",
"data"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"error": {
"additionalProperties": false,
"properties": {
"code": {
"type": "string"
},
"delivery": {
"enum": [
"not_sent",
"possibly_sent",
"observed"
]
},
"effects": {
"additionalProperties": false,
"properties": {
"created": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"maxItems": 3,
"type": "array"
},
"state": {
"enum": [
"none",
"known",
"unknown"
]
}
},
"required": [
"state",
"created"
],
"type": "object"
},
"message": {
"type": "string"
}
},
"required": [
"code",
"message",
"delivery"
],
"type": "object"
},
"ok": {
"const": false
}
},
"required": [
"ok",
"error"
],
"type": "object"
}
],
"type": "object"
}
```
---
# tmux_close
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/
> Destroy one exact session, window or pane. Opt-in destructive operation; closing a session or window also removes its contained topology. Never selects by name or closes the daemon directly. Returns the final tmux client outcome.
tool MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* **tmux_close**()
tool \[[source](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb#L248)][¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close)
Destroy one exact session, window or pane. Opt-in destructive operation; closing a session or window also removes its contained topology. Never selects by name or closes the daemon directly. Returns the final tmux client outcome.
* MCP request method
`tools/call` Send `tmux_close` as the tool name, with the arguments below.
* Tool selection
Opt in with `--enable-tool tmux_close`.
## Arguments[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.parameters)
No named arguments.
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
No other properties are accepted.
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.result)
Returns [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`client_exit_status`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fclient_exit_status)** (0)
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fdelivery)** ("observed")
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F0%2Fproperties%2Fok)** (true)
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`error`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`code`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcode)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fdelivery)** ("not_sent" | "possibly_sent" | "observed")
* **[`effects`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* maxItems
`3`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fstate)** ("none" | "known" | "unknown")
No other properties are accepted.
* **[`message`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fmessage)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.output%2FoneOf%2F1%2Fproperties%2Fok)** (false)
No other properties are accepted.
## Annotations[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.annotations)
* [`destructiveHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#destructiveHint)
`true`
* [`idempotentHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#idempotentHint)
`false`
* [`openWorldHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#openWorldHint)
`false`
* [`readOnlyHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#readOnlyHint)
`false`
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_close/#mcp.tool.tmux_close.schemas)
Use the complete advertised contract for validation and client integration.
Input schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"target"
],
"type": "object"
}
],
"type": "object"
}
```
Output schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"data": {
"additionalProperties": false,
"properties": {
"client_exit_status": {
"const": 0
},
"delivery": {
"const": "observed"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
}
},
"required": [
"target",
"delivery",
"client_exit_status"
],
"type": "object"
},
"ok": {
"const": true
}
},
"required": [
"ok",
"data"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"error": {
"additionalProperties": false,
"properties": {
"code": {
"type": "string"
},
"delivery": {
"enum": [
"not_sent",
"possibly_sent",
"observed"
]
},
"effects": {
"additionalProperties": false,
"properties": {
"created": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"maxItems": 3,
"type": "array"
},
"state": {
"enum": [
"none",
"known",
"unknown"
]
}
},
"required": [
"state",
"created"
],
"type": "object"
},
"message": {
"type": "string"
}
},
"required": [
"code",
"message",
"delivery"
],
"type": "object"
},
"ok": {
"const": false
}
},
"required": [
"ok",
"error"
],
"type": "object"
}
],
"type": "object"
}
```
---
# tmux_create
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/
> Create a session, window in an exact session, or split an exact pane using argv. Opt-in mutation; 64 KiB total string bytes and at most 256 argv entries. Window/pane focus defaults false. Cwd/environment are optional; size is cells or percent. Assigned refs prove creation, not program readiness or completion.
tool MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* **tmux_create**()
tool \[[source](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb#L246)][¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create)
Create a session, window in an exact session, or split an exact pane using argv. Opt-in mutation; 64 KiB total string bytes and at most 256 argv entries. Window/pane focus defaults false. Cwd/environment are optional; size is cells or percent. Assigned refs prove creation, not program readiness or completion.
* MCP request method
`tools/call` Send `tmux_create` as the tool name, with the arguments below.
* Tool selection
Opt in with `--enable-tool tmux_create`.
## Arguments[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.parameters)
No named arguments.
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`argv`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fargv)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* minItems
`1`
* maxItems
`256`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fargv%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`cwd`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fcwd)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`environment`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fenvironment)**? ([Record](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")\)
* maxProperties
`128`
- **[Additional properties](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fenvironment%2FadditionalProperties)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`height`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fheight)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`2147483647`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
* **[`name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fname)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`width`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fwidth)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`2147483647`
* **[`window_name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F0%2Fproperties%2Fwindow_name)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`argv`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fargv)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* minItems
`1`
* maxItems
`256`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fargv%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`cwd`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fcwd)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`environment`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fenvironment)**? ([Record](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")\)
* maxProperties
`128`
- **[Additional properties](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fenvironment%2FadditionalProperties)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`focus`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Ffocus)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Findex)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
* **[`name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fname)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`parent`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fparent)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fparent%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fparent%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fparent%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F1%2Fproperties%2Fparent%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`argv`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fargv)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* minItems
`1`
* maxItems
`256`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fargv%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`cwd`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fcwd)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`direction`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fdirection)** ("horizontal" | "vertical")
* **[`environment`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fenvironment)**? ([Record](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")\)
* maxProperties
`128`
- **[Additional properties](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fenvironment%2FadditionalProperties)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`focus`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Ffocus)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
* **[`parent`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fparent)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fparent%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fparent%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fparent%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fparent%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`size`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fsize)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fsize%2FoneOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`2147483647`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.input%2FoneOf%2F2%2Fproperties%2Fsize%2FoneOf%2F1)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* pattern
`"^(?:[1-9][0-9]?|100)%$"`
No other properties are accepted.
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.result)
Returns [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* minItems
`1`
* maxItems
`3`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fdelivery)** ("observed")
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`program_completion`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fprogram_completion)** ("unobserved")
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F0%2Fproperties%2Fok)** (true)
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`error`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`code`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcode)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fdelivery)** ("not_sent" | "possibly_sent" | "observed")
* **[`effects`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* maxItems
`3`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fstate)** ("none" | "known" | "unknown")
No other properties are accepted.
* **[`message`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fmessage)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.output%2FoneOf%2F1%2Fproperties%2Fok)** (false)
No other properties are accepted.
## Annotations[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.annotations)
* [`destructiveHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#destructiveHint)
`true`
* [`idempotentHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#idempotentHint)
`false`
* [`openWorldHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#openWorldHint)
`false`
* [`readOnlyHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#readOnlyHint)
`false`
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_create/#mcp.tool.tmux_create.schemas)
Use the complete advertised contract for validation and client integration.
Input schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"argv": {
"items": {
"maxLength": 65536,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"maxItems": 256,
"minItems": 1,
"prefixItems": [
{
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
}
],
"type": "array"
},
"cwd": {
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"environment": {
"additionalProperties": {
"maxLength": 65536,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"maxProperties": 128,
"propertyNames": {
"pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
},
"type": "object"
},
"height": {
"maximum": 2147483647,
"minimum": 1,
"type": "integer"
},
"kind": {
"const": "session"
},
"name": {
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"width": {
"maximum": 2147483647,
"minimum": 1,
"type": "integer"
},
"window_name": {
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
}
},
"required": [
"kind",
"name",
"argv"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"argv": {
"items": {
"maxLength": 65536,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"maxItems": 256,
"minItems": 1,
"prefixItems": [
{
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
}
],
"type": "array"
},
"cwd": {
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"environment": {
"additionalProperties": {
"maxLength": 65536,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"maxProperties": 128,
"propertyNames": {
"pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
},
"type": "object"
},
"focus": {
"type": "boolean"
},
"index": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window"
},
"name": {
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"parent": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"kind",
"parent",
"name",
"argv"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"argv": {
"items": {
"maxLength": 65536,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"maxItems": 256,
"minItems": 1,
"prefixItems": [
{
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
}
],
"type": "array"
},
"cwd": {
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"direction": {
"enum": [
"horizontal",
"vertical"
]
},
"environment": {
"additionalProperties": {
"maxLength": 65536,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"maxProperties": 128,
"propertyNames": {
"pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
},
"type": "object"
},
"focus": {
"type": "boolean"
},
"kind": {
"const": "pane"
},
"parent": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"size": {
"oneOf": [
{
"maximum": 2147483647,
"minimum": 1,
"type": "integer"
},
{
"pattern": "^(?:[1-9][0-9]?|100)%$",
"type": "string"
}
]
}
},
"required": [
"kind",
"parent",
"direction",
"argv"
],
"type": "object"
}
],
"type": "object"
}
```
Output schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"data": {
"additionalProperties": false,
"properties": {
"created": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"maxItems": 3,
"minItems": 1,
"type": "array"
},
"delivery": {
"const": "observed"
},
"entity": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"program_completion": {
"const": "unobserved"
}
},
"required": [
"entity",
"created",
"delivery",
"program_completion"
],
"type": "object"
},
"ok": {
"const": true
}
},
"required": [
"ok",
"data"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"error": {
"additionalProperties": false,
"properties": {
"code": {
"type": "string"
},
"delivery": {
"enum": [
"not_sent",
"possibly_sent",
"observed"
]
},
"effects": {
"additionalProperties": false,
"properties": {
"created": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"maxItems": 3,
"type": "array"
},
"state": {
"enum": [
"none",
"known",
"unknown"
]
}
},
"required": [
"state",
"created"
],
"type": "object"
},
"message": {
"type": "string"
}
},
"required": [
"code",
"message",
"delivery"
],
"type": "object"
},
"ok": {
"const": false
}
},
"required": [
"ok",
"error"
],
"type": "object"
}
],
"type": "object"
}
```
---
# tmux_run
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/
> Run an authored POSIX script in an explicitly enrolled idle, empty zsh 5.9 editor. Opt-in; no terminal injection. Exact queue authorization binds the existing shell generation; execution may follow a later pane replacement without retargeting it. Inherits cwd/exported environment, closed stdin, separate bounded UTF-8/base64 outputs. Defaults: 65536 bytes per output, 65536 script bytes; overflow refuses completion. Reports native exit/signal only from the helper; cancellation never proves descendants stopped.
tool MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* **tmux_run**( [script](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Fscript): [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"), [stderr_limit](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Fstderr_limit)?: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"), [stdout_limit](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Fstdout_limit)?: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"), [target](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Ftarget): [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"), )
tool \[[source](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb#L238)][¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run)
Run an authored POSIX script in an explicitly enrolled idle, empty zsh 5.9 editor. Opt-in; no terminal injection. Exact queue authorization binds the existing shell generation; execution may follow a later pane replacement without retargeting it. Inherits cwd/exported environment, closed stdin, separate bounded UTF-8/base64 outputs. Defaults: 65536 bytes per output, 65536 script bytes; overflow refuses completion. Reports native exit/signal only from the helper; cancellation never proves descendants stopped.
* MCP request method
`tools/call` Send `tmux_run` as the tool name, with the arguments below.
* Tool selection
Opt in with `--enable-tool tmux_run`.
## Arguments[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.parameters)
* **[`script`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Fscript)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`stderr_limit`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Fstderr_limit)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`stdout_limit`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Fstdout_limit)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.input%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
No other arguments are accepted.
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.result)
Returns [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`authorization`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthorization)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`enrollment_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthorization%2Fproperties%2Fenrollment_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^[a-f0-9]{32}$"`
* **[`pane_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthorization%2Fproperties%2Fpane_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthorization%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^[a-f0-9]{32}$"`
* **[`run_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthorization%2Fproperties%2Frun_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^[a-f0-9]{32}$"`
* **[`script_digest`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthorization%2Fproperties%2Fscript_digest)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`64`
* pattern
`"^[a-f0-9]{64}$"`
* **[`server_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthorization%2Fproperties%2Fserver_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fauthorization%2Fproperties%2Fstate)** ("authorized")
No other properties are accepted.
* **[`completion`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`exit_status`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion%2FoneOf%2F0%2Fproperties%2Fexit_status)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
* **[`signal`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion%2FoneOf%2F0%2Fproperties%2Fsignal)** ([null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion%2FoneOf%2F0%2Fproperties%2Fstate)** ("exited")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`exit_status`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion%2FoneOf%2F1%2Fproperties%2Fexit_status)** ([null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`signal`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion%2FoneOf%2F1%2Fproperties%2Fsignal)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`255`
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion%2FoneOf%2F1%2Fproperties%2Fstate)** ("signaled")
No other properties are accepted.
* **[`stderr`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstderr)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstderr%2Fproperties%2Fbytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstderr%2Fproperties%2Fdata)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`349528`
* **[`encoding`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstderr%2Fproperties%2Fencoding)** ("utf-8" | "base64")
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstderr%2Fproperties%2Ftruncated)** (false)
No other properties are accepted.
* **[`stdout`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstdout)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstdout%2Fproperties%2Fbytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstdout%2Fproperties%2Fdata)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`349528`
* **[`encoding`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstdout%2Fproperties%2Fencoding)** ("utf-8" | "base64")
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fstdout%2Fproperties%2Ftruncated)** (false)
No other properties are accepted.
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F0%2Fproperties%2Fok)** (true)
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`error`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`code`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcode)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fdelivery)** ("not_sent" | "possibly_sent" | "observed")
* **[`effects`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`authorization`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`enrollment_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization%2FoneOf%2F0%2Fproperties%2Fenrollment_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^[a-f0-9]{32}$"`
* **[`pane_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization%2FoneOf%2F0%2Fproperties%2Fpane_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization%2FoneOf%2F0%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^[a-f0-9]{32}$"`
* **[`run_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization%2FoneOf%2F0%2Fproperties%2Frun_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^[a-f0-9]{32}$"`
* **[`script_digest`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization%2FoneOf%2F0%2Fproperties%2Fscript_digest)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`64`
* pattern
`"^[a-f0-9]{64}$"`
* **[`server_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization%2FoneOf%2F0%2Fproperties%2Fserver_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fauthorization%2FoneOf%2F0%2Fproperties%2Fstate)** ("authorized")
No other properties are accepted.
* **[`completion`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F0%2Fproperties%2Fstate)** ("unobserved")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`exit_status`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F1%2Fproperties%2Fexit_status)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
* **[`signal`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F1%2Fproperties%2Fsignal)** ([null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F1%2Fproperties%2Fstate)** ("exited")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`exit_status`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F2%2Fproperties%2Fexit_status)** ([null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`signal`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F2%2Fproperties%2Fsignal)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`255`
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcompletion%2FoneOf%2F2%2Fproperties%2Fstate)** ("signaled")
No other properties are accepted.
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fstate)** ("none" | "known" | "unknown")
No other properties are accepted.
* **[`message`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fmessage)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.output%2FoneOf%2F1%2Fproperties%2Fok)** (false)
No other properties are accepted.
## Annotations[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.annotations)
* [`destructiveHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#destructiveHint)
`true`
* [`idempotentHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#idempotentHint)
`false`
* [`openWorldHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#openWorldHint)
`false`
* [`readOnlyHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#readOnlyHint)
`false`
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_run/#mcp.tool.tmux_run.schemas)
Use the complete advertised contract for validation and client integration.
Input schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"additionalProperties": false,
"properties": {
"script": {
"maxLength": 65536,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"stderr_limit": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"stdout_limit": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"target",
"script"
],
"type": "object"
}
```
Output schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"data": {
"additionalProperties": false,
"properties": {
"authorization": {
"additionalProperties": false,
"properties": {
"enrollment_generation": {
"maxLength": 32,
"pattern": "^[a-f0-9]{32}$",
"type": "string"
},
"pane_id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"process_generation": {
"maxLength": 32,
"pattern": "^[a-f0-9]{32}$",
"type": "string"
},
"run_id": {
"maxLength": 32,
"pattern": "^[a-f0-9]{32}$",
"type": "string"
},
"script_digest": {
"maxLength": 64,
"pattern": "^[a-f0-9]{64}$",
"type": "string"
},
"server_generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"state": {
"const": "authorized"
}
},
"required": [
"state",
"run_id",
"script_digest",
"server_generation",
"pane_id",
"enrollment_generation",
"process_generation"
],
"type": "object"
},
"completion": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"exit_status": {
"maximum": 255,
"minimum": 0,
"type": "integer"
},
"signal": {
"type": "null"
},
"state": {
"const": "exited"
}
},
"required": [
"state",
"exit_status",
"signal"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"exit_status": {
"type": "null"
},
"signal": {
"maximum": 255,
"minimum": 1,
"type": "integer"
},
"state": {
"const": "signaled"
}
},
"required": [
"state",
"exit_status",
"signal"
],
"type": "object"
}
]
},
"stderr": {
"additionalProperties": false,
"properties": {
"bytes": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"data": {
"maxLength": 349528,
"type": "string"
},
"encoding": {
"enum": [
"utf-8",
"base64"
]
},
"truncated": {
"const": false
}
},
"required": [
"encoding",
"data",
"bytes",
"truncated"
],
"type": "object"
},
"stdout": {
"additionalProperties": false,
"properties": {
"bytes": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"data": {
"maxLength": 349528,
"type": "string"
},
"encoding": {
"enum": [
"utf-8",
"base64"
]
},
"truncated": {
"const": false
}
},
"required": [
"encoding",
"data",
"bytes",
"truncated"
],
"type": "object"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"target",
"authorization",
"completion",
"stdout",
"stderr"
],
"type": "object"
},
"ok": {
"const": true
}
},
"required": [
"ok",
"data"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"error": {
"additionalProperties": false,
"properties": {
"code": {
"type": "string"
},
"delivery": {
"enum": [
"not_sent",
"possibly_sent",
"observed"
]
},
"effects": {
"additionalProperties": false,
"properties": {
"authorization": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"enrollment_generation": {
"maxLength": 32,
"pattern": "^[a-f0-9]{32}$",
"type": "string"
},
"pane_id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"process_generation": {
"maxLength": 32,
"pattern": "^[a-f0-9]{32}$",
"type": "string"
},
"run_id": {
"maxLength": 32,
"pattern": "^[a-f0-9]{32}$",
"type": "string"
},
"script_digest": {
"maxLength": 64,
"pattern": "^[a-f0-9]{64}$",
"type": "string"
},
"server_generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"state": {
"const": "authorized"
}
},
"required": [
"state",
"run_id",
"script_digest",
"server_generation",
"pane_id",
"enrollment_generation",
"process_generation"
],
"type": "object"
},
{
"type": "null"
}
]
},
"completion": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"state": {
"const": "unobserved"
}
},
"required": [
"state"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"exit_status": {
"maximum": 255,
"minimum": 0,
"type": "integer"
},
"signal": {
"type": "null"
},
"state": {
"const": "exited"
}
},
"required": [
"state",
"exit_status",
"signal"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"exit_status": {
"type": "null"
},
"signal": {
"maximum": 255,
"minimum": 1,
"type": "integer"
},
"state": {
"const": "signaled"
}
},
"required": [
"state",
"exit_status",
"signal"
],
"type": "object"
}
]
},
"state": {
"enum": [
"none",
"known",
"unknown"
]
}
},
"required": [
"state",
"authorization",
"completion"
],
"type": "object"
},
"message": {
"type": "string"
}
},
"required": [
"code",
"message",
"delivery"
],
"type": "object"
},
"ok": {
"const": false
}
},
"required": [
"ok",
"error"
],
"type": "object"
}
],
"type": "object"
}
```
---
# tmux_send
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/
> Send literal UTF-8 text or named keys to one exact pane. Opt-in mutation; 64 KiB total text bytes, at most 256 keys. Reports tmux client completion and input dispatch only; never shell completion.
tool MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* **tmux_send**()
tool \[[source](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb#L244)][¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send)
Send literal UTF-8 text or named keys to one exact pane. Opt-in mutation; 64 KiB total text bytes, at most 256 keys. Reports tmux client completion and input dispatch only; never shell completion.
* MCP request method
`tools/call` Send `tmux_send` as the tool name, with the arguments below.
* Tool selection
Opt in with `--enable-tool tmux_send`.
## Arguments[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.parameters)
No named arguments.
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`input`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Finput)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Finput%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`text`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Finput%2FoneOf%2F0%2Fproperties%2Ftext)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`type`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Finput%2FoneOf%2F0%2Fproperties%2Ftype)** ("text")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Finput%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`keys`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Finput%2FoneOf%2F1%2Fproperties%2Fkeys)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* minItems
`1`
* maxItems
`256`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Finput%2FoneOf%2F1%2Fproperties%2Fkeys%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`65536`
* pattern
`"^[^\\u0000]*$"`
* **[`type`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Finput%2FoneOf%2F1%2Fproperties%2Ftype)** ("keys")
No other properties are accepted.
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
No other properties are accepted.
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.result)
Returns [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`client_exit_status`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fclient_exit_status)** (0)
* **[`completion`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcompletion)** ("dispatch_only")
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fdelivery)** ("observed")
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftarget%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F0%2Fproperties%2Fok)** (true)
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`error`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`code`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcode)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fdelivery)** ("not_sent" | "possibly_sent" | "observed")
* **[`effects`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* maxItems
`3`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fstate)** ("none" | "known" | "unknown")
No other properties are accepted.
* **[`message`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fmessage)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.output%2FoneOf%2F1%2Fproperties%2Fok)** (false)
No other properties are accepted.
## Annotations[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.annotations)
* [`destructiveHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#destructiveHint)
`true`
* [`idempotentHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#idempotentHint)
`false`
* [`openWorldHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#openWorldHint)
`false`
* [`readOnlyHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#readOnlyHint)
`false`
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_send/#mcp.tool.tmux_send.schemas)
Use the complete advertised contract for validation and client integration.
Input schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"input": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"text": {
"maxLength": 65536,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"type": {
"const": "text"
}
},
"required": [
"type",
"text"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"keys": {
"items": {
"maxLength": 65536,
"minLength": 1,
"pattern": "^[^\\u0000]*$",
"type": "string"
},
"maxItems": 256,
"minItems": 1,
"type": "array"
},
"type": {
"const": "keys"
}
},
"required": [
"type",
"keys"
],
"type": "object"
}
]
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"target",
"input"
],
"type": "object"
}
],
"type": "object"
}
```
Output schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"data": {
"additionalProperties": false,
"properties": {
"client_exit_status": {
"const": 0
},
"completion": {
"const": "dispatch_only"
},
"delivery": {
"const": "observed"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
}
},
"required": [
"target",
"delivery",
"client_exit_status",
"completion"
],
"type": "object"
},
"ok": {
"const": true
}
},
"required": [
"ok",
"data"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"error": {
"additionalProperties": false,
"properties": {
"code": {
"type": "string"
},
"delivery": {
"enum": [
"not_sent",
"possibly_sent",
"observed"
]
},
"effects": {
"additionalProperties": false,
"properties": {
"created": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"maxItems": 3,
"type": "array"
},
"state": {
"enum": [
"none",
"known",
"unknown"
]
}
},
"required": [
"state",
"created"
],
"type": "object"
},
"message": {
"type": "string"
}
},
"required": [
"code",
"message",
"delivery"
],
"type": "object"
},
"ok": {
"const": false
}
},
"required": [
"ok",
"error"
],
"type": "object"
}
],
"type": "object"
}
```
---
# tmux_snapshot
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/
> Capture ordered metadata and evaluate Ruby criteria locally. Pages retain one immutable capture; expired cursors require a new query. Limit defaults to 50 records, maximum 200.
tool MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* **tmux_snapshot**( [criteria](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria)?: [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"), [cursor](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcursor)?: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"), [entity](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fentity)?: "session" | "window" | "pane" | "window_link" | "client", [limit](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Flimit)?: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"), )
tool \[[source](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb#L6)][¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot)
Capture ordered metadata and evaluate Ruby criteria locally. Pages retain one immutable capture; expired cursors require a new query. Limit defaults to 50 records, maximum 200.
* MCP request method
`tools/call` Send `tmux_snapshot` as the tool name, with the arguments below.
* Tool selection
Enabled by default.
## Arguments[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.parameters)
* **[`criteria`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F0%2Fproperties%2Fentity)** ("session")
* **[`profile`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F0%2Fproperties%2Fprofile)** ("libtmux-ruby.where")
* **[`version`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F0%2Fproperties%2Fversion)** (1)
* **[`where`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F0%2Fproperties%2Fwhere)** ([session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession))
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F1%2Fproperties%2Fentity)** ("window")
* **[`profile`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F1%2Fproperties%2Fprofile)** ("libtmux-ruby.where")
* **[`version`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F1%2Fproperties%2Fversion)** (1)
* **[`where`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F1%2Fproperties%2Fwhere)** ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F2%2Fproperties%2Fentity)** ("pane")
* **[`profile`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F2%2Fproperties%2Fprofile)** ("libtmux-ruby.where")
* **[`version`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F2%2Fproperties%2Fversion)** (1)
* **[`where`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F2%2Fproperties%2Fwhere)** ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane))
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F3%2Fproperties%2Fentity)** ("window_link")
* **[`profile`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F3%2Fproperties%2Fprofile)** ("libtmux-ruby.where")
* **[`version`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F3%2Fproperties%2Fversion)** (1)
* **[`where`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F3%2Fproperties%2Fwhere)** ([window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link))
No other properties are accepted.
* **[Variant 5](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F4)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F4%2Fproperties%2Fentity)** ("client")
* **[`profile`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F4%2Fproperties%2Fprofile)** ("libtmux-ruby.where")
* **[`version`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F4%2Fproperties%2Fversion)** (1)
* **[`where`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcriteria%2FoneOf%2F4%2Fproperties%2Fwhere)** ([client](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient))
No other properties are accepted.
* **[`cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fcursor)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`43`
* pattern
`"^[a-f0-9]{32}:[0-9]{1,10}$"`
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Fentity)**? ("session" | "window" | "pane" | "window_link" | "client")
* **[`limit`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2Fproperties%2Flimit)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`200`
No other arguments are accepted.
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.result)
Returns [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcapture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`coverage`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fcoverage)** ([Record](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")\)
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fentity)** ("session" | "window" | "pane" | "window_link" | "client")
* **[`interval`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Finterval)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`clock`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Finterval%2Fproperties%2Fclock)** ("monotonic_seconds")
* **[`finished`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Finterval%2Fproperties%2Ffinished)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`reads`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Finterval%2Fproperties%2Freads)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`started`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Finterval%2Fproperties%2Fstarted)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
No other properties are accepted.
* **[`items`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* maxItems
`200`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`fields`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Ffields)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`attached`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Ffields%2Fproperties%2Fattached)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Ffields%2Fproperties%2Fcreated)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Ffields%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Ffields%2Fproperties%2Fname)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`windowCount`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Ffields%2Fproperties%2FwindowCount)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
No other properties are accepted.
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
* **[`ref`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Fref)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Fref%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F0%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`fields`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Ffields)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`height`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Ffields%2Fproperties%2Fheight)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Ffields%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`layout`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Ffields%2Fproperties%2Flayout)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Ffields%2Fproperties%2Fname)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`paneCount`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Ffields%2Fproperties%2FpaneCount)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[`width`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Ffields%2Fproperties%2Fwidth)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
No other properties are accepted.
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
* **[`ref`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Fref)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Fref%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F1%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`fields`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`active`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2Factive)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`currentCommand`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2FcurrentCommand)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`currentPath`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2FcurrentPath)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`dead`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2Fdead)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`deadStatus`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2FdeadStatus)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* minimum
`0`
* maximum
`255`
* **[`height`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2Fheight)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[`pid`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2Fpid)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
* **[`title`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2Ftitle)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`width`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2Fwidth)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[`windowId`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Ffields%2Fproperties%2FwindowId)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
* **[`ref`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Fref)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Fref%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F2%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`fields`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Ffields)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`active`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Ffields%2Fproperties%2Factive)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Ffields%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
* **[`sessionId`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Ffields%2Fproperties%2FsessionId)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`windowId`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Ffields%2Fproperties%2FwindowId)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`ref`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Fref)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Fref%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F3%2Fproperties%2Fref%2FoneOf%2F0%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
No other properties are accepted.
* **[Variant 5](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`fields`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`controlMode`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2FcontrolMode)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2Fcreated)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
* **[`height`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2Fheight)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[`name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2Fname)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`pid`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2Fpid)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
* **[`readOnly`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2FreadOnly)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`sessionId`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2FsessionId)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`tty`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2Ftty)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`utf8`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2Futf8)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`width`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Ffields%2Fproperties%2Fwidth)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
No other properties are accepted.
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Fkind)** ("client")
* **[`ref`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fitems%2Fitems%2FoneOf%2F4%2Fproperties%2Fref)** ([null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
No other properties are accepted.
* **[`next_cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fnext_cursor)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`server_identity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`pid`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity%2Fproperties%2Fpid)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`start_time`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity%2Fproperties%2Fstart_time)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`tmux_version`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Fserver_identity%2Fproperties%2Ftmux_version)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fdata%2Fproperties%2Ftruncated)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F0%2Fproperties%2Fok)** (true)
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`error`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`code`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcode)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fdelivery)** ("not_sent" | "possibly_sent" | "observed")
* **[`effects`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* maxItems
`3`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fstate)** ("none" | "known" | "unknown")
No other properties are accepted.
* **[`message`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fmessage)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.output%2FoneOf%2F1%2Fproperties%2Fok)** (false)
No other properties are accepted.
## Types[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.types)
* ### `client`: [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient)
* **[`and`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fand)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[client](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient)>)
* maxItems
`2048`
* **[`controlMode`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2FcontrolMode)**? ([client.control_mode](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.control_mode))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fcreated)**? ([client.created](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created))
* **[`height`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fheight)**? ([client.height](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height))
* **[`name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fname)**? ([client.name](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name))
* **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fnot)**? ([client](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient))
* **[`or`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2For)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[client](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient)>)
* maxItems
`2048`
* **[`pid`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fpid)**? ([client.pid](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid))
* **[`readOnly`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2FreadOnly)**? ([client.read_only](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.read_only))
* **[`session`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fsession)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`is`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fsession%2Fproperties%2Fis)**? ([session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession) | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
- **[`isNot`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fsession%2Fproperties%2FisNot)**? ([session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession) | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
No other properties are accepted.
* **[`sessionId`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2FsessionId)**? ([client.session_id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id))
* **[`tty`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Ftty)**? ([client.tty](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty))
* **[`utf8`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Futf8)**? ([client.utf8](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.utf8))
* **[`width`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient%2Fproperties%2Fwidth)**? ([client.width](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width))
No other properties are accepted.
- ### `client.control_mode`: [boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.control_mode)
Matches one or more variants.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.control_mode%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.control_mode%2FanyOf%2F1%2Fproperties%2Fequals)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.control_mode%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)")>)
* maxItems
`1024`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.control_mode%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.control_mode](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.control_mode))
No other properties are accepted.
* ### `client.created`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.created](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.created))
No other properties are accepted.
- ### `client.height`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F0%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Fequals%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Fin%2Fitems%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.height](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.height))
No other properties are accepted.
* ### `client.name`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`contains`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F1%2Fproperties%2Fcontains)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`endsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F1%2Fproperties%2FendsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.name](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name))
- **[`startsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.name%2FanyOf%2F1%2Fproperties%2FstartsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
No other properties are accepted.
- ### `client.pid`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.pid](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.pid))
No other properties are accepted.
* ### `client.read_only`: [boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.read_only)
Matches one or more variants.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.read_only%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.read_only%2FanyOf%2F1%2Fproperties%2Fequals)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.read_only%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)")>)
* maxItems
`1024`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.read_only%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.read_only](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.read_only))
No other properties are accepted.
- ### `client.session_id`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F0%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F1%2Fproperties%2Fequals%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F1%2Fproperties%2Fin%2Fitems%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.session_id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.session_id))
No other properties are accepted.
* ### `client.tty`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F0%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`contains`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2Fcontains)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`endsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2FendsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2Fequals%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2Fin%2Fitems%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.tty](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty))
- **[`startsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.tty%2FanyOf%2F1%2Fproperties%2FstartsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
No other properties are accepted.
- ### `client.utf8`: [boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.utf8)
Matches one or more variants.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.utf8%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.utf8%2FanyOf%2F1%2Fproperties%2Fequals)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.utf8%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)")>)
* maxItems
`1024`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.utf8%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.utf8](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.utf8))
No other properties are accepted.
* ### `client.width`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width%2FanyOf%2F1%2Fproperties%2Fnot)**? ([client.width](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fclient.width))
No other properties are accepted.
- ### `pane`: [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane)
* **[`active`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Factive)**? ([pane.active](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.active))
* **[`and`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fand)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane)>)
* maxItems
`2048`
* **[`currentCommand`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2FcurrentCommand)**? ([pane.current_command](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command))
* **[`currentPath`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2FcurrentPath)**? ([pane.current_path](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path))
* **[`dead`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fdead)**? ([pane.dead](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead))
* **[`deadStatus`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2FdeadStatus)**? ([pane.dead_status](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status))
* **[`height`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fheight)**? ([pane.height](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height))
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fid)**? ([pane.id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id))
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Findex)**? ([pane.index](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index))
* **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fnot)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane))
* **[`or`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2For)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane)>)
* maxItems
`2048`
* **[`pid`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fpid)**? ([pane.pid](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid))
* **[`title`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Ftitle)**? ([pane.title](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title))
* **[`width`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fwidth)**? ([pane.width](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width))
* **[`window`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fwindow)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`is`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fwindow%2Fproperties%2Fis)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
- **[`isNot`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2Fwindow%2Fproperties%2FisNot)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
No other properties are accepted.
* **[`windowId`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane%2Fproperties%2FwindowId)**? ([pane.window_id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id))
No other properties are accepted.
* ### `pane.active`: [boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.active)
Matches one or more variants.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.active%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.active%2FanyOf%2F1%2Fproperties%2Fequals)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.active%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)")>)
* maxItems
`1024`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.active%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.active](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.active))
No other properties are accepted.
- ### `pane.current_command`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`contains`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F1%2Fproperties%2Fcontains)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`endsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F1%2Fproperties%2FendsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.current_command](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command))
- **[`startsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_command%2FanyOf%2F1%2Fproperties%2FstartsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
No other properties are accepted.
* ### `pane.current_path`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F0%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`contains`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2Fcontains)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`endsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2FendsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2Fequals%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2Fin%2Fitems%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.current_path](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path))
- **[`startsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.current_path%2FanyOf%2F1%2Fproperties%2FstartsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
No other properties are accepted.
- ### `pane.dead`: [boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead)
Matches one or more variants.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead%2FanyOf%2F1%2Fproperties%2Fequals)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)")>)
* maxItems
`1024`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.dead](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead))
No other properties are accepted.
* ### `pane.dead_status`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F0%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Fequals%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Fin%2Fitems%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`255`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.dead_status](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.dead_status))
No other properties are accepted.
- ### `pane.height`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.height](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.height))
No other properties are accepted.
* ### `pane.id`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.id))
No other properties are accepted.
- ### `pane.index`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.index](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.index))
No other properties are accepted.
* ### `pane.pid`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F0%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Fequals%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Fin%2Fitems%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.pid](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.pid))
No other properties are accepted.
- ### `pane.title`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`contains`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F1%2Fproperties%2Fcontains)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`endsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F1%2Fproperties%2FendsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.title](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title))
- **[`startsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.title%2FanyOf%2F1%2Fproperties%2FstartsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
No other properties are accepted.
* ### `pane.width`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.width](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.width))
No other properties are accepted.
- ### `pane.window_id`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id%2FanyOf%2F1%2Fproperties%2Fnot)**? ([pane.window_id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane.window_id))
No other properties are accepted.
* ### `session`: [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession)
* **[`and`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fand)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession)>)
* maxItems
`2048`
* **[`attached`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fattached)**? ([session.attached](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fcreated)**? ([session.created](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created))
* **[`currentWindow`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2FcurrentWindow)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`is`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2FcurrentWindow%2Fproperties%2Fis)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow) | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
- **[`isNot`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2FcurrentWindow%2Fproperties%2FisNot)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow) | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
No other properties are accepted.
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fid)**? ([session.id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id))
* **[`name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fname)**? ([session.name](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name))
* **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fnot)**? ([session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession))
* **[`or`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2For)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession)>)
* maxItems
`2048`
* **[`panes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fpanes)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`every`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fpanes%2Fproperties%2Fevery)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane))
- **[`none`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fpanes%2Fproperties%2Fnone)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane))
- **[`some`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fpanes%2Fproperties%2Fsome)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane))
No other properties are accepted.
* **[`windowCount`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2FwindowCount)**? ([session.window_count](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count))
* **[`windowLinks`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2FwindowLinks)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`every`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2FwindowLinks%2Fproperties%2Fevery)**? ([window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link))
- **[`none`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2FwindowLinks%2Fproperties%2Fnone)**? ([window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link))
- **[`some`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2FwindowLinks%2Fproperties%2Fsome)**? ([window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link))
No other properties are accepted.
* **[`windows`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fwindows)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`every`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fwindows%2Fproperties%2Fevery)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
- **[`none`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fwindows%2Fproperties%2Fnone)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
- **[`some`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession%2Fproperties%2Fwindows%2Fproperties%2Fsome)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
No other properties are accepted.
No other properties are accepted.
- ### `session.attached`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached%2FanyOf%2F1%2Fproperties%2Fnot)**? ([session.attached](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.attached))
No other properties are accepted.
* ### `session.created`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`-9223372036854776000`
* maximum
`9223372036854776000`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created%2FanyOf%2F1%2Fproperties%2Fnot)**? ([session.created](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.created))
No other properties are accepted.
- ### `session.id`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id%2FanyOf%2F1%2Fproperties%2Fnot)**? ([session.id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.id))
No other properties are accepted.
* ### `session.name`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`contains`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F1%2Fproperties%2Fcontains)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`endsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F1%2Fproperties%2FendsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F1%2Fproperties%2Fnot)**? ([session.name](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name))
- **[`startsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.name%2FanyOf%2F1%2Fproperties%2FstartsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
No other properties are accepted.
- ### `session.window_count`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count%2FanyOf%2F1%2Fproperties%2Fnot)**? ([session.window_count](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession.window_count))
No other properties are accepted.
* ### `window`: [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow)
* **[`activePane`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2FactivePane)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`is`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2FactivePane%2Fproperties%2Fis)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane) | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
- **[`isNot`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2FactivePane%2Fproperties%2FisNot)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane) | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
No other properties are accepted.
* **[`and`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fand)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow)>)
* maxItems
`2048`
* **[`height`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fheight)**? ([window.height](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height))
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fid)**? ([window.id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id))
* **[`layout`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Flayout)**? ([window.layout](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout))
* **[`name`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fname)**? ([window.name](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name))
* **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fnot)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
* **[`or`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2For)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow)>)
* maxItems
`2048`
* **[`paneCount`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2FpaneCount)**? ([window.pane_count](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count))
* **[`panes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fpanes)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`every`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fpanes%2Fproperties%2Fevery)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane))
- **[`none`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fpanes%2Fproperties%2Fnone)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane))
- **[`some`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fpanes%2Fproperties%2Fsome)**? ([pane](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fpane))
No other properties are accepted.
* **[`width`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2Fwidth)**? ([window.width](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width))
* **[`windowLinks`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2FwindowLinks)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`every`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2FwindowLinks%2Fproperties%2Fevery)**? ([window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link))
- **[`none`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2FwindowLinks%2Fproperties%2Fnone)**? ([window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link))
- **[`some`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow%2Fproperties%2FwindowLinks%2Fproperties%2Fsome)**? ([window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link))
No other properties are accepted.
No other properties are accepted.
- ### `window_link`: [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link)
* **[`active`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Factive)**? ([window_link.active](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.active))
* **[`and`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Fand)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link)>)
* maxItems
`2048`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Findex)**? ([window_link.index](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index))
* **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Fnot)**? ([window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link))
* **[`or`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2For)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[window_link](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link)>)
* maxItems
`2048`
* **[`session`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Fsession)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`is`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Fsession%2Fproperties%2Fis)**? ([session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession))
- **[`isNot`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Fsession%2Fproperties%2FisNot)**? ([session](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fsession))
No other properties are accepted.
* **[`sessionId`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2FsessionId)**? ([window_link.session_id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id))
* **[`window`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Fwindow)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`is`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Fwindow%2Fproperties%2Fis)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
- **[`isNot`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2Fwindow%2Fproperties%2FisNot)**? ([window](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow))
No other properties are accepted.
* **[`windowId`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link%2Fproperties%2FwindowId)**? ([window_link.window_id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id))
No other properties are accepted.
* ### `window_link.active`: [boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.active)
Matches one or more variants.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.active%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.active%2FanyOf%2F1%2Fproperties%2Fequals)**? ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.active%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)")>)
* maxItems
`1024`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.active%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window_link.active](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.active))
No other properties are accepted.
- ### `window_link.index`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`2147483647`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window_link.index](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.index))
No other properties are accepted.
* ### `window_link.session_id`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window_link.session_id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.session_id))
No other properties are accepted.
- ### `window_link.window_id`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window_link.window_id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow_link.window_id))
No other properties are accepted.
* ### `window.height`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window.height](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.height))
No other properties are accepted.
- ### `window.id`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window.id](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.id))
No other properties are accepted.
* ### `window.layout`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`contains`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F1%2Fproperties%2Fcontains)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`endsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F1%2Fproperties%2FendsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window.layout](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout))
- **[`startsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.layout%2FanyOf%2F1%2Fproperties%2FstartsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
No other properties are accepted.
- ### `window.name`: [string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F0)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`contains`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F1%2Fproperties%2Fcontains)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`endsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F1%2Fproperties%2FendsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F1%2Fproperties%2Fequals)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window.name](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name))
- **[`startsWith`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.name%2FanyOf%2F1%2Fproperties%2FstartsWith)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`65536`
* x-maxUtf8Bytes
`65536`
No other properties are accepted.
* ### `window.pane_count`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window.pane_count](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.pane_count))
No other properties are accepted.
- ### `window.width`: [integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
type [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width)
Matches one or more variants.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F0)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* minProperties
`1`
- **[`equals`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1%2Fproperties%2Fequals)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1%2Fproperties%2Fgt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`gte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1%2Fproperties%2Fgte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`in`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1%2Fproperties%2Fin)**? ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)")>)
* maxItems
`1024`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1%2Fproperties%2Fin%2Fitems)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lt`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1%2Fproperties%2Flt)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`lte`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1%2Fproperties%2Flte)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`4294967295`
- **[`not`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width%2FanyOf%2F1%2Fproperties%2Fnot)**? ([window.width](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.input%2F%24defs%2Fwindow.width))
No other properties are accepted.
## Annotations[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.annotations)
* [`destructiveHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#destructiveHint)
`false`
* [`idempotentHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#idempotentHint)
`false`
* [`openWorldHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#openWorldHint)
`false`
* [`readOnlyHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#readOnlyHint)
`false`
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/#mcp.tool.tmux_snapshot.schemas)
Use the complete advertised contract for validation and client integration.
Input schema
```json
{
"$defs": {
"client": {
"additionalProperties": false,
"properties": {
"and": {
"items": {
"$ref": "#/$defs/client"
},
"maxItems": 2048,
"type": "array"
},
"controlMode": {
"$ref": "#/$defs/client.control_mode"
},
"created": {
"$ref": "#/$defs/client.created"
},
"height": {
"$ref": "#/$defs/client.height"
},
"name": {
"$ref": "#/$defs/client.name"
},
"not": {
"$ref": "#/$defs/client"
},
"or": {
"items": {
"$ref": "#/$defs/client"
},
"maxItems": 2048,
"type": "array"
},
"pid": {
"$ref": "#/$defs/client.pid"
},
"readOnly": {
"$ref": "#/$defs/client.read_only"
},
"session": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"is": {
"anyOf": [
{
"$ref": "#/$defs/session"
},
{
"type": "null"
}
]
},
"isNot": {
"anyOf": [
{
"$ref": "#/$defs/session"
},
{
"type": "null"
}
]
}
},
"type": "object"
},
"sessionId": {
"$ref": "#/$defs/client.session_id"
},
"tty": {
"$ref": "#/$defs/client.tty"
},
"utf8": {
"$ref": "#/$defs/client.utf8"
},
"width": {
"$ref": "#/$defs/client.width"
}
},
"type": "object"
},
"client.control_mode": {
"anyOf": [
{
"type": "boolean"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"type": "boolean"
},
"in": {
"items": {
"type": "boolean"
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/client.control_mode"
}
},
"type": "object"
}
]
},
"client.created": {
"anyOf": [
{
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"gt": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"gte": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"in": {
"items": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"lte": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"not": {
"$ref": "#/$defs/client.created"
}
},
"type": "object"
}
]
},
"client.height": {
"anyOf": [
{
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/client.height"
}
},
"type": "object"
}
]
},
"client.name": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"contains": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"endsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/client.name"
},
"startsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
}
},
"type": "object"
}
]
},
"client.pid": {
"anyOf": [
{
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/client.pid"
}
},
"type": "object"
}
]
},
"client.read_only": {
"anyOf": [
{
"type": "boolean"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"type": "boolean"
},
"in": {
"items": {
"type": "boolean"
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/client.read_only"
}
},
"type": "object"
}
]
},
"client.session_id": {
"anyOf": [
{
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
"in": {
"items": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/client.session_id"
}
},
"type": "object"
}
]
},
"client.tty": {
"anyOf": [
{
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"contains": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"endsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"equals": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
"in": {
"items": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/client.tty"
},
"startsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
}
},
"type": "object"
}
]
},
"client.utf8": {
"anyOf": [
{
"type": "boolean"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"type": "boolean"
},
"in": {
"items": {
"type": "boolean"
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/client.utf8"
}
},
"type": "object"
}
]
},
"client.width": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/client.width"
}
},
"type": "object"
}
]
},
"pane": {
"additionalProperties": false,
"properties": {
"active": {
"$ref": "#/$defs/pane.active"
},
"and": {
"items": {
"$ref": "#/$defs/pane"
},
"maxItems": 2048,
"type": "array"
},
"currentCommand": {
"$ref": "#/$defs/pane.current_command"
},
"currentPath": {
"$ref": "#/$defs/pane.current_path"
},
"dead": {
"$ref": "#/$defs/pane.dead"
},
"deadStatus": {
"$ref": "#/$defs/pane.dead_status"
},
"height": {
"$ref": "#/$defs/pane.height"
},
"id": {
"$ref": "#/$defs/pane.id"
},
"index": {
"$ref": "#/$defs/pane.index"
},
"not": {
"$ref": "#/$defs/pane"
},
"or": {
"items": {
"$ref": "#/$defs/pane"
},
"maxItems": 2048,
"type": "array"
},
"pid": {
"$ref": "#/$defs/pane.pid"
},
"title": {
"$ref": "#/$defs/pane.title"
},
"width": {
"$ref": "#/$defs/pane.width"
},
"window": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"is": {
"$ref": "#/$defs/window"
},
"isNot": {
"$ref": "#/$defs/window"
}
},
"type": "object"
},
"windowId": {
"$ref": "#/$defs/pane.window_id"
}
},
"type": "object"
},
"pane.active": {
"anyOf": [
{
"type": "boolean"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"type": "boolean"
},
"in": {
"items": {
"type": "boolean"
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/pane.active"
}
},
"type": "object"
}
]
},
"pane.current_command": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"contains": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"endsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/pane.current_command"
},
"startsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
}
},
"type": "object"
}
]
},
"pane.current_path": {
"anyOf": [
{
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"contains": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"endsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"equals": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
"in": {
"items": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"type": "null"
}
]
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/pane.current_path"
},
"startsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
}
},
"type": "object"
}
]
},
"pane.dead": {
"anyOf": [
{
"type": "boolean"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"type": "boolean"
},
"in": {
"items": {
"type": "boolean"
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/pane.dead"
}
},
"type": "object"
}
]
},
"pane.dead_status": {
"anyOf": [
{
"anyOf": [
{
"maximum": 255,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"anyOf": [
{
"maximum": 255,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
"gt": {
"maximum": 255,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 255,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"anyOf": [
{
"maximum": 255,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 255,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 255,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/pane.dead_status"
}
},
"type": "object"
}
]
},
"pane.height": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/pane.height"
}
},
"type": "object"
}
]
},
"pane.id": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/pane.id"
}
},
"type": "object"
}
]
},
"pane.index": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/pane.index"
}
},
"type": "object"
}
]
},
"pane.pid": {
"anyOf": [
{
"anyOf": [
{
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"anyOf": [
{
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
"gt": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"anyOf": [
{
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
{
"type": "null"
}
]
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/pane.pid"
}
},
"type": "object"
}
]
},
"pane.title": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"contains": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"endsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/pane.title"
},
"startsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
}
},
"type": "object"
}
]
},
"pane.width": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/pane.width"
}
},
"type": "object"
}
]
},
"pane.window_id": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/pane.window_id"
}
},
"type": "object"
}
]
},
"session": {
"additionalProperties": false,
"properties": {
"and": {
"items": {
"$ref": "#/$defs/session"
},
"maxItems": 2048,
"type": "array"
},
"attached": {
"$ref": "#/$defs/session.attached"
},
"created": {
"$ref": "#/$defs/session.created"
},
"currentWindow": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"is": {
"anyOf": [
{
"$ref": "#/$defs/window"
},
{
"type": "null"
}
]
},
"isNot": {
"anyOf": [
{
"$ref": "#/$defs/window"
},
{
"type": "null"
}
]
}
},
"type": "object"
},
"id": {
"$ref": "#/$defs/session.id"
},
"name": {
"$ref": "#/$defs/session.name"
},
"not": {
"$ref": "#/$defs/session"
},
"or": {
"items": {
"$ref": "#/$defs/session"
},
"maxItems": 2048,
"type": "array"
},
"panes": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"every": {
"$ref": "#/$defs/pane"
},
"none": {
"$ref": "#/$defs/pane"
},
"some": {
"$ref": "#/$defs/pane"
}
},
"type": "object"
},
"windowCount": {
"$ref": "#/$defs/session.window_count"
},
"windowLinks": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"every": {
"$ref": "#/$defs/window_link"
},
"none": {
"$ref": "#/$defs/window_link"
},
"some": {
"$ref": "#/$defs/window_link"
}
},
"type": "object"
},
"windows": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"every": {
"$ref": "#/$defs/window"
},
"none": {
"$ref": "#/$defs/window"
},
"some": {
"$ref": "#/$defs/window"
}
},
"type": "object"
}
},
"type": "object"
},
"session.attached": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/session.attached"
}
},
"type": "object"
}
]
},
"session.created": {
"anyOf": [
{
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"gt": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"gte": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"in": {
"items": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"lte": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"not": {
"$ref": "#/$defs/session.created"
}
},
"type": "object"
}
]
},
"session.id": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/session.id"
}
},
"type": "object"
}
]
},
"session.name": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"contains": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"endsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/session.name"
},
"startsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
}
},
"type": "object"
}
]
},
"session.window_count": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/session.window_count"
}
},
"type": "object"
}
]
},
"window": {
"additionalProperties": false,
"properties": {
"activePane": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"is": {
"anyOf": [
{
"$ref": "#/$defs/pane"
},
{
"type": "null"
}
]
},
"isNot": {
"anyOf": [
{
"$ref": "#/$defs/pane"
},
{
"type": "null"
}
]
}
},
"type": "object"
},
"and": {
"items": {
"$ref": "#/$defs/window"
},
"maxItems": 2048,
"type": "array"
},
"height": {
"$ref": "#/$defs/window.height"
},
"id": {
"$ref": "#/$defs/window.id"
},
"layout": {
"$ref": "#/$defs/window.layout"
},
"name": {
"$ref": "#/$defs/window.name"
},
"not": {
"$ref": "#/$defs/window"
},
"or": {
"items": {
"$ref": "#/$defs/window"
},
"maxItems": 2048,
"type": "array"
},
"paneCount": {
"$ref": "#/$defs/window.pane_count"
},
"panes": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"every": {
"$ref": "#/$defs/pane"
},
"none": {
"$ref": "#/$defs/pane"
},
"some": {
"$ref": "#/$defs/pane"
}
},
"type": "object"
},
"width": {
"$ref": "#/$defs/window.width"
},
"windowLinks": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"every": {
"$ref": "#/$defs/window_link"
},
"none": {
"$ref": "#/$defs/window_link"
},
"some": {
"$ref": "#/$defs/window_link"
}
},
"type": "object"
}
},
"type": "object"
},
"window_link": {
"additionalProperties": false,
"properties": {
"active": {
"$ref": "#/$defs/window_link.active"
},
"and": {
"items": {
"$ref": "#/$defs/window_link"
},
"maxItems": 2048,
"type": "array"
},
"index": {
"$ref": "#/$defs/window_link.index"
},
"not": {
"$ref": "#/$defs/window_link"
},
"or": {
"items": {
"$ref": "#/$defs/window_link"
},
"maxItems": 2048,
"type": "array"
},
"session": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"is": {
"$ref": "#/$defs/session"
},
"isNot": {
"$ref": "#/$defs/session"
}
},
"type": "object"
},
"sessionId": {
"$ref": "#/$defs/window_link.session_id"
},
"window": {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"is": {
"$ref": "#/$defs/window"
},
"isNot": {
"$ref": "#/$defs/window"
}
},
"type": "object"
},
"windowId": {
"$ref": "#/$defs/window_link.window_id"
}
},
"type": "object"
},
"window_link.active": {
"anyOf": [
{
"type": "boolean"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"type": "boolean"
},
"in": {
"items": {
"type": "boolean"
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/window_link.active"
}
},
"type": "object"
}
]
},
"window_link.index": {
"anyOf": [
{
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/window_link.index"
}
},
"type": "object"
}
]
},
"window_link.session_id": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/window_link.session_id"
}
},
"type": "object"
}
]
},
"window_link.window_id": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/window_link.window_id"
}
},
"type": "object"
}
]
},
"window.height": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/window.height"
}
},
"type": "object"
}
]
},
"window.id": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/window.id"
}
},
"type": "object"
}
]
},
"window.layout": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"contains": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"endsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/window.layout"
},
"startsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
}
},
"type": "object"
}
]
},
"window.name": {
"anyOf": [
{
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"contains": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"endsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"equals": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"in": {
"items": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
},
"maxItems": 1024,
"type": "array"
},
"not": {
"$ref": "#/$defs/window.name"
},
"startsWith": {
"maxLength": 65536,
"type": "string",
"x-maxUtf8Bytes": 65536
}
},
"type": "object"
}
]
},
"window.pane_count": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/window.pane_count"
}
},
"type": "object"
}
]
},
"window.width": {
"anyOf": [
{
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
{
"additionalProperties": false,
"minProperties": 1,
"properties": {
"equals": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"gte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"in": {
"items": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"maxItems": 1024,
"type": "array"
},
"lt": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"lte": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"not": {
"$ref": "#/$defs/window.width"
}
},
"type": "object"
}
]
}
},
"$schema": "https://json-schema.org/draft/2020-12/schema",
"additionalProperties": false,
"oneOf": [
{
"not": {
"required": [
"cursor"
]
},
"required": [
"entity"
]
},
{
"not": {
"anyOf": [
{
"required": [
"entity"
]
},
{
"required": [
"criteria"
]
},
{
"required": [
"limit"
]
}
]
},
"required": [
"cursor"
]
}
],
"properties": {
"criteria": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"entity": {
"const": "session"
},
"profile": {
"const": "libtmux-ruby.where"
},
"version": {
"const": 1,
"type": "integer"
},
"where": {
"$ref": "#/$defs/session"
}
},
"required": [
"profile",
"version",
"entity",
"where"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"entity": {
"const": "window"
},
"profile": {
"const": "libtmux-ruby.where"
},
"version": {
"const": 1,
"type": "integer"
},
"where": {
"$ref": "#/$defs/window"
}
},
"required": [
"profile",
"version",
"entity",
"where"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"entity": {
"const": "pane"
},
"profile": {
"const": "libtmux-ruby.where"
},
"version": {
"const": 1,
"type": "integer"
},
"where": {
"$ref": "#/$defs/pane"
}
},
"required": [
"profile",
"version",
"entity",
"where"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"entity": {
"const": "window_link"
},
"profile": {
"const": "libtmux-ruby.where"
},
"version": {
"const": 1,
"type": "integer"
},
"where": {
"$ref": "#/$defs/window_link"
}
},
"required": [
"profile",
"version",
"entity",
"where"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"entity": {
"const": "client"
},
"profile": {
"const": "libtmux-ruby.where"
},
"version": {
"const": 1,
"type": "integer"
},
"where": {
"$ref": "#/$defs/client"
}
},
"required": [
"profile",
"version",
"entity",
"where"
],
"type": "object"
}
]
},
"cursor": {
"maxLength": 43,
"pattern": "^[a-f0-9]{32}:[0-9]{1,10}$",
"type": "string"
},
"entity": {
"enum": [
"session",
"window",
"pane",
"window_link",
"client"
]
},
"limit": {
"maximum": 200,
"minimum": 1,
"type": "integer"
}
},
"required": [],
"type": "object"
}
```
Output schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"data": {
"additionalProperties": false,
"properties": {
"capture_id": {
"type": "string"
},
"coverage": {
"additionalProperties": {
"enum": [
"complete",
"unloaded"
]
},
"type": "object"
},
"entity": {
"enum": [
"session",
"window",
"pane",
"window_link",
"client"
]
},
"interval": {
"additionalProperties": false,
"properties": {
"clock": {
"const": "monotonic_seconds"
},
"finished": {
"type": "number"
},
"reads": {
"minimum": 0,
"type": "integer"
},
"started": {
"type": "number"
}
},
"required": [
"clock",
"started",
"finished",
"reads"
],
"type": "object"
},
"items": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"fields": {
"additionalProperties": false,
"properties": {
"attached": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"created": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"id": {
"type": "string"
},
"name": {
"type": "string"
},
"windowCount": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
}
},
"required": [
"id",
"name",
"created",
"attached",
"windowCount"
],
"type": "object"
},
"kind": {
"const": "session"
},
"ref": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"kind",
"fields",
"ref"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"fields": {
"additionalProperties": false,
"properties": {
"height": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"id": {
"type": "string"
},
"layout": {
"type": "string"
},
"name": {
"type": "string"
},
"paneCount": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"width": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
}
},
"required": [
"id",
"name",
"width",
"height",
"paneCount",
"layout"
],
"type": "object"
},
"kind": {
"const": "window"
},
"ref": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"kind",
"fields",
"ref"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"fields": {
"additionalProperties": false,
"properties": {
"active": {
"type": "boolean"
},
"currentCommand": {
"type": "string"
},
"currentPath": {
"type": [
"string",
"null"
]
},
"dead": {
"type": "boolean"
},
"deadStatus": {
"maximum": 255,
"minimum": 0,
"type": [
"integer",
"null"
]
},
"height": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"id": {
"type": "string"
},
"index": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"pid": {
"maximum": 2147483647,
"minimum": 0,
"type": [
"integer",
"null"
]
},
"title": {
"type": "string"
},
"width": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
},
"windowId": {
"type": "string"
}
},
"required": [
"id",
"windowId",
"index",
"pid",
"currentCommand",
"currentPath",
"title",
"active",
"dead",
"deadStatus",
"width",
"height"
],
"type": "object"
},
"kind": {
"const": "pane"
},
"ref": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"kind",
"fields",
"ref"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"fields": {
"additionalProperties": false,
"properties": {
"active": {
"type": "boolean"
},
"index": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"sessionId": {
"type": "string"
},
"windowId": {
"type": "string"
}
},
"required": [
"sessionId",
"windowId",
"index",
"active"
],
"type": "object"
},
"kind": {
"const": "window_link"
},
"ref": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
}
},
"required": [
"kind",
"fields",
"ref"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"fields": {
"additionalProperties": false,
"properties": {
"controlMode": {
"type": "boolean"
},
"created": {
"maximum": 9223372036854776000,
"minimum": -9223372036854776000,
"type": "integer"
},
"height": {
"maximum": 4294967295,
"minimum": 0,
"type": [
"integer",
"null"
]
},
"name": {
"type": "string"
},
"pid": {
"maximum": 2147483647,
"minimum": 0,
"type": "integer"
},
"readOnly": {
"type": "boolean"
},
"sessionId": {
"type": [
"string",
"null"
]
},
"tty": {
"type": [
"string",
"null"
]
},
"utf8": {
"type": "boolean"
},
"width": {
"maximum": 4294967295,
"minimum": 0,
"type": "integer"
}
},
"required": [
"name",
"pid",
"created",
"tty",
"sessionId",
"width",
"height",
"readOnly",
"utf8",
"controlMode"
],
"type": "object"
},
"kind": {
"const": "client"
},
"ref": {
"type": "null"
}
},
"required": [
"kind",
"fields",
"ref"
],
"type": "object"
}
]
},
"maxItems": 200,
"type": "array"
},
"next_cursor": {
"type": "string"
},
"server_identity": {
"additionalProperties": false,
"properties": {
"generation": {
"type": "string"
},
"pid": {
"type": "integer"
},
"start_time": {
"type": "integer"
},
"tmux_version": {
"type": "string"
}
},
"required": [
"generation",
"pid",
"start_time",
"tmux_version"
],
"type": "object"
},
"truncated": {
"type": "boolean"
}
},
"required": [
"capture_id",
"server_identity",
"entity",
"items",
"coverage",
"interval",
"truncated"
],
"type": "object"
},
"ok": {
"const": true
}
},
"required": [
"ok",
"data"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"error": {
"additionalProperties": false,
"properties": {
"code": {
"type": "string"
},
"delivery": {
"enum": [
"not_sent",
"possibly_sent",
"observed"
]
},
"effects": {
"additionalProperties": false,
"properties": {
"created": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"maxItems": 3,
"type": "array"
},
"state": {
"enum": [
"none",
"known",
"unknown"
]
}
},
"required": [
"state",
"created"
],
"type": "object"
},
"message": {
"type": "string"
}
},
"required": [
"code",
"message",
"delivery"
],
"type": "object"
},
"ok": {
"const": false
}
},
"required": [
"ok",
"error"
],
"type": "object"
}
],
"type": "object"
}
```
---
# tmux_wait
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/
> Wait for observed literal screen text or the initial pane process exit. Deadline in seconds is capped by the application limit. Pane exit is observed through process descriptors. The screen_contains condition joins wrapped rows, uses control events on tmux>=3.7 and polls the pane screen on older daemons, which take no control client. A pane or tmux server that ends first fails with pane_died and the last rows read in error.capture; a lost control stream fails with observation_lost. Requires tmux>=3.3a and Linux peer pidfds with matching PID namespaces or Darwin kqueue process observation. Reports observed evidence, never remote termination caused by cancellation or an inferred process exit status.
tool MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* **tmux_wait**()
tool \[[source](https://github.com/libtmux/libtmux-ruby/blob/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267/gems/libtmux-mcp/lib/libtmux/mcp/catalog.rb#L242)][¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait)
Wait for observed literal screen text or the initial pane process exit. Deadline in seconds is capped by the application limit. Pane exit is observed through process descriptors. The screen_contains condition joins wrapped rows, uses control events on tmux>=3.7 and polls the pane screen on older daemons, which take no control client. A pane or tmux server that ends first fails with pane_died and the last rows read in error.capture; a lost control stream fails with observation_lost. Requires tmux>=3.3a and Linux peer pidfds with matching PID namespaces or Darwin kqueue process observation. Reports observed evidence, never remote termination caused by cancellation or an inferred process exit status.
* MCP request method
`tools/call` Send `tmux_wait` as the tool name, with the arguments below.
* Tool selection
Opt in with `--enable-tool tmux_wait`.
## Arguments[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.parameters)
No named arguments.
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`condition`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fcondition)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fcondition%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`text`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fcondition%2FoneOf%2F0%2Fproperties%2Ftext)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`4096`
* **[`type`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fcondition%2FoneOf%2F0%2Fproperties%2Ftype)** ("screen_contains")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fcondition%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`type`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fcondition%2FoneOf%2F1%2Fproperties%2Ftype)** ("process_exit")
No other properties are accepted.
* **[`history_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fhistory_lines)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`max_bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fmax_bytes)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`262144`
* **[`max_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Fmax_lines)**? ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`1000`
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`timeout`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.input%2FoneOf%2F0%2Fproperties%2Ftimeout)**? ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* maximum
`60`
* exclusiveMinimum
`0`
No other properties are accepted.
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.result)
Returns [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`data`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`capture`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fbytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fcapture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`encoding`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fencoding)** ("utf-8" | "base64")
* **[`history_continuity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fhistory_continuity)** ("unknown")
* **[`interval`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Finterval)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`clock`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Fclock)** ("monotonic_seconds")
* **[`finished`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Ffinished)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`started`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Fstarted)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
No other properties are accepted.
* **[`mode`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fmode)** ("snapshot")
* **[`next_cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fnext_cursor)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`row_count`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Frow_count)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`rows`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Frows)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1000`
* **[`scope`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fscope)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`history_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fhistory_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`max_bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fmax_bytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`262144`
* **[`max_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fmax_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`1000`
No other properties are accepted.
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftruncated)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`base_capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fbase_capture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fbytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fcapture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`encoding`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fencoding)** ("utf-8" | "base64")
* **[`history_continuity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fhistory_continuity)** ("unknown")
* **[`interval`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Finterval)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`clock`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Fclock)** ("monotonic_seconds")
* **[`finished`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Ffinished)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`started`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Fstarted)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
No other properties are accepted.
* **[`mode`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fmode)** ("delta")
* **[`next_cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fnext_cursor)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`reset`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Freset)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`row_count`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Frow_count)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`scope`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fscope)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`history_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fhistory_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`max_bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fmax_bytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`262144`
* **[`max_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fmax_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`1000`
No other properties are accepted.
* **[`splice`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fsplice)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`delete`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Fdelete)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`rows`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Frows)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1000`
* **[`start`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Fstart)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
No other properties are accepted.
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftruncated)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
No other properties are accepted.
* **[`condition`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Fcondition)** ("screen_contains")
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`condition`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fcondition)** ("process_exit")
* **[`exit_status`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fexit_status)** ("unobserved")
* **[`observed_at`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fobserved_at)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fdata%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F0%2Fproperties%2Fok)** (true)
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`error`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`capture`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fbytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fcapture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`encoding`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fencoding)** ("utf-8" | "base64")
* **[`history_continuity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fhistory_continuity)** ("unknown")
* **[`interval`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Finterval)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`clock`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Fclock)** ("monotonic_seconds")
* **[`finished`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Ffinished)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`started`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Finterval%2Fproperties%2Fstarted)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
No other properties are accepted.
* **[`mode`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fmode)** ("snapshot")
* **[`next_cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fnext_cursor)**? ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`row_count`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Frow_count)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`rows`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Frows)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1000`
* **[`scope`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fscope)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`history_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fhistory_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`max_bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fmax_bytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`262144`
* **[`max_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Fscope%2Fproperties%2Fmax_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`1000`
No other properties are accepted.
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F0%2Fproperties%2Ftruncated)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`base_capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fbase_capture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fbytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`262144`
* **[`capture_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fcapture_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`encoding`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fencoding)** ("utf-8" | "base64")
* **[`history_continuity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fhistory_continuity)** ("unknown")
* **[`interval`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Finterval)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`clock`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Fclock)** ("monotonic_seconds")
* **[`finished`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Ffinished)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* **[`started`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Finterval%2Fproperties%2Fstarted)** ([number](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
No other properties are accepted.
* **[`mode`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fmode)** ("delta")
* **[`next_cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fnext_cursor)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`process_generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fprocess_generation)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)") | [null](https://json-schema.org/understanding-json-schema/reference/null "null (JSON Schema)"))
* **[`reset`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Freset)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
* **[`row_count`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Frow_count)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`scope`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fscope)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`history_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fhistory_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* maximum
`1000`
* **[`max_bytes`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fmax_bytes)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`262144`
* **[`max_lines`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fscope%2Fproperties%2Fmax_lines)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`1`
* maximum
`1000`
No other properties are accepted.
* **[`splice`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fsplice)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`delete`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Fdelete)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`rows`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Frows)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)")>)
* maxItems
`1000`
* **[`start`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Fsplice%2Fproperties%2Fstart)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
No other properties are accepted.
* **[`target`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftarget%2FoneOf%2F0%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[`truncated`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcapture%2FoneOf%2F1%2Fproperties%2Ftruncated)** ([boolean](https://json-schema.org/understanding-json-schema/reference/boolean "boolean (JSON Schema)"))
No other properties are accepted.
* **[`code`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fcode)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* **[`delivery`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fdelivery)** ("not_sent" | "possibly_sent" | "observed")
* **[`effects`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects)**? ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`created`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated)** ([Array](https://json-schema.org/understanding-json-schema/reference/array "array (JSON Schema)")<[object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)")>)
* maxItems
`3`
- **[Items](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)") | [object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
Matches exactly one variant.
* **[Variant 1](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F0%2Fproperties%2Fkind)** ("session")
No other properties are accepted.
* **[Variant 2](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F1%2Fproperties%2Fkind)** ("window")
No other properties are accepted.
* **[Variant 3](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^%[0-9]+$"`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F2%2Fproperties%2Fkind)** ("pane")
No other properties are accepted.
* **[Variant 4](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3)** ([object](https://json-schema.org/understanding-json-schema/reference/object "object (JSON Schema)"))
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fgeneration)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* minLength
`1`
* maxLength
`128`
* **[`id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fid)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^@[0-9]+$"`
* **[`index`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Findex)** ([integer](https://json-schema.org/understanding-json-schema/reference/numeric "numeric (JSON Schema)"))
* minimum
`0`
* **[`kind`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fkind)** ("window_link")
* **[`session_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fcreated%2Fitems%2FoneOf%2F3%2Fproperties%2Fsession_id)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
* maxLength
`32`
* pattern
`"^\\$[0-9]+$"`
No other properties are accepted.
* **[`state`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Feffects%2Fproperties%2Fstate)** ("none" | "known" | "unknown")
No other properties are accepted.
* **[`message`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Ferror%2Fproperties%2Fmessage)** ([string](https://json-schema.org/understanding-json-schema/reference/string "string (JSON Schema)"))
No other properties are accepted.
* **[`ok`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.output%2FoneOf%2F1%2Fproperties%2Fok)** (false)
No other properties are accepted.
## Annotations[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.annotations)
* [`destructiveHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#destructiveHint)
`false`
* [`idempotentHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#idempotentHint)
`false`
* [`openWorldHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#openWorldHint)
`false`
* [`readOnlyHint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/glossary/#readOnlyHint)
`false`
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_wait/#mcp.tool.tmux_wait.schemas)
Use the complete advertised contract for validation and client integration.
Input schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"condition": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"text": {
"maxLength": 4096,
"minLength": 1,
"type": "string"
},
"type": {
"const": "screen_contains"
}
},
"required": [
"type",
"text"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"type": {
"const": "process_exit"
}
},
"required": [
"type"
],
"type": "object"
}
]
},
"history_lines": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"max_bytes": {
"maximum": 262144,
"minimum": 1,
"type": "integer"
},
"max_lines": {
"maximum": 1000,
"minimum": 1,
"type": "integer"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"timeout": {
"exclusiveMinimum": 0,
"maximum": 60,
"type": "number"
}
},
"required": [
"target",
"condition"
],
"type": "object"
}
],
"type": "object"
}
```
Output schema
```json
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"oneOf": [
{
"additionalProperties": false,
"properties": {
"data": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"capture": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"bytes": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"capture_id": {
"type": "string"
},
"encoding": {
"enum": [
"utf-8",
"base64"
]
},
"history_continuity": {
"const": "unknown"
},
"interval": {
"additionalProperties": false,
"properties": {
"clock": {
"const": "monotonic_seconds"
},
"finished": {
"type": "number"
},
"started": {
"type": "number"
}
},
"required": [
"clock",
"started",
"finished"
],
"type": "object"
},
"mode": {
"const": "snapshot"
},
"next_cursor": {
"type": "string"
},
"process_generation": {
"type": [
"string",
"null"
]
},
"row_count": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"rows": {
"items": {
"type": "string"
},
"maxItems": 1000,
"type": "array"
},
"scope": {
"additionalProperties": false,
"properties": {
"history_lines": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"max_bytes": {
"maximum": 262144,
"minimum": 1,
"type": "integer"
},
"max_lines": {
"maximum": 1000,
"minimum": 1,
"type": "integer"
}
},
"required": [
"max_lines",
"max_bytes",
"history_lines"
],
"type": "object"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"truncated": {
"type": "boolean"
}
},
"required": [
"target",
"capture_id",
"process_generation",
"encoding",
"row_count",
"bytes",
"truncated",
"history_continuity",
"interval",
"scope",
"mode",
"rows"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"base_capture_id": {
"type": "string"
},
"bytes": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"capture_id": {
"type": "string"
},
"encoding": {
"enum": [
"utf-8",
"base64"
]
},
"history_continuity": {
"const": "unknown"
},
"interval": {
"additionalProperties": false,
"properties": {
"clock": {
"const": "monotonic_seconds"
},
"finished": {
"type": "number"
},
"started": {
"type": "number"
}
},
"required": [
"clock",
"started",
"finished"
],
"type": "object"
},
"mode": {
"const": "delta"
},
"next_cursor": {
"type": "string"
},
"process_generation": {
"type": [
"string",
"null"
]
},
"reset": {
"type": "boolean"
},
"row_count": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"scope": {
"additionalProperties": false,
"properties": {
"history_lines": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"max_bytes": {
"maximum": 262144,
"minimum": 1,
"type": "integer"
},
"max_lines": {
"maximum": 1000,
"minimum": 1,
"type": "integer"
}
},
"required": [
"max_lines",
"max_bytes",
"history_lines"
],
"type": "object"
},
"splice": {
"additionalProperties": false,
"properties": {
"delete": {
"minimum": 0,
"type": "integer"
},
"rows": {
"items": {
"type": "string"
},
"maxItems": 1000,
"type": "array"
},
"start": {
"minimum": 0,
"type": "integer"
}
},
"required": [
"start",
"delete",
"rows"
],
"type": "object"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"truncated": {
"type": "boolean"
}
},
"required": [
"target",
"capture_id",
"process_generation",
"encoding",
"row_count",
"bytes",
"truncated",
"history_continuity",
"interval",
"scope",
"mode",
"base_capture_id",
"reset",
"splice",
"next_cursor"
],
"type": "object"
}
]
},
"condition": {
"const": "screen_contains"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"target",
"condition",
"capture"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"condition": {
"const": "process_exit"
},
"exit_status": {
"const": "unobserved"
},
"observed_at": {
"type": "number"
},
"process_generation": {
"type": "string"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
}
},
"required": [
"target",
"condition",
"process_generation",
"observed_at",
"exit_status"
],
"type": "object"
}
]
},
"ok": {
"const": true
}
},
"required": [
"ok",
"data"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"error": {
"additionalProperties": false,
"properties": {
"capture": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"bytes": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"capture_id": {
"type": "string"
},
"encoding": {
"enum": [
"utf-8",
"base64"
]
},
"history_continuity": {
"const": "unknown"
},
"interval": {
"additionalProperties": false,
"properties": {
"clock": {
"const": "monotonic_seconds"
},
"finished": {
"type": "number"
},
"started": {
"type": "number"
}
},
"required": [
"clock",
"started",
"finished"
],
"type": "object"
},
"mode": {
"const": "snapshot"
},
"next_cursor": {
"type": "string"
},
"process_generation": {
"type": [
"string",
"null"
]
},
"row_count": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"rows": {
"items": {
"type": "string"
},
"maxItems": 1000,
"type": "array"
},
"scope": {
"additionalProperties": false,
"properties": {
"history_lines": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"max_bytes": {
"maximum": 262144,
"minimum": 1,
"type": "integer"
},
"max_lines": {
"maximum": 1000,
"minimum": 1,
"type": "integer"
}
},
"required": [
"max_lines",
"max_bytes",
"history_lines"
],
"type": "object"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"truncated": {
"type": "boolean"
}
},
"required": [
"target",
"capture_id",
"process_generation",
"encoding",
"row_count",
"bytes",
"truncated",
"history_continuity",
"interval",
"scope",
"mode",
"rows"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"base_capture_id": {
"type": "string"
},
"bytes": {
"maximum": 262144,
"minimum": 0,
"type": "integer"
},
"capture_id": {
"type": "string"
},
"encoding": {
"enum": [
"utf-8",
"base64"
]
},
"history_continuity": {
"const": "unknown"
},
"interval": {
"additionalProperties": false,
"properties": {
"clock": {
"const": "monotonic_seconds"
},
"finished": {
"type": "number"
},
"started": {
"type": "number"
}
},
"required": [
"clock",
"started",
"finished"
],
"type": "object"
},
"mode": {
"const": "delta"
},
"next_cursor": {
"type": "string"
},
"process_generation": {
"type": [
"string",
"null"
]
},
"reset": {
"type": "boolean"
},
"row_count": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"scope": {
"additionalProperties": false,
"properties": {
"history_lines": {
"maximum": 1000,
"minimum": 0,
"type": "integer"
},
"max_bytes": {
"maximum": 262144,
"minimum": 1,
"type": "integer"
},
"max_lines": {
"maximum": 1000,
"minimum": 1,
"type": "integer"
}
},
"required": [
"max_lines",
"max_bytes",
"history_lines"
],
"type": "object"
},
"splice": {
"additionalProperties": false,
"properties": {
"delete": {
"minimum": 0,
"type": "integer"
},
"rows": {
"items": {
"type": "string"
},
"maxItems": 1000,
"type": "array"
},
"start": {
"minimum": 0,
"type": "integer"
}
},
"required": [
"start",
"delete",
"rows"
],
"type": "object"
},
"target": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
}
]
},
"truncated": {
"type": "boolean"
}
},
"required": [
"target",
"capture_id",
"process_generation",
"encoding",
"row_count",
"bytes",
"truncated",
"history_continuity",
"interval",
"scope",
"mode",
"base_capture_id",
"reset",
"splice",
"next_cursor"
],
"type": "object"
}
]
},
"code": {
"type": "string"
},
"delivery": {
"enum": [
"not_sent",
"possibly_sent",
"observed"
]
},
"effects": {
"additionalProperties": false,
"properties": {
"created": {
"items": {
"oneOf": [
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
},
"kind": {
"const": "session"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"kind": {
"const": "window"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^%[0-9]+$",
"type": "string"
},
"kind": {
"const": "pane"
}
},
"required": [
"generation",
"kind",
"id"
],
"type": "object"
},
{
"additionalProperties": false,
"properties": {
"generation": {
"maxLength": 128,
"minLength": 1,
"type": "string"
},
"id": {
"maxLength": 32,
"pattern": "^@[0-9]+$",
"type": "string"
},
"index": {
"minimum": 0,
"type": "integer"
},
"kind": {
"const": "window_link"
},
"session_id": {
"maxLength": 32,
"pattern": "^\\$[0-9]+$",
"type": "string"
}
},
"required": [
"generation",
"kind",
"id",
"session_id",
"index"
],
"type": "object"
}
]
},
"maxItems": 3,
"type": "array"
},
"state": {
"enum": [
"none",
"known",
"unknown"
]
}
},
"required": [
"state",
"created"
],
"type": "object"
},
"message": {
"type": "string"
}
},
"required": [
"code",
"message",
"delivery"
],
"type": "object"
},
"ok": {
"const": false
}
},
"required": [
"ok",
"error"
],
"type": "object"
}
],
"type": "object"
}
```
---
# Prompts
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/prompts/
> Browse the reusable workflows the server provides through prompts/get. Each prompt documents its arguments and the messages it returns.
Browse the reusable workflows the server provides through prompts/get. Each prompt documents its arguments and the messages it returns.
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
The reference configuration advertises 0 prompts. Your server’s available objects depend on its configuration. [Setup documentation](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/) explains how to connect a client.
This server does not advertise prompts in the reference configuration.
Reference configuration
* `mode`
`explicit CLI options`
* `tools`
`tmux_capabilities,tmux_snapshot,tmux_capture,tmux_wait,tmux_create,tmux_send,tmux_close,tmux_run`
Protocol version: `2025-11-25`. [Download the full protocol catalog](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools.json).
Source: [`libtmux/libtmux-ruby@d8ce4bbee0ca`](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).
The [language API reference](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/) documents embedding and implementation types.
Source revision: [libtmux/libtmux-ruby@d8ce4bbee0ca7748a81929f81f7d8d07f8c51267](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).
---
# Resources
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/
> Browse the data the server exposes through resources/read. Resource templates describe URI patterns and the variables used to select a resource.
Browse the data the server exposes through resources/read. Resource templates describe URI patterns and the variables used to select a resource.
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
The reference configuration advertises 3 resources and resource templates. Your server’s available objects depend on its configuration. [Setup documentation](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/guides/) explains how to connect a client.
## Resource templates3 objects[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/#resources-resource-templates)
[tmux_metadata](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/)
Acquire metadata through [tmux_snapshot](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/) with its default page limit. Encode every URI component; generation must match discovery. Reports capture interval and truncation.
[tmux_metadata_page](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/)
Read a retained [tmux_snapshot](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/) page without refreshing it. Encode the cursor component; endpoint, generation and entity must match its captured query.
[tmux_screen](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/)
Capture an exact pane through [tmux_capture](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/) with its default byte/line bounds, without cursor tracking. Percent-encode pane IDs. Invalid UTF-8 is an application/octet-stream blob; \_meta includes capture interval, truncation and unknown history continuity.
Reference configuration
* `mode`
`explicit CLI options`
* `tools`
`tmux_capabilities,tmux_snapshot,tmux_capture,tmux_wait,tmux_create,tmux_send,tmux_close,tmux_run`
Protocol version: `2025-11-25`. [Download the full protocol catalog](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools.json).
Source: [`libtmux/libtmux-ruby@d8ce4bbee0ca`](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).
The [language API reference](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/reference/) documents embedding and implementation types.
Source revision: [libtmux/libtmux-ruby@d8ce4bbee0ca7748a81929f81f7d8d07f8c51267](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).
---
# tmux_metadata
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/
> Acquire metadata through tmux_snapshot with its default page limit. Encode every URI component; generation must match discovery. Reports capture interval and truncation.
resource template MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* `tmux://{endpoint}/{generation}/snapshots/{entity}`
resource template [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D)
Acquire metadata through [tmux_snapshot](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/) with its default page limit. Encode every URI component; generation must match discovery. Reports capture interval and truncation.
* MCP request method
`resources/read` Send the resource URI shown above.
* MIME type
`application/json`
## URI parameters[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D.parameters)
* **[`endpoint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D.parameter.endpoint)**
* Binding
URI variable
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D.parameter.generation)**
* Binding
URI variable
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D.parameter.entity)**
* Binding
URI variable
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D.result)
Returns resource contents for the requested URI with MIME type `application/json`.
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D.schemas)
Use the complete advertised contract for validation and client integration.
Registration
```json
{
"description": "Acquire metadata through tmux_snapshot with its default page limit. Encode every URI component; generation must match discovery. Reports capture interval and truncation.",
"mimeType": "application/json",
"name": "tmux_metadata",
"uriTemplate": "tmux://{endpoint}/{generation}/snapshots/{entity}"
}
```
Source revision: [libtmux/libtmux-ruby@d8ce4bbee0ca7748a81929f81f7d8d07f8c51267](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).
---
# tmux_metadata_page
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/
> Read a retained tmux_snapshot page without refreshing it. Encode the cursor component; endpoint, generation and entity must match its captured query.
resource template MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* `tmux://{endpoint}/{generation}/snapshots/{entity}/pages/{cursor}`
resource template [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D%2Fpages%2F%7Bcursor%7D)
Read a retained [tmux_snapshot](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_snapshot/) page without refreshing it. Encode the cursor component; endpoint, generation and entity must match its captured query.
* MCP request method
`resources/read` Send the resource URI shown above.
* MIME type
`application/json`
## URI parameters[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D%2Fpages%2F%7Bcursor%7D.parameters)
* **[`endpoint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D%2Fpages%2F%7Bcursor%7D.parameter.endpoint)**
* Binding
URI variable
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D%2Fpages%2F%7Bcursor%7D.parameter.generation)**
* Binding
URI variable
* **[`entity`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D%2Fpages%2F%7Bcursor%7D.parameter.entity)**
* Binding
URI variable
* **[`cursor`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D%2Fpages%2F%7Bcursor%7D.parameter.cursor)**
* Binding
URI variable
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D%2Fpages%2F%7Bcursor%7D.result)
Returns resource contents for the requested URI with MIME type `application/json`.
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_metadata_page/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fsnapshots%2F%7Bentity%7D%2Fpages%2F%7Bcursor%7D.schemas)
Use the complete advertised contract for validation and client integration.
Registration
```json
{
"description": "Read a retained tmux_snapshot page without refreshing it. Encode the cursor component; endpoint, generation and entity must match its captured query.",
"mimeType": "application/json",
"name": "tmux_metadata_page",
"uriTemplate": "tmux://{endpoint}/{generation}/snapshots/{entity}/pages/{cursor}"
}
```
Source revision: [libtmux/libtmux-ruby@d8ce4bbee0ca7748a81929f81f7d8d07f8c51267](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).
---
# tmux_screen
Source: https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/
> Capture an exact pane through tmux_capture with its default byte/line bounds, without cursor tracking. Percent-encode pane IDs. Invalid UTF-8 is an application/octet-stream blob; _meta includes capture interval, truncation and unknown history continuity.
resource template MCPv0.1.0.alpha.3
MCP concept example
A working example of the core library. It can change without notice.
[What concept means](https://libtmux.org/en/meta/support/#concept-and-alpha)
* `tmux://{endpoint}/{generation}/panes/{pane_id}/screen`
resource template [¶](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fpanes%2F%7Bpane_id%7D%2Fscreen)
Capture an exact pane through [tmux_capture](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/tools/tmux_capture/) with its default byte/line bounds, without cursor tracking. Percent-encode pane IDs. Invalid UTF-8 is an application/octet-stream blob; \_meta includes capture interval, truncation and unknown history continuity.
* MCP request method
`resources/read` Send the resource URI shown above.
* MIME type
`text/plain`
## URI parameters[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fpanes%2F%7Bpane_id%7D%2Fscreen.parameters)
* **[`endpoint`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fpanes%2F%7Bpane_id%7D%2Fscreen.parameter.endpoint)**
* Binding
URI variable
* **[`generation`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fpanes%2F%7Bpane_id%7D%2Fscreen.parameter.generation)**
* Binding
URI variable
* **[`pane_id`](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fpanes%2F%7Bpane_id%7D%2Fscreen.parameter.pane_id)**
* Binding
URI variable
## Result[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fpanes%2F%7Bpane_id%7D%2Fscreen.result)
Returns resource contents for the requested URI with MIME type `text/plain`.
## Protocol data[#](https://libtmux.org/en/ruby/v0.1.0.alpha.3/mcp/resources/templates/tmux_screen/#mcp.resource-template.tmux%3A%2F%2F%7Bendpoint%7D%2F%7Bgeneration%7D%2Fpanes%2F%7Bpane_id%7D%2Fscreen.schemas)
Use the complete advertised contract for validation and client integration.
Registration
```json
{
"description": "Capture an exact pane through tmux_capture with its default byte/line bounds, without cursor tracking. Percent-encode pane IDs. Invalid UTF-8 is an application/octet-stream blob; _meta includes capture interval, truncation and unknown history continuity.",
"mimeType": "text/plain",
"name": "tmux_screen",
"uriTemplate": "tmux://{endpoint}/{generation}/panes/{pane_id}/screen"
}
```
Source revision: [libtmux/libtmux-ruby@d8ce4bbee0ca7748a81929f81f7d8d07f8c51267](https://github.com/libtmux/libtmux-ruby/tree/d8ce4bbee0ca7748a81929f81f7d8d07f8c51267).