{
  "schemaVersion": "1",
  "revision": "22ce5d34dbcb5a78",
  "id": "foundations-cmux-orchestrate-playbook",
  "slug": "cmux-orchestrate-playbook",
  "title": "Command a CMUX manager/worker layout playbook",
  "summary": "Web developers already juggle dev servers, test runners, browser verification, and agent chats; this pattern turns that chaos into one visible Manager pane coordinating narrow worker panes. It matters most when a local app needs code changes plus runtime proof, because the Manager can inspect panes, send targeted tasks, read worker output, and keep the human focused on decisions instead of pane babysitting.",
  "category": "Execution",
  "tags": [
    "CMUX",
    "orchestration",
    "delegation",
    "playbook",
    "prompts"
  ],
  "sources": [
    {
      "label": "Agent foundations: Coordinate agents with a manager and worker panes (authorized access required)",
      "url": "https://codex-workshop-followup.pages.dev/lesson-02.html"
    }
  ],
  "sourceUnits": [
    "scenarios/topics.mjs#cmux-orchestrate",
    "scenarios/cmux-orchestrate.json#audienceFit",
    "toolkit/prompts/02-cmux-manager-worker-layout.md",
    "toolkit/codex-skills/cmux-orchestrate/SKILL.md",
    "scenarios/cmux-orchestrate.json#scenarios/0",
    "scenarios/cmux-orchestrate.json#scenarios/1",
    "scenarios/cmux-orchestrate.json#scenarios/2",
    "scenarios/cmux-orchestrate.json#implementationNotes",
    "scenarios/cmux-orchestrate.json#notTaughtOrAvoid/1",
    "scenarios/cmux-orchestrate.json#notTaughtOrAvoid/2",
    "scenarios/cmux-orchestrate.json#notTaughtOrAvoid/3",
    "scenarios/cmux-orchestrate.json#notTaughtOrAvoid/4",
    "scenarios/cmux-orchestrate.json#notTaughtOrAvoid/5",
    "scenarios/cmux-orchestrate.json#agentReferences",
    "toolkit/bundles/code-cmux-cli.md"
  ],
  "collection": "foundations",
  "categoryId": "execution",
  "wordCount": 2916,
  "url": "/topics/foundations-cmux-orchestrate-playbook/",
  "markdownUrl": "/markdown/foundations-cmux-orchestrate-playbook.md?raw=1&v=22ce5d34dbcb5a78",
  "jsonUrl": "/api/v1/documents/foundations-cmux-orchestrate-playbook.json",
  "headings": [
    {
      "id": "copy-paste-workflow",
      "text": "Copy-paste workflow",
      "level": 2
    },
    {
      "id": "copy-paste-prompt",
      "text": "Copy-paste prompt",
      "level": 3
    },
    {
      "id": "how-it-works",
      "text": "How it works",
      "level": 3
    },
    {
      "id": "reusable-skill",
      "text": "Reusable skill",
      "level": 2
    },
    {
      "id": "scenarios",
      "text": "Scenarios",
      "level": 2
    },
    {
      "id": "triage-a-broken-localhost-checkout-flow",
      "text": "Triage a broken localhost checkout flow",
      "level": 3
    },
    {
      "id": "agent-brief",
      "text": "Agent brief",
      "level": 4
    },
    {
      "id": "implementation-references",
      "text": "Implementation references",
      "level": 4
    },
    {
      "id": "browser-verification",
      "text": "Browser verification",
      "level": 4
    },
    {
      "id": "definition-of-done",
      "text": "Definition of done",
      "level": 4
    },
    {
      "id": "failure-modes-and-mitigations",
      "text": "Failure modes and mitigations",
      "level": 4
    },
    {
      "id": "coordinate-a-design-drift-review-before-touching-css",
      "text": "Coordinate a design-drift review before touching CSS",
      "level": 3
    },
    {
      "id": "agent-brief-2",
      "text": "Agent brief",
      "level": 4
    },
    {
      "id": "implementation-references-2",
      "text": "Implementation references",
      "level": 4
    },
    {
      "id": "browser-verification-2",
      "text": "Browser verification",
      "level": 4
    },
    {
      "id": "definition-of-done-2",
      "text": "Definition of done",
      "level": 4
    },
    {
      "id": "failure-modes-and-mitigations-2",
      "text": "Failure modes and mitigations",
      "level": 4
    },
    {
      "id": "run-a-bounded-afk-manager-check-in-on-parallel-workers",
      "text": "Run a bounded AFK manager check-in on parallel workers",
      "level": 3
    },
    {
      "id": "agent-brief-3",
      "text": "Agent brief",
      "level": 4
    },
    {
      "id": "implementation-references-3",
      "text": "Implementation references",
      "level": 4
    },
    {
      "id": "browser-verification-3",
      "text": "Browser verification",
      "level": 4
    },
    {
      "id": "definition-of-done-3",
      "text": "Definition of done",
      "level": 4
    },
    {
      "id": "failure-modes-and-mitigations-3",
      "text": "Failure modes and mitigations",
      "level": 4
    },
    {
      "id": "implementation-notes",
      "text": "Implementation notes",
      "level": 2
    },
    {
      "id": "boundaries-and-caveats",
      "text": "Boundaries and caveats",
      "level": 2
    },
    {
      "id": "agent-reference-map",
      "text": "Agent reference map",
      "level": 2
    },
    {
      "id": "existing-cmux-manager-worker-prompt",
      "text": "Existing CMUX manager/worker prompt",
      "level": 3
    },
    {
      "id": "cmux-orchestration-skill",
      "text": "CMUX orchestration skill",
      "level": 3
    },
    {
      "id": "verified-cmux-cli-command-map",
      "text": "Verified CMUX CLI command map",
      "level": 3
    },
    {
      "id": "lesson-02-validated-references",
      "text": "Lesson 02 validated references",
      "level": 3
    },
    {
      "id": "lesson-02-validation-notes",
      "text": "Lesson 02 validation notes",
      "level": 3
    },
    {
      "id": "command-reference",
      "text": "Command reference",
      "level": 2
    },
    {
      "id": "panes-layout",
      "text": "Panes / layout",
      "level": 2
    },
    {
      "id": "reading-sending",
      "text": "Reading / sending",
      "level": 2
    },
    {
      "id": "tabs-markdown-notifications",
      "text": "Tabs / markdown / notifications",
      "level": 2
    },
    {
      "id": "global-options-before-the-command",
      "text": "Global options (before the command)",
      "level": 2
    }
  ],
  "markdown": "# Command a CMUX manager/worker layout playbook\n\n> Original source pages and recordings require authorized access. The full article text here is public.\n\nWeb developers already juggle dev servers, test runners, browser verification, and agent chats; this pattern turns that chaos into one visible Manager pane coordinating narrow worker panes. It matters most when a local app needs code changes plus runtime proof, because the Manager can inspect panes, send targeted tasks, read worker output, and keep the human focused on decisions instead of pane babysitting.\n\n[Core principles](/topics/foundations-manager-worker-orchestration/)\n\n## Copy-paste workflow\n\n**When to use:** When you want to drive several agent panes in parallel but only talk to one. This sets up a Manager pane plus worker panes in CMUX using natural language; the Manager opens, inspects, and delegates to the workers while you only converse with the Manager.\n\n### Copy-paste prompt\n\n```text\nYou are the Manager agent running in my focused CMUX pane. I will only talk to you; you coordinate worker panes. Use the REAL cmux CLI (do not invent flags). Keep the upfront planning human-led — confirm the plan with me before delegating.\n\n1. Build the layout. Open a worker surface to the right and create additional worker panes as needed:\n     cmux new-split right\n     cmux new-pane\n   Name the tabs so they stay findable:\n     cmux rename-tab \"<role-name>\"\n\n2. Always inspect live state before acting on a worker:\n     cmux --json tree        # full pane/surface tree as JSON (focused pane, refs, cwd)\n     cmux list-panes         # enumerate worker panes\n\n3. Delegate a task into a worker surface, then read its output back as context:\n     cmux send -- \"<TASK TEXT FOR THAT WORKER>\"\n     cmux read-screen        # read that worker's terminal text back\n\n4. Loop: you (Manager) talk to me, workers do the research/implementation. Report status back to me; do not let workers drift without checking cmux --json tree.\n\nGuardrail: prefer PANES over tab groups — tab groups are easy to lose track of.\n```\n\n### How it works\n- `cmux new-split right` and `cmux new-pane` build the manager/worker layout; `cmux rename-tab \"<name>\"` keeps roles findable.\n- `cmux --json tree` returns the live window/workspace/pane/surface tree as JSON (focused pane, refs like `pane:89`/`surface:126`, working directory) — inspect it before acting.\n- `cmux list-panes` enumerates worker panes.\n- `cmux send -- \"<text>\"` injects a task into a worker surface; `cmux read-screen` reads that worker's terminal text back as context for the Manager.\n- The Manager talks to the human; workers do research/implementation. Keep upfront planning human-led.\n- Prefer panes over tab groups — tab groups are easy to lose track of.\n- Reference: [CMUX](https://cmux.com/).\n\n## Reusable skill\n\nInstall as `~/.agents/skills/cmux-orchestrate/SKILL.md`, then restart Codex.\n\n````markdown\n---\nname: cmux-orchestrate\ndescription: Trigger when the user wants to drive multiple terminal/agent panes in CMUX from natural language — build manager/worker layouts, open/arrange panes, inspect or send work to other panes. Do NOT trigger outside a CMUX workspace.\n---\n\n# CMUX orchestration\n\nAct as the Manager agent: build a pane layout, inspect live state, and delegate work to worker panes using the REAL cmux CLI. Do not invent flags. Inspect with `cmux --json tree` before acting.\n\n## Command map (real cmux CLI)\n\n```bash\ncmux new-split <left|right|up|down>   # split from the focused surface in a direction\ncmux new-pane                         # create a pane (terminal or browser content)\ncmux --json tree                      # full window/workspace/pane/surface tree as JSON\ncmux list-panes                       # enumerate panes in the workspace\ncmux send -- \"<text>\"                 # send a task into a terminal surface\ncmux read-screen                      # read a surface's terminal text back as context\ncmux rename-tab \"<name>\"              # name a tab so it stays findable\ncmux focus-pane <ref>                 # focus a pane (ref like pane:89 or surface:126)\n```\n\nHandles accept UUIDs, refs like `workspace:2` / `pane:89` / `surface:126`, and indexes.\n\n## Manager-worker pattern\n1. Build the layout: `cmux new-split right`, then `cmux new-pane` for each worker; name them with `cmux rename-tab \"<role>\"`.\n2. Before acting on any worker, inspect live state: `cmux --json tree` (focused pane, refs, cwd) and `cmux list-panes`.\n3. Delegate work: `cmux send -- \"<task>\"` into a worker, then `cmux read-screen` to pull its output back as context.\n4. You (Manager) talk to the human; workers do research/implementation. Report status back.\n\n## Guardrails\n- Prefer PANES over tab groups — tab groups are easy to lose track of.\n- Only use inside a CMUX workspace.\n````\n\n## Scenarios\n\n### Triage a broken localhost checkout flow\n\n**Role:** As a full-stack Next.js developer shipping a checkout fix\n\nA Next.js storefront runs locally, the checkout route intermittently loses cart state after refresh, and the developer needs one agent to coordinate source inspection, dev-server logs, and browser proof without manually switching between terminals.\n\n> As a full-stack Next.js developer, I want one CMUX Manager pane to spin up focused workers for server logs, cart-state source review, and browser validation, so that I can fix the checkout bug with visible evidence instead of trusting a single agent transcript.\n\n#### Agent brief\n\n```text\nYou are the Manager agent in my focused CMUX pane. Do not implement yet. First inspect live CMUX state with `cmux --json tree` and `cmux list-panes`. Build a visible pane layout using only real CMUX commands: create worker panes with `cmux new-split right` and `cmux new-pane`, then name the workspace tab with `cmux rename-tab \"checkout-triage\"`. Create three worker roles: `server-log-worker`, `source-worker`, and `browser-proof-worker`. Send each worker a narrow task using `cmux send -- \"<task>\"`: server-log-worker runs or watches the local dev server and captures errors; source-worker inspects cart and checkout route code only; browser-proof-worker verifies the localhost checkout flow in a browser or browser-agent workflow and reports exact observed behavior. After each worker responds, read its visible terminal output with `cmux read-screen`, summarize conflicts between source, logs, and browser behavior, then propose the smallest fix. Expected output: a Manager report containing pane refs from `cmux --json tree`, each worker assignment, each worker result, the chosen fix plan, and the browser/dev-server proof shape required before merging.\n```\n\n#### Implementation references\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/)\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/)\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/#command-reference)\n\n```text\ncmux --json tree\n```\n\n```text\ncmux list-panes\n```\n\n```text\ncmux new-split right\n```\n\n```text\ncmux new-pane\n```\n\n```text\ncmux send -- \"<task>\"\n```\n\n```text\ncmux read-screen\n```\n\n```text\ncmux rename-tab \"checkout-triage\"\n```\n\n#### Browser verification\n\nUse the browser-proof-worker for runtime proof: open the local checkout URL, take an accessibility-style snapshot of the page state, click through cart → checkout → refresh/back navigation, fill only safe test fields, and report URL, visible cart count, console/runtime errors, and whether state survives refresh. If a CMUX browser pane is available, keep that proof visible beside the Manager; otherwise use the project's existing browser automation or local browser and paste the observation back into the worker pane.\n\n#### Definition of done\n\n- Manager report includes the live CMUX pane refs from `cmux --json tree` and the named roles assigned to each worker.\n- Dev-server or test-runner output is copied from a worker via `cmux read-screen`, not summarized from memory.\n- Browser proof includes the exact localhost route, user actions, visible before/after state, and any console/runtime error text.\n- A final review artifact lists the minimal code area to change and the verification commands or browser steps to rerun.\n\n#### Failure modes and mitigations\n\n- The Manager delegates before inspecting live state; mitigate by requiring `cmux --json tree` and `cmux list-panes` before every send/read cycle.\n- Workers drift into broad refactors; mitigate by assigning each worker one narrow responsibility and having the Manager reject unrelated changes.\n- The browser worker reports success without proof; mitigate by requiring concrete URL, visible UI state, action sequence, and error/log evidence.\n\n### Coordinate a design-drift review before touching CSS\n\n**Role:** As a frontend engineer maintaining a dashboard UI\n\nA dashboard page has visual drift across cards, filters, and responsive layout after several agent-generated edits, and the developer wants separate workers to inspect current code, compare live UI behavior, and propose a bounded cleanup.\n\n> As a frontend engineer, I want a CMUX Manager to coordinate code, browser, and review workers before editing CSS, so that cleanup is based on current source and visible UI proof rather than vague design taste.\n\n#### Agent brief\n\n```text\nYou are the Manager agent in my focused CMUX pane. Keep the human interaction surface to you only. Use `cmux --json tree` and `cmux list-panes` first. Create a visible Manager/worker layout with `cmux new-split right` and `cmux new-pane`; name the tab `dashboard-drift-review` with `cmux rename-tab \"dashboard-drift-review\"`. Create workers named `current-code-worker`, `responsive-browser-worker`, and `cleanup-plan-worker`. Use `cmux send -- \"<task>\"` to assign: current-code-worker identifies the current dashboard route, component files, and styling sources; responsive-browser-worker opens the local dashboard in a browser and records desktop and narrow-width observations; cleanup-plan-worker waits for the first two worker outputs, then drafts a small numbered cleanup plan with options A/B/C and a recommended pick. Read worker panes with `cmux read-screen`. Expected output: a numbered implementation plan that says which files are source of truth, what the browser showed, which visual issues are real, and which cleanup option the Manager recommends before implementation.\n```\n\n#### Implementation references\n\n[Open reference](/topics/foundations-manager-worker-orchestration/)\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/)\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/)\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/#command-reference)\n\n```text\ncmux --json tree\n```\n\n```text\ncmux list-panes\n```\n\n```text\ncmux send -- \"<task>\"\n```\n\n```text\ncmux read-screen\n```\n\n```text\ncmux rename-tab \"dashboard-drift-review\"\n```\n\n#### Browser verification\n\nUse a CMUX browser pane or local browser verification to inspect the dashboard at desktop and narrow widths. The browser worker should capture a snapshot-style summary of headings, card order, filter controls, overflow, empty states, and any console errors; click filters and navigation only enough to prove whether drift is visual, state-related, or route-specific.\n\n#### Definition of done\n\n- Manager names the CMUX tab and can list all worker panes with `cmux list-panes`.\n- Current-code-worker identifies the actual source files instead of relying on memory.\n- Responsive-browser-worker provides desktop and narrow-width observations with route and visible-state evidence.\n- Cleanup-plan-worker produces numbered options with a recommended pick, so the human can steer with a terse choice such as `2B`.\n\n#### Failure modes and mitigations\n\n- The agent treats design.md or memory as more authoritative than the current code; mitigate by making current-code-worker inspect the live repo first.\n- The browser check becomes a full QA swarm; mitigate by limiting it to the dashboard route, two viewport sizes, and the specific drift symptoms.\n- The Manager hides worker uncertainty; mitigate by requiring each worker output to include what it verified and what it did not verify.\n\n### Run a bounded AFK manager check-in on parallel workers\n\n**Role:** As a senior developer supervising several local agent tasks\n\nThree workers are already running in CMUX on separate subtasks: one is fixing a flaky unit test, one is checking a build failure, and one is investigating docs or dependency usage. The developer wants the Manager to periodically inspect panes and answer simple blocking questions, but not run forever.\n\n> As a senior developer, I want a CMUX Manager to check worker panes at a fixed interval with a hard stop condition, so that parallel work keeps moving while I step away without creating an unbounded autonomous loop.\n\n#### Agent brief\n\n```text\nYou are the Manager agent in my focused CMUX pane. Start by creating a timestamp in your notes and inspect live CMUX state with `cmux --json tree` and `cmux list-panes`. Do not create new broad goals. Identify the existing worker panes by role, cwd, visible command, or recent terminal text. Every check-in cycle, use `cmux read-screen` to read each worker pane, summarize status, and if a worker is blocked by a simple question, choose the safest reasonable answer only when it stays inside that worker's assigned task. Use `cmux send -- \"<answer or nudge>\"` only after confirming the target pane from `cmux --json tree`. Stop after the explicit bound I give you, or after 3 check-in cycles if no bound is provided. Expected output: a check-in ledger with timestamp, pane refs, worker status, any answers sent, any panes needing human attention, and final stop reason.\n```\n\n#### Implementation references\n\n[Open reference](/topics/foundations-manager-worker-orchestration/)\n\n[Open reference](/topics/foundations-manager-worker-orchestration/)\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/)\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/)\n\n```text\ncmux --json tree\n```\n\n```text\ncmux list-panes\n```\n\n```text\ncmux read-screen\n```\n\n```text\ncmux send -- \"<answer or nudge>\"\n```\n\n```text\ncmux notify\n```\n\n#### Browser verification\n\nBrowser proof is only appropriate if one of the existing workers is assigned to a web-app runtime task. In that case, the Manager should ask that worker for the local URL, exact browser action taken, and visible result; otherwise the correct proof is terminal evidence from `cmux read-screen`, test logs, and the check-in ledger.\n\n#### Definition of done\n\n- The Manager records a start timestamp and a hard stop condition before the loop begins.\n- Each cycle includes pane refs, worker status, and terminal evidence read from the worker pane.\n- Any `cmux send -- \"<answer or nudge>\"` action is tied to a verified target pane from `cmux --json tree`.\n- The final ledger states whether each worker is done, blocked, still running, or needs human review, plus the stop reason.\n\n#### Failure modes and mitigations\n\n- The loop runs without a bound; mitigate by requiring a duration, target time, iteration cap, or default 3-cycle limit before starting.\n- The Manager answers high-risk questions for a worker; mitigate by only answering simple in-scope blockers and escalating destructive, production, credential, or broad architecture decisions to the human.\n- The Manager sends a message to the wrong pane; mitigate by rechecking `cmux --json tree` immediately before each `cmux send`.\n\n## Implementation notes\n\n- The Manager should inspect with `cmux --json tree` before acting and again before sending to a target pane; stale pane refs are how agents nudge the wrong worker.\n- Keep worker tasks narrow: one worker for logs, one for source, one for browser/runtime proof is usually better than three agents all editing the same files.\n- Prefer panes over tab groups for visible parallel work, because hidden tab groups are easy to lose track of during agent-heavy sessions.\n- Use `cmux read-screen` as evidence. Do not let the Manager summarize worker progress from memory or from optimistic worker claims.\n- Browser verification should prove live web behavior when the task is a web-app task; for non-browser tasks, terminal logs, test output, and a Manager ledger are stronger proof.\n- AFK-style loops need an explicit interval and stop condition. Without a bound, the workflow becomes token-burning theater.\n\n## Boundaries and caveats\n\n- Do not present CMUX browser automation skills as a taught this workflow workflow; use browser proof only where a web app needs runtime verification.\n- Do not prescribe Claude Code scheduling, Codex Mobile, tmux migration, Zellij, or Vault search as implementation requirements for this playbook.\n- Do not invent CMUX flags beyond the verified command map.\n- Do not turn workers loose on unrelated broad refactors; the taught pattern is Manager-led orchestration with narrow worker assignments.\n- Do not run unbounded AFK loops or let a Manager approve risky production, credential, billing, deployment, or destructive actions without the human.\n\n## Agent reference map\n\n### Existing CMUX manager/worker prompt\n\nUse this as the copy-paste baseline for Manager behavior, worker delegation, live-state inspection, and the human-led planning guardrail.\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/)\n\n### CMUX orchestration skill\n\nUse this as the reusable Codex skill contract for triggering CMUX orchestration only inside a CMUX workspace and for staying on the real command surface.\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/)\n\n### Verified CMUX CLI command map\n\nUse this to avoid invented flags and to keep pane creation, state inspection, send/read, focus, and tab naming grounded in the verified commands.\n\n[Open reference](/topics/foundations-cmux-orchestrate-playbook/#command-reference)\n\n### Lesson 02 validated references\n\nUse this as the taught-concept source for agent-first tooling, natural-language terminal orchestration, cross-pane reading, manager-worker topology, and bounded AFK loops.\n\n[Open reference](/topics/foundations-manager-worker-orchestration/)\n\n### Lesson 02 validation notes\n\nUse this to stay inside the transcript-validated boundary and avoid reintroducing removed or merely mentioned tools as taught workflows.\n\n[Open reference](/topics/foundations-manager-worker-orchestration/)\n\n## Command reference\n\nThese command shapes are version-specific. Use the installed tool’s help and the linked public repository when platform behavior differs.\n\nThese are REAL commands. Do not invent flags.\n\n## Panes / layout\n- `cmux new-split <left|right|up|down> [flags]` — split from the focused surface in a direction.\n- `cmux new-pane [flags]` — create a pane with terminal or browser content.\n- `cmux new-workspace [--name <title>] [--description <text>] [--cwd <path>] [--command <text>] [--layout <json>] [--focus <true|false>]`\n- `cmux focus-pane [--pane <id|ref> | <ref>]`\n- `cmux list-panes` — enumerate panes in a workspace.\n- `cmux tree [flags]` / `cmux --json tree` — print the window/workspace/pane/surface tree (JSON with `--json`).\n\nLive `cmux --json tree` returns an object with `active` (focused pane/surface refs, `is_browser_surface`, etc.) plus the full tree — this is the \"CMUX state as JSON\" / \"inspect\" the workflow uses (focused pane, refs, working directory).\n\n## Reading / sending\n- `cmux read-screen [flags]` — read terminal text from a surface back as context.\n- `cmux send [flags] -- <text>` — send text to a terminal surface.\n- `cmux send-key <key>` — send one key.\n\n## Tabs / markdown / notifications\n- `cmux rename-tab \"<name>\"` (compat wrapper for `cmux tab-action rename`).\n- `cmux markdown open <path> [--direction <left|right|up|down>] [--focus <true|false>]` — open a markdown file in a formatted viewer panel with **live file watching** (auto-refresh). This is the \"live Markdown side pane\" tracker.\n- `cmux notify` — send a notification to a workspace/surface.\n- `cmux events` — stream reconnectable cmux events as newline-delimited JSON (agent-readable telemetry / audit log).\n\n## Global options (before the command)\n`--socket <path>`, `--password <value>`, `--json`, `--id-format <refs|uuids|both>`, `--window <id|ref|index>`.\n\nHandles accept UUIDs, refs like `workspace:2` / `pane:89` / `surface:126`, and indexes."
}
