@lattices/cli 0.3.0

package/docs/app.md

@@ -0,0 +1,297 @@
+---
+title: Menu Bar App
+description: Command palette, window tiling, and session management
+order: 3
+---
+
+The lattices menu bar app sits in your menu bar and controls your
+workspace from there.
+
+## Installation
+
+```bash
+lattices app          # Build (or download) and launch
+lattices app build    # Rebuild from source
+lattices app restart  # Quit, rebuild, relaunch
+lattices app quit     # Stop the app
+```
+
+The first run builds from source if Swift is available, otherwise
+downloads a pre-built binary from GitHub releases.
+
+## Command palette
+
+Press **Cmd+Shift+M** from anywhere to open the command palette.
+It's a searchable list of every action the app can perform, with
+fuzzy matching on titles and subtitles.
+
+### Project commands
+
+| Command                       | Description                              |
+|-------------------------------|------------------------------------------|
+| Launch *project*              | Create a new session and open terminal   |
+| Attach *project*              | Focus or open the running session        |
+| Sync *project*                | Reconcile session to declared config     |
+| Restart *pane* in *project*   | Kill and re-run a specific pane's command |
+
+### Window commands
+
+Available for running sessions:
+
+| Command                       | Description                              |
+|-------------------------------|------------------------------------------|
+| Go to *project*               | Focus the terminal window (switches Spaces if needed) |
+| Tile *project* Left           | Snap window to left half                 |
+| Tile *project* Right          | Snap window to right half                |
+| Maximize *project*            | Expand window to fill screen             |
+| Detach *project*              | Disconnect clients, keep session alive   |
+| Kill *project*                | Terminate the tmux session               |
+
+### Tab group commands
+
+Available when `groups` are configured in `~/.lattices/workspace.json`
+(see [Tab Groups](/docs/layers#tab-groups)):
+
+| Command                     | Description                              |
+|-----------------------------|------------------------------------------|
+| Launch *group*              | Start the group session (all tabs)       |
+| Attach *group*              | Focus the running group session          |
+| *Group*: *Tab*              | Switch to a specific tab within a group  |
+| Kill *group* Group          | Terminate the group session              |
+
+### Layer commands
+
+Available when `layers` are configured in `~/.lattices/workspace.json`
+(see [Layers](/docs/layers#layers)):
+
+| Command                     | Description                              |
+|-----------------------------|------------------------------------------|
+| Switch to Layer: *label*    | Focus and tile the layer's project windows |
+
+### App commands
+
+| Command           | Description                              |
+|-------------------|------------------------------------------|
+| Settings          | Open preferences (terminal, scan root)   |
+| Diagnostics       | View logs and debug info                 |
+| Refresh Projects  | Re-scan for .lattices.json configs        |
+| Quit Lattices      | Exit the menu bar app                    |
+
+## Project discovery
+
+The app scans a configurable root directory (up to 3 levels deep)
+for `.lattices.json` files. It skips `.git/` and `node_modules/`.
+
+Auto-detection for the scan root checks these paths in order:
+`~/dev`, `~/Developer`, `~/projects`, `~/src`.
+
+For each project found, the app reads:
+- Pane names and commands from `.lattices.json`
+- Dev command and package manager from `package.json`
+- Running status by checking `tmux has-session`
+
+## Session management
+
+The app calls the lattices CLI for session operations. Launch runs
+`lattices` in the project directory, Sync runs `lattices sync` to
+reconcile panes, and Restart runs `lattices restart <pane>` to kill
+and re-run a pane's process. Detach and Kill call `tmux detach-client`
+and `tmux kill-session` directly.
+
+## Window tiling
+
+The app can tile terminal windows to preset screen positions via
+the command palette. It finds windows by their `[lattices:session-name]`
+title tag.
+
+For Terminal.app and iTerm2, tiling uses AppleScript to set window
+bounds by matching the title tag. For other terminals, it tiles the
+frontmost window.
+
+### Tile positions (app)
+
+| Position     | Area                            |
+|--------------|---------------------------------|
+| Left         | Left half                       |
+| Right        | Right half                      |
+| Top Left     | Top-left quarter                |
+| Top Right    | Top-right quarter               |
+| Bottom Left  | Bottom-left quarter             |
+| Bottom Right | Bottom-right quarter            |
+| Maximize     | Full visible screen             |
+| Left Third   | Left third                      |
+| Center Third | Center third                    |
+| Right Third  | Right third                     |
+| Center       | 70% width, 80% height, centered |
+
+## Space navigation
+
+"Go to" commands can switch macOS Spaces to reach a window on a
+different desktop. The app uses a three-path fallback:
+
+1. **CGWindowList** (needs Screen Recording) — looks up the window
+   by title tag, finds its Space via SkyLight, switches to it, then
+   raises the window
+2. **Accessibility API** (needs Accessibility) — finds the window
+   via AXUIElement, raises it, and activates the app
+3. **AppleScript** — iterates windows by name for Terminal/iTerm2,
+   or bare-activates for other terminals
+
+When a window is found and focused, the app flashes a green border
+highlight around it for ~1 second so you can spot it immediately.
+
+Grant Screen Recording and Accessibility permissions in System
+Settings > Privacy & Security for all three paths to work.
+
+## Settings
+
+Open via the command palette or the gear icon in the main view.
+The settings window has three tabs:
+
+### General
+
+| Setting    | Description                                          |
+|------------|------------------------------------------------------|
+| Terminal   | Which terminal to use (auto-detected from installed) |
+| Mode       | `learning` or `auto` (see below)                     |
+| Scan Root  | Directory to scan for .lattices.json configs (type a path or click Browse) |
+
+**Mode** controls how the app handles session interaction:
+
+- **Learning** — shows tmux keybinding hints when you detach
+  (helpful while getting used to tmux)
+- **Auto** — detaches sessions automatically (fewer prompts)
+
+### Shortcuts
+
+Shows keyboard shortcut reference:
+
+| Shortcut          | Action              |
+|-------------------|----------------------|
+| Cmd+Shift+M       | Open command palette |
+| Cmd+Option+1/2/3  | Switch workspace layer |
+| Ctrl+B  D         | Detach from session  |
+| Ctrl+B  X         | Kill current pane    |
+| Ctrl+B  Left/Right| Move between panes   |
+| Ctrl+B  Z         | Zoom pane (toggle)   |
+| Ctrl+B  [         | Scroll mode          |
+
+### Docs
+
+Embedded quick reference with glossary, "how it works" steps, and
+links to open the full `config.md` and `concepts.md` docs.
+
+## Supported terminals
+
+| Terminal     | Launch | Focus/Attach | Tile by tag |
+|--------------|--------|--------------|-------------|
+| Terminal.app | yes    | yes          | yes         |
+| iTerm2       | yes    | yes          | yes         |
+| Warp         | yes    | activate     | frontmost   |
+| Ghostty      | yes    | activate     | frontmost   |
+| Kitty        | yes    | activate     | frontmost   |
+| Alacritty    | yes    | activate     | frontmost   |
+
+"yes" means full AppleScript-based window matching by title tag.
+"activate" means the app is brought to front but a specific window
+can't be targeted. "frontmost" means tiling applies to whatever
+window is in front.
+
+## Screen OCR
+
+> See [Screen OCR](/docs/ocr) for full details on configuration, scanning,
+> search, and agent usage.
+
+The app reads text from visible windows using Apple's Vision framework
+and stores results in a local SQLite database with FTS5 full-text search.
+Agents can use this to "see" what's on screen.
+
+### How it works
+
+1. Every 60 seconds, the app captures the top visible windows as images
+2. A SHA256 hash detects whether the window content has changed
+3. Changed windows are processed through `VNRecognizeTextRequest` (fast mode)
+4. Results are stored in `~/.lattices/ocr.db` with full-text indexing
+5. Entries older than 3 days are automatically purged
+
+### Desktop Inventory integration
+
+The Desktop Inventory view (Hyper+4) uses OCR to make windows searchable
+by their content — not just by title or app name. When you type a search
+query, windows matching by OCR content show contextual snippets.
+
+### API access
+
+Agents can query OCR data through four API methods:
+
+| Method         | Description                                    |
+|----------------|------------------------------------------------|
+| `ocr.snapshot` | Current OCR results for all visible windows    |
+| `ocr.search`   | Full-text search across history (FTS5 syntax)  |
+| `ocr.history`  | Timeline of OCR results for a specific window  |
+| `ocr.scan`     | Trigger an immediate scan (bypasses timer)     |
+
+```js
+import { daemonCall } from '@lattices/cli'
+
+// Find windows showing error messages
+const errors = await daemonCall('ocr.search', { query: 'error OR failed' })
+
+// Read what's currently on screen
+const snapshot = await daemonCall('ocr.snapshot')
+```
+
+More in the [Agent API reference](/docs/api#ocrsnapshot).
+
+### Requirements
+
+- **Screen Recording** permission — required to capture window images
+- Granted via System Settings > Privacy & Security > Screen Recording
+
+## Agent API server
+
+The menu bar app runs a WebSocket server on `ws://127.0.0.1:9399`.
+It starts automatically when the app launches and stops when the app
+quits.
+
+### Checking status
+
+```bash
+lattices daemon status
+```
+
+Or programmatically:
+
+```js
+import { isDaemonRunning, daemonCall } from '@lattices/cli'
+
+if (await isDaemonRunning()) {
+  const status = await daemonCall('daemon.status')
+  console.log(status) // { uptime, clientCount, version, windowCount, tmuxSessionCount }
+}
+```
+
+### What it provides
+
+- 35+ RPC methods for reading windows, sessions, projects, spaces, layers,
+  processes, terminals, and OCR. Also launching/killing sessions, tiling
+  windows, switching layers, and managing tab groups.
+- 5 real-time events (`windows.changed`, `tmux.changed`, `processes.changed`,
+  `layer.switched`, `ocr.scanComplete`) broadcast to all connected clients.
+- Window tracking that monitors the desktop window list and correlates
+  windows to lattices sessions via title tags.
+- Space awareness, so it knows which macOS Space each window is on.
+
+### Security
+
+The server binds to localhost only (`127.0.0.1:9399`). Not accessible
+from the network. No authentication, so any local process can connect.
+This is intentional — it's for local automation, not remote access.
+
+Full method list in the [Agent API reference](/docs/api).
+
+## Diagnostics
+
+The diagnostics panel shows a timestamped log of window navigation
+attempts, including which path succeeded or failed. Useful for
+debugging Screen Recording / Accessibility permission issues.

package/docs/concepts.md

@@ -0,0 +1,135 @@
+---
+title: Concepts
+description: Core ideas, glossary, and architecture of lattices
+order: 6
+---
+
+## Glossary
+
+| Term | Definition |
+|------|------------|
+| **Command Palette** | The menu bar app's primary interface (**Cmd+Shift+M**). Searchable list of actions: launch, tile, sync, restart, settings. |
+| **Window Tiling** | Snap terminal windows to preset screen positions (halves, quarters, thirds, maximize, center). Works from the CLI (`lattices tile`) or the command palette. |
+| **Agent API** | WebSocket server (`ws://127.0.0.1:9399`) inside the menu bar app. Exposes 35+ RPC methods and 5 real-time events for programmatic control. See the [API reference](/docs/api). |
+| **Agent** | Any program that calls the agent API autonomously — an AI coding agent, a shell script, a CI pipeline, or a custom tool. |
+| **Session** | A persistent tmux workspace that lives in the background. Survives terminal crashes, disconnects, and closing your laptop. One session per project. Requires tmux. |
+| **Pane** | A single terminal view inside a session. A typical setup has two panes side by side — Claude Code on the left, dev server on the right. Requires tmux. |
+| **Attach / Detach** | Attaching connects your terminal to an existing session. Detaching disconnects but keeps the session alive — your dev server keeps running, Claude keeps thinking. Requires tmux. |
+| **Sync / Reconcile** | `lattices sync` brings a running session back in line with its declared config — recreates missing panes, re-applies layout, restores labels, re-runs commands in idle panes. Requires tmux. |
+| **Ensure / Prefill** | Two modes for restoring exited commands on reattach. **Ensure** auto-reruns the command. **Prefill** types it but waits for you to press Enter. Set via `.lattices.json`. Requires tmux. |
+| **tmux** | Terminal multiplexer (optional). Provides persistent sessions, pane layouts, and command restoration. Install with `brew install tmux` if you want session management. |
+
+## How it works
+
+1. You create a `.lattices.json` file in your project root (or run `lattices init`)
+2. The menu bar app discovers the project and adds it to the command palette
+3. You can tile windows, switch layers, search via OCR, and use the agent API
+4. With tmux installed, `lattices` also creates persistent terminal sessions:
+   - Each pane gets its command (claude, dev server, tests, etc.)
+   - The session persists in the background until you kill it
+   - You can attach/detach from any terminal at any time
+   - If `ensure` is enabled, exited commands auto-restart on reattach
+
+## Architecture
+
+<img src="/architecture.svg" alt="lattices architecture diagram" style="margin: 2rem 0; max-width: 100%;" />
+
+- The menu bar app is the core. It provides the command palette,
+  window tiling, OCR, project discovery, and the agent API (a WebSocket
+  server on `ws://127.0.0.1:9399`). It works with or without tmux.
+- The CLI handles tiling, OCR queries, and (when tmux is installed)
+  session management via `tmux` shell commands.
+- Agents and scripts connect to the agent API over WebSocket. They can
+  do everything the app and CLI can do: discover projects, tile windows,
+  switch layers, read on-screen text, and subscribe to real-time events.
+  See the [Agent API reference](/docs/api).
+- When tmux is installed, the app and CLI can also launch, sync, and
+  manage persistent terminal sessions. All layers share the same session
+  naming convention so they always agree on which session belongs to
+  which project.
+
+### Session naming
+
+A session name is `<basename>-<hash>`, where:
+
+- `basename` is the project directory name (non-alphanumeric chars replaced with `-`)
+- `hash` is the first 6 hex chars of the SHA-256 of the full absolute path
+
+This guarantees unique session names even if two projects share the
+same directory name (e.g. `~/work/app` and `~/personal/app`).
+
+Both the CLI (Node.js `crypto.createHash`) and the app (Swift
+`CryptoKit.SHA256`) produce identical hashes.
+
+### Window discovery via title tags
+
+When lattices creates a tmux session, it sets the tmux option:
+
+```
+set-titles-string "[lattices:<session-name>] #{pane_title}"
+```
+
+This embeds a `[lattices:name]` tag in the terminal window title. The
+menu bar app uses this tag to find windows via three fallback paths:
+
+1. **CGWindowList** (needs Screen Recording permission) — fastest,
+   reads window names from the window server
+2. **Accessibility API** (needs Accessibility permission) — queries
+   AXUIElement window titles for the terminal app
+3. **AppleScript** — iterates Terminal.app or iTerm2 windows by name
+
+### Space switching via SkyLight
+
+The menu bar app can switch macOS Spaces to reach a session's window.
+It uses private SkyLight framework APIs loaded at runtime via `dlopen`:
+
+- `CGSMainConnectionID` — get the connection to the window server
+- `CGSGetActiveSpace` — current Space ID
+- `CGSCopyManagedDisplaySpaces` — enumerate all Spaces per display
+- `SLSCopySpacesForWindows` — find which Space a window is on
+- `SLSManagedDisplaySetCurrentSpace` — switch a display to a Space
+
+This is the same approach used by [Loop](https://github.com/MrKai77/Loop)
+and other macOS window managers.
+
+### Ensure/prefill restoration (requires tmux)
+
+When you run `lattices` (no arguments) and a session already exists:
+
+1. lattices checks the `ensure` / `prefill` flag in `.lattices.json`
+2. For each pane, it queries `#{pane_current_command}` via tmux
+3. If the pane is running a shell (bash, zsh, fish, sh, dash) — meaning
+   the original command has exited — it either:
+   - **ensure**: sends the command + Enter (auto-restart)
+   - **prefill**: sends the command without Enter (manual restart)
+4. Then it attaches to the session as normal
+
+## Agent control
+
+The agent API gives agents the same control as a human using the
+menu bar app. An agent can list projects and windows, launch sessions,
+tile windows to screen positions, subscribe to real-time events
+(`windows.changed`, `tmux.changed`, `layer.switched`), and sync
+sessions back to their declared config.
+
+A typical orchestrator sets up a multi-project workspace in a few
+`daemonCall()` invocations. See the [Agent API reference](/docs/api)
+for the full method list and code examples.
+
+## Key shortcuts (inside tmux)
+
+These work when you're inside a tmux session:
+
+| Shortcut       | Action                |
+|----------------|-----------------------|
+| Ctrl+B  D      | Detach from session   |
+| Ctrl+B  X      | Kill current pane     |
+| Ctrl+B  Left   | Move to left pane     |
+| Ctrl+B  Right  | Move to right pane    |
+| Ctrl+B  Up     | Move to pane above    |
+| Ctrl+B  Down   | Move to pane below    |
+| Ctrl+B  Z      | Zoom pane (toggle)    |
+| Ctrl+B  [      | Scroll mode (q exits) |
+
+The prefix `Ctrl+B` means: hold Control, press B, release both,
+then press the next key.

package/docs/config.md

@@ -0,0 +1,245 @@
+---
+title: Configuration
+description: CLI commands, .lattices.json format, and tile positions
+order: 2
+---
+
+## .lattices.json
+
+Place a `.lattices.json` file in your project root to define your
+workspace layout. lattices reads this file when creating a session.
+
+### Minimal example
+
+```json
+{
+  "panes": [
+    { "name": "claude", "cmd": "claude" },
+    { "name": "server", "cmd": "pnpm dev" }
+  ]
+}
+```
+
+### Full example
+
+```json
+{
+  "ensure": true,
+  "panes": [
+    { "name": "claude", "cmd": "claude", "size": 60 },
+    { "name": "server", "cmd": "pnpm dev" },
+    { "name": "tests",  "cmd": "pnpm test --watch" }
+  ]
+}
+```
+
+## Config fields
+
+| Field    | Type    | Required | Description                                          |
+|----------|---------|----------|------------------------------------------------------|
+| panes    | array   | no       | List of pane definitions (see below)                 |
+| ensure   | boolean | no       | Auto-restart exited commands on reattach              |
+| prefill  | boolean | no       | Type exited commands into idle panes on reattach (you hit Enter) |
+
+`ensure` and `prefill` are mutually exclusive. If both are set,
+`ensure` takes priority.
+
+- **ensure** — when you reattach to an existing session, lattices checks
+  each pane. If a pane's process has exited and the shell is idle, lattices
+  automatically re-runs its declared command.
+- **prefill** — same check, but the command is typed into the pane
+  without pressing Enter. You review and hit Enter yourself.
+
+## Pane fields
+
+| Field  | Type   | Required | Description                         |
+|--------|--------|----------|-------------------------------------|
+| name   | string | no       | Label for the pane (shown in app)   |
+| cmd    | string | no       | Command to run when pane opens      |
+| size   | number | no       | Width % for the first pane (1-99)   |
+
+- `size` only applies to the **first pane**. It sets the width of the
+  main pane as a percentage. Default is 60.
+- `cmd` can be any shell command. If omitted, the pane opens a shell.
+- `name` is used in the lattices app to show a summary of your layout,
+  and as a target for `lattices restart <name>`.
+
+## Layouts
+
+lattices picks a layout based on how many panes you define:
+
+### 2 panes — side by side
+
+```
+┌──────────┬─────────┐
+│  claude  │ server  │
+│  (60%)   │ (40%)   │
+└──────────┴─────────┘
+```
+
+Horizontal split. First pane on the left, second on the right.
+
+### 3+ panes — main-vertical
+
+```
+┌──────────┬─────────┐
+│  claude  │ server  │
+│  (60%)   ├─────────┤
+│          │ tests   │
+└──────────┴─────────┘
+```
+
+First pane takes the left side. Remaining panes stack vertically
+on the right.
+
+### 4 panes
+
+```
+┌──────────┬─────────┐
+│  claude  │ server  │
+│  (60%)   ├─────────┤
+│          │ tests   │
+│          ├─────────┤
+│          │ logs    │
+└──────────┴─────────┘
+```
+
+## Auto-detection (no config)
+
+If there's no `.lattices.json`, lattices still works. It will:
+
+1. Create a 2-pane layout (60/40 split)
+2. Run `claude` in the left pane
+3. Auto-detect your dev command from package.json scripts:
+   - Looks for: `dev`, `start`, `serve`, `watch` (in that order)
+   - Detects package manager: pnpm > bun > yarn > npm
+
+## Creating a config
+
+Run `lattices init` in your project directory to generate a starter
+`.lattices.json` based on your project. The generated config includes
+`"ensure": true` by default.
+
+## CLI commands
+
+| Command                    | Description                                      |
+|----------------------------|--------------------------------------------------|
+| `lattices`                   | Create or attach to session for current project   |
+| `lattices init`              | Generate .lattices.json config for this project     |
+| `lattices ls`                | List active sessions (requires tmux)              |
+| `lattices kill [name]`       | Kill a session (defaults to current project)      |
+| `lattices sync`              | Reconcile session to match declared config        |
+| `lattices restart [pane]`    | Restart a pane's process (by name or index)       |
+| `lattices tile <position>`   | Tile the frontmost window to a screen position    |
+| `lattices group [id]`        | List tab groups or launch/attach a group          |
+| `lattices groups`            | List all tab groups with status                   |
+| `lattices tab <group> [tab]` | Switch tab within a group (by label or index)     |
+| `lattices app`               | Launch the menu bar companion app                 |
+| `lattices app build`         | Rebuild the menu bar app from source              |
+| `lattices app restart`       | Rebuild and relaunch the menu bar app             |
+| `lattices layer [name\|index]` | Switch to a workspace layer by name or index      |
+| `lattices windows [--json]`  | List all visible windows                          |
+| `lattices window assign <wid> <layer>` | Tag a window to a layer                |
+| `lattices window map [--json]` | Show all window→layer assignments                |
+| `lattices scan search <query>` | Search indexed screen text                       |
+| `lattices diag [limit]`       | Show recent diagnostic entries                   |
+| `lattices focus <session>`   | Focus a session's window and switch Spaces        |
+| `lattices app`               | Launch the menu bar companion app                 |
+| `lattices app build`         | Rebuild the menu bar app from source              |
+| `lattices app restart`       | Rebuild and relaunch the menu bar app             |
+| `lattices app quit`          | Stop the menu bar app                             |
+| `lattices help`              | Show help                                         |
+
+Aliases: `ls`/`list`, `kill`/`rm`, `sync`/`reconcile`,
+`restart`/`respawn`, `tile`/`t`.
+
+## Machine-readable output
+
+### `--json` flag
+
+The `lattices windows` command supports a `--json` flag for structured
+output:
+
+```bash
+lattices windows --json
+```
+
+Returns a JSON array of window objects to stdout, useful for piping
+into `jq` or consuming from scripts.
+
+### Daemon responses
+
+All agent API calls return JSON natively. If you need structured data
+from lattices, the daemon is easier than parsing stdout. See the
+[API reference](/docs/api).
+
+### Exit codes
+
+| Code | Meaning                                     |
+|------|---------------------------------------------|
+| `0`  | Success                                     |
+| `1`  | General error (missing args, bad config)    |
+| `2`  | Session not found                           |
+
+## Recovery
+
+### sync
+
+```
+lattices sync
+```
+
+Reconciles a running session to match the declared config:
+
+1. Counts actual panes vs declared panes
+2. Recreates any missing panes
+3. Re-applies the layout (main-vertical with correct width)
+4. Restores pane labels
+5. Re-runs declared commands in any idle panes
+
+Use when a pane was killed and you want to get back to the declared
+state without killing the whole session.
+
+### restart
+
+```
+lattices restart [target]
+```
+
+Kills the process in a specific pane and re-runs its declared command.
+The target can be:
+
+- A **pane name** (case-insensitive): `lattices restart server`
+- A **0-based index**: `lattices restart 1`
+- **Omitted** (defaults to pane 0): `lattices restart`
+
+The restart sequence: send Ctrl-C, wait 0.5s, check if the process
+stopped. If it's still running, escalate to SIGKILL on child
+processes. Then send the declared command.
+
+## Tile positions
+
+The `lattices tile` command moves the frontmost window to a preset
+screen position. Available positions:
+
+| Position       | Area                        |
+|----------------|-----------------------------|
+| `left`         | Left half                   |
+| `right`        | Right half                  |
+| `top`          | Top half                    |
+| `bottom`       | Bottom half                 |
+| `top-left`     | Top-left quarter            |
+| `top-right`    | Top-right quarter           |
+| `bottom-left`  | Bottom-left quarter         |
+| `bottom-right` | Bottom-right quarter        |
+| `maximize`     | Full screen (visible area)  |
+| `left-third`   | Left third                  |
+| `center-third` | Center third                |
+| `right-third`  | Right third                 |
+| `center`       | 70% width, 80% height, centered |
+
+Aliases: `left-half`/`left`, `right-half`/`right`, `top-half`/`top`,
+`bottom-half`/`bottom`, `max`/`maximize`.
+
+Tiling respects the menu bar and dock. It uses the visible desktop
+area, not the full screen.