Prompts¶

Run this shell command in tmux pane %1, wait until it
finishes, and inspect the typed result:

```python
result = run_command(
    pane_id='%1',
    command='pytest',
    timeout=60.0,
    max_lines=100,
)
```

Use `result.exit_status`, `result.timed_out`, and `result.output`
to decide what happened. Do NOT use a `send_keys` + `capture_pane`
retry loop for authored commands — `run_command` already performs
deterministic completion and returns tail-preserved output.

If the task needs persistent shell state or TUI keystrokes instead of
a one-shot shell command, use `send_keys` or `send_keys_batch`, then
observe later output with `capture_since`.

Something went wrong in tmux pane %1. Diagnose it:

1. Call `snapshot_pane(pane_id="%1")` to get content,
   cursor position, pane mode, and scroll state in one call.
2. If the content looks truncated, re-call with `max_lines=None`.
3. If you need to watch the pane across more than one turn, call
   `capture_since(pane_id="%1")`, keep the returned cursor,
   and pass it to later `capture_since(cursor=...)` calls.
4. Identify the last command that ran (look at the prompt line and
   the line above it) and the last non-empty output line.
5. Propose a root cause hypothesis and a minimal command to verify
   it (do NOT execute anything yet — produce the plan first).

Set up a 3-pane development workspace named
'dev' with editor on top, a shell on the bottom-left, and
a logs tail on the bottom-right:

1. `create_session(session_name="dev")` — creates the
   session with a single pane (pane A, the editor). Capture the
   returned `active_pane_id` as `%A`.
2. `split_window(pane_id="%A", direction="below")` — splits off
   the bottom half (pane B, the terminal). Capture the returned
   `pane_id` as `%B`.
3. `split_window(pane_id="%B", direction="right")` — splits pane B
   horizontally (pane C, the logs pane). Capture the returned
   `pane_id` as `%C`.
4. Launch the editor and the log command via {tooliconl}`send-keys`:
   `send_keys(pane_id="%A", keys="vim")` and
   `send_keys(pane_id="%C", keys='watch -n 1 date')`. Leave pane B
   at its fresh shell prompt — nothing needs to be sent there. No
   pre-launch wait is required: tmux buffers keystrokes into the
   pane's PTY whether or not the shell has finished drawing, so
   `send_keys` immediately after `split_window` is safe and
   shell-agnostic.
5. Optionally confirm each program drew its UI via
   `wait_for_text(pane_id="%A", patterns=null, timeout=3.0)`
   (and similarly for `%C`). Omitting `patterns` makes this a
   "did anything new get printed?" check — it works whether the
   pane shows a prompt glyph, a vim splash screen, or a log tail,
   so no shell-specific regex is needed.

Use pane IDs (`%N`) for all subsequent targeting — they are stable
across layout changes; window renames are not.

Interrupt whatever is running in pane %1 and
verify that control returns to the shell:

1. `get_pane_info(pane_id="%1")` — note `pane_current_command`.
   That is the thing you are trying to change, and comparing it
   before and after is the only reliable answer.
2. `send_keys(pane_id="%1", keys="C-c", literal=False,
   enter=False)` — tmux interprets `C-c` as SIGINT.
3. `wait_for_text(pane_id="%1", patterns=["\$", "\#", "\%", ">"],
   regex=True, timeout=5.0)` — waits for a common shell prompt glyph.
   Adjust the patterns to match the user's shell theme.
   Do NOT put `\^C` in `stop`: the terminal echoes `^C` whenever SIGINT
   is DELIVERED, whether or not the process dies, so it marks the
   success path as a failure. Measured on sh and bash — the process
   exited and the wait still returned `outcome="stopped"`.
   The `wait_for_channel` pattern doesn't apply here — `C-c` is a
   signal, not a shell command, so there's no statement to compose
   `tmux wait-for -S` into.
4. Re-read `get_pane_info(pane_id="%1")`. If
   `pane_current_command` is back to a shell, the interrupt worked —
   trust this over the wait result, which can time out on a prompt
   whose glyph you did not predict.
5. Only if the command is UNCHANGED is the process ignoring SIGINT.
   Stop and ask the caller how to proceed — do NOT escalate
   automatically to `C-\` (SIGQUIT) or `kill`.