Agent orchestrator

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Python
Package:    libtmux (PyPI)
Repository: https://github.com/tmux-python/libtmux

Read these before writing code:
- https://libtmux.org/en/py/latest/llms.txt
  every page for Python, as a list
- https://libtmux.org/en/py/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/py/latest/reference/
  the Python API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Python project yet, start one:
       uv init
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. libtmux 0.62.0 is the current release on PyPI.
       uv add libtmux
   Check https://pypi.org/project/libtmux/ if you need a different version.
   If this project already uses pip, Poetry or PDM, add the dependency with
   that tool instead: the package is the same.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

For Python: libtmux for Python is synchronous. There is no `async def` in
the package, so reach for threads or processes rather than looking for an
async API that is not there.

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Ruby
Package:    libtmux (RubyGems)
Repository: https://github.com/libtmux/libtmux-ruby

Read these before writing code:
- https://libtmux.org/en/ruby/latest/llms.txt
  every page for Ruby, as a list
- https://libtmux.org/en/ruby/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/ruby/latest/reference/
  the Ruby API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Ruby project yet, start one:
       bundle init
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. libtmux has no stable release. 0.1.0.alpha.1 is the
   newest prerelease on RubyGems, and the command below names it because the
   resolver skips prereleases otherwise.
       bundle add libtmux --version 0.1.0.alpha.1
   Check https://rubygems.org/gems/libtmux for a newer version, and prefer a
   stable release over this one if there now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

For Ruby: Use `libtmux-async` inside an application-owned Async task. For
output completion, use bounded control subscriptions and operation-specific
evidence rather than a timer.

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Lua
Package:    libtmux (LuaRocks)
Repository: https://github.com/libtmux/libtmux-lua

Read these before writing code:
- https://libtmux.org/en/lua/latest/llms.txt
  every page for Lua, as a list
- https://libtmux.org/en/lua/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/lua/latest/reference/
  the Lua API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Lua project yet, start one:
       luarocks init
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. libtmux has no stable release. 0.1.0alpha1-1 is the
   newest prerelease on LuaRocks, and the command below names it because the
   resolver skips prereleases otherwise.
       luarocks --local install libtmux 0.1.0alpha1-1
   Check https://luarocks.org/modules/tony/libtmux for a newer version, and
   prefer a stable release over this one if there now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

For Lua: Choose the luv adapter for standalone Lua or the Neovim adapter in
an editor host. Await Requests and retain `value, err`; do not block the
host loop.

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   PowerShell
Package:    LibTmux (PowerShell Gallery)
Repository: https://github.com/libtmux/libtmux-powershell

Read these before writing code:
- https://libtmux.org/en/powershell/latest/llms.txt
  every page for PowerShell, as a list
- https://libtmux.org/en/powershell/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/powershell/latest/reference/
  the PowerShell API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a PowerShell project yet, Create a PowerShell
   script in this directory; no project manifest is required.
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. LibTmux has no stable release. 0.1.0-alpha2 is the
   newest prerelease on PowerShell Gallery, and the command below names it
   because the resolver skips prereleases otherwise.
       Install-Module -Name LibTmux -RequiredVersion 0.1.0-alpha2 -AllowPrerelease
   Check https://www.powershellgallery.com/packages/LibTmux for a newer
   version, and prefer a stable release over this one if there now is any.
   Import LibTmux after installation. LibTmux.Workspace is a separate
   module; the .NET MCP tool does not import either module.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Julia
Package:    LibTmux (its repository)
Repository: https://github.com/libtmux/libtmux-julia

Read these before writing code:
- https://libtmux.org/en/julia/latest/llms.txt
  every page for Julia, as a list
- https://libtmux.org/en/julia/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/julia/latest/reference/
  the Julia API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Julia project yet, start one:
       using Pkg
Pkg.activate(".")
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. LibTmux is not published to its registry yet, so this
   installs from the repository at tag v0.1.0-alpha.1.
       using Pkg
       Pkg.add(PackageSpec(url="https://github.com/libtmux/libtmux-julia.git", rev="v0.1.0-alpha.1"))
   Check https://github.com/libtmux/libtmux-julia for a newer version, and
   prefer a stable release over this one if there now is any.
   Julia 1.10+ and tmux 3.2a+ are compatibility targets; see the
   compatibility guide for tested versions. Companion packages share the
   core source release.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   TypeScript
Package:    libtmux (npm)
Repository: https://github.com/libtmux/libtmux-ts

Read these before writing code:
- https://libtmux.org/en/ts/latest/llms.txt
  every page for TypeScript, as a list
- https://libtmux.org/en/ts/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/ts/latest/reference/
  the TypeScript API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a TypeScript project yet, start one:
       bun init
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. libtmux has no stable release. 0.1.0-alpha.12 is the
   newest prerelease on npm, and the command below names it because the
   resolver skips prereleases otherwise.
       bun add libtmux@0.1.0-alpha.12
   Check https://www.npmjs.com/package/libtmux for a newer version, and
   prefer a stable release over this one if there now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Rust
Package:    libtmux (crates.io)
Repository: https://github.com/libtmux/libtmux-rs

Read these before writing code:
- https://libtmux.org/en/rs/latest/llms.txt
  every page for Rust, as a list
- https://libtmux.org/en/rs/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/rs/latest/reference/
  the Rust API reference
- https://docs.rs/libtmux
  Rust reference on docs.rs
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Rust project yet, start one:
       cargo init
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. libtmux has no stable release. 0.1.0-alpha.15 is the
   newest prerelease on crates.io, and the command below names it because the
   resolver skips prereleases otherwise.
       cargo add libtmux@0.1.0-alpha.15
   Check https://crates.io/crates/libtmux for a newer version, and prefer a
   stable release over this one if there now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Go
Package:    github.com/libtmux/libtmux-go/tmux (pkg.go.dev)
Repository: https://github.com/libtmux/libtmux-go

Read these before writing code:
- https://libtmux.org/en/go/latest/llms.txt
  every page for Go, as a list
- https://libtmux.org/en/go/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/go/latest/reference/
  the Go API reference
- https://pkg.go.dev/github.com/libtmux/libtmux-go/tmux
  Go reference on pkg.go.dev
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Go project yet, start one:
       go mod init example.com/tmuxdemo
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. github.com/libtmux/libtmux-go/tmux has no stable
   release. v0.0.1-alpha.9 is the newest prerelease on pkg.go.dev, and the
   command below names it because the resolver skips prereleases otherwise.
       go get github.com/libtmux/libtmux-go@v0.0.1-alpha.9
   Check https://pkg.go.dev/github.com/libtmux/libtmux-go/tmux for a newer
   version, and prefer a stable release over this one if there now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Java
Package:    io.github.libtmux:libtmux (Maven Central)
Repository: https://github.com/libtmux/libtmux-java

Read these before writing code:
- https://libtmux.org/en/java/latest/llms.txt
  every page for Java, as a list
- https://libtmux.org/en/java/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/java/latest/reference/
  the Java API reference
- https://javadoc.io/doc/io.github.libtmux/libtmux
  Java reference on javadoc.io
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Java project yet, start one:
       gradle init --type java-application --dsl kotlin
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. io.github.libtmux:libtmux has no stable release.
   0.0.1-alpha.17 is the newest prerelease on Maven Central, and the command
   below names it because the resolver skips prereleases otherwise.
       implementation("io.github.libtmux:libtmux:0.0.1-alpha.17")
   Check https://central.sonatype.com/artifact/io.github.libtmux/libtmux for
   a newer version, and prefer a stable release over this one if there now
   is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Kotlin
Package:    io.github.libtmux:libtmux-kotlin (Maven Central)
Repository: https://github.com/libtmux/libtmux-java

Read these before writing code:
- https://libtmux.org/en/kotlin/latest/llms.txt
  every page for Kotlin, as a list
- https://libtmux.org/en/kotlin/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/kotlin/latest/reference/
  the Kotlin API reference
- https://javadoc.io/doc/io.github.libtmux/libtmux-kotlin
  Kotlin reference on Dokka
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Kotlin project yet, start one:
       gradle init --type kotlin-application --dsl kotlin
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. io.github.libtmux:libtmux-kotlin has no stable
   release. 0.0.1-alpha.17 is the newest prerelease on Maven Central, and the
   command below names it because the resolver skips prereleases otherwise.
       implementation("io.github.libtmux:libtmux-kotlin:0.0.1-alpha.17")
   Check
   https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin
   for a newer version, and prefer a stable release over this one if there
   now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Scala
Package:    io.github.libtmux:libtmux-scala_3 (Maven Central)
Repository: https://github.com/libtmux/libtmux-java

Read these before writing code:
- https://libtmux.org/en/scala/latest/llms.txt
  every page for Scala, as a list
- https://libtmux.org/en/scala/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/scala/latest/reference/
  the Scala API reference
- https://javadoc.io/doc/io.github.libtmux/libtmux-scala_3
  Scala reference on Scaladoc
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Scala project yet, start one:
       sbt new scala/scala3.g8
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. io.github.libtmux:libtmux-scala_3 has no stable
   release. 0.0.1-alpha.17 is the newest prerelease on Maven Central, and the
   command below names it because the resolver skips prereleases otherwise.
       libraryDependencies += "io.github.libtmux" %% "libtmux-scala" % "0.0.1-alpha.17"
   Check
   https://central.sonatype.com/artifact/io.github.libtmux/libtmux-scala_3
   for a newer version, and prefer a stable release over this one if there
   now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   C#
Package:    LibTmux (NuGet)
Repository: https://github.com/libtmux/libtmux-dotnet

Read these before writing code:
- https://libtmux.org/en/csharp/latest/llms.txt
  every page for C#, as a list
- https://libtmux.org/en/csharp/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/csharp/latest/reference/
  the C# API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a C# project yet, start one:
       dotnet new console
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. LibTmux has no stable release. 0.0.0-alpha.21 is the
   newest prerelease on NuGet, and the command below names it because the
   resolver skips prereleases otherwise.
       dotnet add package LibTmux --version 0.0.0-alpha.21
   Check https://www.nuget.org/packages/LibTmux for a newer version, and
   prefer a stable release over this one if there now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   F#
Package:    LibTmux.FSharp (NuGet)
Repository: https://github.com/libtmux/libtmux-dotnet

Read these before writing code:
- https://libtmux.org/en/fsharp/latest/llms.txt
  every page for F#, as a list
- https://libtmux.org/en/fsharp/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/fsharp/latest/reference/
  the F# API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a F# project yet, start one:
       dotnet new console --language F#
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. LibTmux.FSharp has no stable release. 0.0.0-alpha.21
   is the newest prerelease on NuGet, and the command below names it because
   the resolver skips prereleases otherwise.
       dotnet package add LibTmux.FSharp --version 0.0.0-alpha.21
   Check https://www.nuget.org/packages/LibTmux.FSharp for a newer version,
   and prefer a stable release over this one if there now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   C++
Package:    libtmux-cxx (its repository)
Repository: https://github.com/libtmux/libtmux-cxx

Read these before writing code:
- https://libtmux.org/en/cxx/latest/llms.txt
  every page for C++, as a list
- https://libtmux.org/en/cxx/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/cxx/latest/reference/
  the C++ API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a C++ project yet, write a CMakeLists.txt
   declaring cmake_minimum_required and project(), targeting C++23.
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. libtmux-cxx is not published to its registry yet, so
   this installs from the repository at tag v0.1.0-alpha.11.
       include(FetchContent)
       FetchContent_Declare(libtmux-cxx
         GIT_REPOSITORY https://github.com/libtmux/libtmux-cxx
         GIT_TAG v0.1.0-alpha.11)
       FetchContent_MakeAvailable(libtmux-cxx)
   Check https://github.com/libtmux/libtmux-cxx for a newer version, and
   prefer a stable release over this one if there now is any.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports

Then build an orchestrator that runs several coding agents side by side in
tmux.

libtmux drives a real tmux server from code. It gives you objects for the
server, its sessions, windows and panes. Documentation for every language
is at https://libtmux.org/en/.

Language:   Swift
Package:    libtmux-swift (Swift Package Index)
Repository: https://github.com/libtmux/libtmux-swift

Read these before writing code:
- https://libtmux.org/en/swift/latest/llms.txt
  every page for Swift, as a list
- https://libtmux.org/en/swift/latest/docs.json
  the same list with headings, as JSON
- https://libtmux.org/en/swift/latest/reference/
  the Swift API reference
If you cannot fetch URLs, clone the repository above and read its README
and examples instead, or ask me to paste those pages in.

Set up first:
1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so
   nothing below works without one. Stop and tell me if it is missing.
2. If this directory is not a Swift project yet, start one:
       swift package init --type executable
   Skip this in a project that already exists, and match what is here.
3. Add the dependency. libtmux-swift has no stable release. 0.1.0-alpha.6 is
   the newest prerelease on Swift Package Index, and the command below names it
   because the resolver skips prereleases otherwise.
       .package(url: "https://github.com/libtmux/libtmux-swift", exact: "0.1.0-alpha.6")
   Check https://swiftpackageindex.com/libtmux/libtmux-swift for a newer
   version, and prefer a stable release over this one if there now is any.
   A target depends on the product, not the package: write .product(name:
   "LibTmux", package: "libtmux-swift"). The library is `LibTmux` while the
   package identity SwiftPM derives from the URL is `libtmux-swift`, which
   is neither the product name nor the `name:` in the package manifest.
4. Write the smallest program that proves the install works: connect to a
   tmux server, create a session, confirm it is there, then kill it. Give
   that server a socket of its own rather than using the default one, so
   this never touches a tmux I am already running. Run it, and show me the
   output and the files you added.

Rules for everything below:
- Use the reference above rather than guessing names. The ten libtmux
  ports do not share spellings, and a name from another language will look
  plausible and not exist.
- If the reference does not have something you expected, say so instead of
  writing a call that does not exist.
- Follow the conventions already in this repository.

Agent orchestrator

What it does:
- Takes a list of tasks and starts one agent per task, each in its own pane of
  a dedicated session, so I can watch all of them at once.
- Streams each pane's output as it arrives rather than polling on a timer.
- Detects when an agent has finished or gone quiet, and reports which task that
  was. Say in a comment how you decide "finished", because the agent's exit and
  the shell's prompt returning are different events.
- Lets me attach to the session and take over any pane by hand.

Constraints:
- Do not block the whole orchestrator on one pane. If this language has an
  async or streaming API, use it, and say why you picked the API you did.
- Send input as data, not as shell text the pane will re-parse. Task text can
  contain quotes, newlines and semicolons.
- Tear down cleanly on interrupt, and leave no stray server behind.
- Keep a task's output attributable to that task. Interleaved output nobody can
  attribute is the failure mode here.

Anchor it in these pages:
- https://libtmux.org/en/tmux/guides/sending-keys/      sending keys
- https://libtmux.org/en/tmux/guides/capturing-output/  capturing output
- https://libtmux.org/en/tmux/concepts/transports/      transports