@lattices/cli 0.3.0 → 0.4.1

package/docs/agent-layer-guide.md

@@ -0,0 +1,207 @@
+# Agent Guide: Generating Layers
+
+How to create and manage Lattices workspace layers programmatically. This guide is for AI agents (Claude Code, etc.) that want to generate layers from high-level user descriptions.
+
+## Quick Reference
+
+```bash
+# See what's on screen
+lattices windows --json
+
+# Create a layer with tiling
+lattices layer create "Design" --json '[
+  {"app": "Figma", "tile": "left"},
+  {"app": "Google Chrome", "title": "Tailwind", "tile": "right"}
+]'
+
+# Snapshot current windows as a layer
+lattices layer snap "my-context"
+
+# List / switch / delete session layers
+lattices layer session
+lattices layer session "Design"
+lattices layer delete "Design"
+lattices layer clear
+```
+
+## How It Works
+
+There are two kinds of layers:
+
+| Type | Storage | Requires restart? | How to create |
+|------|---------|-------------------|---------------|
+| **Config layers** | `~/.lattices/workspace.json` | Yes (or refresh) | Edit JSON file |
+| **Session layers** | In-memory (daemon) | No | CLI or daemon API |
+
+**Session layers are what you want.** They're created via TypeScript CLI commands, take effect immediately, and don't require restarting anything.
+
+## Step-by-Step: Generating a Layer
+
+### 1. Discover what's available
+
+```bash
+lattices windows --json
+```
+
+Returns an array of window objects:
+```json
+[
+  {
+    "wid": 1234,
+    "app": "iTerm2",
+    "title": "lattices — zsh",
+    "latticesSession": "lattices-abc123",
+    "frame": { "x": 0, "y": 25, "w": 960, "h": 1050 },
+    "spaceIds": [1]
+  },
+  {
+    "wid": 5678,
+    "app": "Google Chrome",
+    "title": "GitHub - arach/lattices",
+    "frame": { "x": 960, "y": 25, "w": 960, "h": 1050 },
+    "spaceIds": [1]
+  }
+]
+```
+
+Key fields for matching:
+- `wid` — unique window ID (most precise)
+- `app` — application name
+- `title` — window title (use for disambiguation when multiple windows of same app)
+- `latticesSession` — tmux session name (for terminal windows)
+
+### 2. Decide on a layout
+
+Pick tile positions based on how many windows and what makes sense:
+
+| Windows | Good layout | Tile values |
+|---------|-------------|-------------|
+| 2 | Side by side | `left`, `right` |
+| 2 | Stacked | `top`, `bottom` |
+| 3 | Main + sidebar | `left` (60%), `top-right`, `bottom-right` |
+| 3 | Columns | `left-third`, `center-third`, `right-third` |
+| 4 | Quadrants | `top-left`, `top-right`, `bottom-left`, `bottom-right` |
+| 1 | Focused | `maximize` or `center` |
+
+Full position reference:
+- **Halves**: `left`, `right`, `top`, `bottom`
+- **Quarters**: `top-left`, `top-right`, `bottom-left`, `bottom-right`
+- **Thirds**: `left-third`, `center-third`, `right-third`
+- **Sixths**: `top-left-third`, `top-center-third`, `top-right-third`, `bottom-left-third`, `bottom-center-third`, `bottom-right-third`
+- **Fourths**: `first-fourth`, `second-fourth`, `third-fourth`, `last-fourth`
+- **Special**: `maximize`, `center`
+- **Custom grid**: `grid:CxR:C,R` (e.g. `grid:5x3:2,1`)
+
+### 3. Create the layer
+
+**Option A: By window ID (most reliable)**
+```bash
+lattices layer create "Coding" --json '[
+  {"wid": 1234, "tile": "left"},
+  {"wid": 5678, "tile": "right"}
+]'
+```
+
+**Option B: By app name (survives window recreation)**
+```bash
+lattices layer create "Research" --json '[
+  {"app": "Google Chrome", "title": "docs", "tile": "left"},
+  {"app": "Notes", "tile": "right"}
+]'
+```
+
+**Option C: Simple wid list (no tiling)**
+```bash
+lattices layer create "Focus" wid:1234 wid:5678
+```
+
+**Option D: Snapshot everything visible**
+```bash
+lattices layer snap "Current Context"
+```
+
+### 4. Switch between layers
+
+```bash
+lattices layer session          # list all session layers
+lattices layer session "Coding" # switch to "Coding"
+lattices layer session 0        # switch by index
+```
+
+## Daemon API (Advanced)
+
+For finer control, use raw daemon calls:
+
+```bash
+# Create layer with window IDs
+lattices call session.layers.create '{"name":"Coding","windowIds":[1234,5678]}'
+
+# Create layer with app references
+lattices call session.layers.create '{"name":"Design","windows":[{"app":"Figma"},{"app":"Google Chrome","contentHint":"Tailwind"}]}'
+
+# Tile a specific window
+lattices call window.place '{"wid":1234,"placement":"left"}'
+
+# Switch layer
+lattices call session.layers.switch '{"name":"Coding"}'
+
+# List session layers
+lattices call session.layers.list
+
+# Delete
+lattices call session.layers.delete '{"name":"old-layer"}'
+```
+
+## Composing Layers from Intent
+
+When a user says something high-level, here's how to think about it:
+
+### "Make me a coding layer"
+1. Find terminal windows (iTerm2, Terminal, Warp, etc.)
+2. Find browser windows with dev-related titles (GitHub, docs, localhost)
+3. Main editor/terminal on `left`, reference material on `right`
+
+### "Set up a design layer"
+1. Find design tools (Figma, Sketch, Adobe XD)
+2. Find browser windows with design references
+3. Design tool `left` (or `maximize`), references `right`
+
+### "Create a writing layer"
+1. Find text editors, notes apps (Notes, Obsidian, iA Writer, VS Code with .md)
+2. Find research/reference windows
+3. Writing app `left` or `center`, references `right`
+
+### "Give me a communication layer"
+1. Find messaging apps (Slack, Discord, Messages)
+2. Find email (Mail, Gmail in browser)
+3. Arrange by priority — primary tool `left`, secondary `right`
+
+### "Split my work into layers by project"
+1. Group windows by project (match on title keywords, session names, or app)
+2. Create one layer per project group
+3. Use the 3-window layout pattern: main `left`, support `top-right`, `bottom-right`
+
+## App Grouping Heuristics
+
+When deciding which windows go together:
+
+| Category | Common apps | Goes well with |
+|----------|-------------|----------------|
+| **Code** | iTerm2, Terminal, VS Code, Xcode | Chrome (docs/GitHub), Simulator |
+| **Design** | Figma, Sketch, Pixelmator | Chrome (design systems), Preview |
+| **Writing** | Notes, Obsidian, iA Writer | Chrome (research), Preview |
+| **Communication** | Slack, Discord, Messages, Mail | Calendar, Notes |
+| **Media** | Spotify, Music, Podcasts | (background, no tile needed) |
+| **Reference** | Chrome, Safari, Preview, Finder | (depends on content) |
+
+Browser windows are chameleons — use `title` matching to assign them to the right layer based on their content.
+
+## Tips
+
+- Prefer `wid` when the windows are already open — it's unambiguous.
+- Use `app` + `title` when you want the layer to survive window restarts.
+- Don't put more than 4-5 windows in a single layer — it gets cramped.
+- Background apps (music, etc.) usually don't need to be in any layer.
+- The `snap` command is great for "save what I have now" scenarios.
+- Session layers are ephemeral — they live until the daemon restarts. For permanent layers, edit `~/.lattices/workspace.json`.
+- You can create multiple layers in sequence, then switch between them with `lattices layer session <name>`.

package/docs/agents.md

@@ -0,0 +1,142 @@
+---
+title: Agent Guide
+description: Canonical contracts for agents using docs URLs, CLI, voice, and the daemon API
+order: 6
+---
+
+Lattices exposes the same execution model through four surfaces:
+
+- **Docs URLs** for discovery and citation
+- **CLI** for shell-based agents
+- **Daemon API** for typed programmatic control
+- **Voice / hands-off / HUD** as clients of the same execution layer
+
+The rule is simple: agents should learn the **canonical action model**
+first, then choose the transport that fits the environment.
+
+## Canonical mutations
+
+These are the preferred action identifiers:
+
+| Action | Purpose | Preferred surface |
+|--------|---------|-------------------|
+| `window.place` | Place a window or session using a typed placement spec | Daemon API |
+| `layer.activate` | Bring up a workspace layer with explicit activation mode | Daemon API |
+| `space.optimize` | Rebalance a set of windows using an explicit scope and strategy | Daemon API |
+
+Compatibility wrappers still exist:
+
+| Legacy method | Canonical equivalent |
+|---------------|----------------------|
+| `window.tile` | `window.place` |
+| `layer.switch` | `layer.activate` with `mode=launch` |
+| `layout.distribute` | `space.optimize` with `scope=visible`, `strategy=balanced` |
+
+## Discoverability
+
+Agents should use these paths in order:
+
+1. **API schema**: `lattices call api.schema`
+2. **Daemon reference**: [/docs/api](/docs/api)
+3. **Agent guide**: [/docs/agents](/docs/agents)
+4. **Voice model**: [/docs/voice](/docs/voice)
+5. **Concepts / config**: [/docs/concepts](/docs/concepts), [/docs/config](/docs/config)
+
+Useful CLI discovery commands:
+
+```bash
+lattices help
+lattices call api.schema
+lattices voice intents
+```
+
+## Placement contract
+
+At the boundary, placements may be strings for convenience.
+Inside the daemon, the canonical contract is typed.
+
+String shorthand:
+
+```json
+{ "placement": "top-right" }
+{ "placement": "grid:3x2:2,0" }
+```
+
+Typed placement objects:
+
+```json
+{ "placement": { "kind": "tile", "value": "top-third" } }
+{ "placement": { "kind": "grid", "columns": 3, "rows": 2, "column": 2, "row": 0 } }
+{ "placement": { "kind": "fractions", "x": 0.5, "y": 0, "w": 0.5, "h": 1 } }
+```
+
+This lets voice stay natural while the executor stays explicit.
+
+## Choosing a surface
+
+Use the **daemon API** when you need:
+
+- typed receipts and traces
+- explicit targeting by `wid`, `session`, or `app`
+- composition across layers, windows, and optimization
+
+Use the **CLI** when you need:
+
+- one-shot shell execution
+- quick discovery from inside an agent terminal
+- compatibility with environments that already have `lattices`
+
+Use **docs URLs** when an agent needs:
+
+- a citeable contract
+- a stable page to open in a browser or pass to another agent
+- quick onboarding without reading source
+
+## Examples
+
+Node.js:
+
+```js
+import { daemonCall } from '@lattices/cli'
+
+await daemonCall('session.launch', { path: '/Users/you/dev/frontend' })
+await daemonCall('window.place', {
+  session: 'frontend-a1b2c3',
+  placement: { kind: 'tile', value: 'left' }
+})
+await daemonCall('layer.activate', { name: 'review', mode: 'launch' })
+await daemonCall('space.optimize', { scope: 'visible', strategy: 'balanced' })
+```
+
+CLI:
+
+```bash
+lattices call api.schema
+lattices call window.place '{"session":"frontend-a1b2c3","placement":"left"}'
+lattices call layer.activate '{"name":"review","mode":"launch"}'
+lattices call space.optimize '{"scope":"visible","strategy":"balanced"}'
+```
+
+## Receipts and traceability
+
+Mutating daemon calls should return structured receipts when possible.
+The important fields for agents are:
+
+- resolved target
+- resolved placement / scope / mode
+- affected window IDs
+- trace entries explaining why the daemon chose that path
+
+This is what keeps voice, hands-off, and scripted execution scrutable.
+
+## Voice and hands-off
+
+Voice is not a separate execution system. It should compile into the
+same canonical actions:
+
+- "put Terminal in the upper third" → `window.place`
+- "bring up review" → `layer.activate`
+- "make this nice" → `space.optimize`
+
+That keeps the interaction layer flexible while the executor stays
+predictable.

package/docs/api.md

@@ -112,7 +112,10 @@ const win = await daemonCall('windows.get', { wid: 1234 })
 
 // Mutations
 await daemonCall('session.launch', { path: '/Users/you/dev/myapp' })
-await daemonCall('window.tile', { session: 'myapp-a1b2c3', position: 'left' })
+await daemonCall('window.place', {
+  session: 'myapp-a1b2c3',
+  placement: { kind: 'tile', value: 'left' }
+})
 
 // Custom timeout (default: 3000ms)
 await daemonCall('projects.scan', null, 10000)
@@ -190,6 +193,12 @@ Useful for agent self-discovery.
 
 **Params**: none
 
+CLI shortcut:
+
+```bash
+lattices call api.schema
+```
+
 #### `diagnostics.list`
 
 Return recent diagnostic log entries from the daemon.
@@ -210,13 +219,15 @@ Return recent diagnostic log entries from the daemon.
 | `windows.get` | read | Single window by ID |
 | `windows.search` | read | Search windows by query |
 | `spaces.list` | read | macOS display spaces |
-| `window.tile` | write | Tile a window to a position |
+| `window.place` | write | Place a window or session using a typed placement spec |
+| `window.tile` | write | Compatibility wrapper for session tiling |
 | `window.focus` | write | Focus a window / switch Spaces |
 | `window.move` | write | Move a window to another Space |
 | `window.assignLayer` | write | Tag a window to a layer |
 | `window.removeLayer` | write | Remove a window's layer tag |
 | `window.layerMap` | read | All window→layer assignments |
-| `layout.distribute` | write | Distribute windows evenly |
+| `space.optimize` | write | Optimize a set of windows using an explicit scope and strategy |
+| `layout.distribute` | write | Compatibility wrapper for visible-window balancing |
 
 #### `windows.list`
 
@@ -263,17 +274,50 @@ Get a single window by its CGWindowID.
 
 #### `windows.search`
 
-Search windows by text query, including OCR content.
+Search windows by text query across title, app name, session tags, and OCR content. Returns results with `matchSource` indicating how the match was found, and `ocrSnippet` for OCR matches.
 
 **Params**:
 
 | Field   | Type   | Required | Description                    |
 |---------|--------|----------|--------------------------------|
-| `query` | string | yes      | Search query (matches title, app, OCR text) |
+| `query` | string | yes      | Search query (matches title, app, session, OCR text) |
 | `ocr`   | boolean| no       | Include OCR text in search (default true) |
-| `limit` | number | no       | Max results (default 20)       |
+| `limit` | number | no       | Max results (default 50)       |
+
+**Returns**: array of window objects with additional search fields:
+
+```json
+[
+  {
+    "wid": 265,
+    "app": "iTerm2",
+    "title": "✳ Claude Code",
+    "matchSource": "ocr",
+    "ocrSnippet": "…~/dev/vox StatusBarIconFolder…",
+    "frame": { "x": 688, "y": 3, "w": 1720, "h": 720 },
+    "isOnScreen": true
+  }
+]
+```
 
-**Returns**: array of window objects matching the query.
+`matchSource` values: `"title"`, `"app"`, `"session"`, `"ocr"`.
+
+**CLI usage**:
+
+```bash
+# Basic search (uses windows.search)
+lattices search vox
+
+# Deep search — adds terminal tab/process inspection for ranking
+lattices search vox --deep
+
+# Pipeable output
+lattices search vox --wid
+lattices search vox --json
+
+# Search + focus + tile in one step
+lattices place vox right
+```
 
 #### `spaces.list`
 
@@ -297,20 +341,53 @@ List macOS display spaces (virtual desktops).
 ]
 ```
 
-#### `window.tile`
+#### `window.place`
 
-Tile a session's terminal window to a screen position.
+Canonical window placement mutation. Use this when an agent needs a
+single, typed placement contract across voice, CLI, and daemon clients.
 
 **Params**:
 
-| Field      | Type   | Required | Description                         |
-|------------|--------|----------|-------------------------------------|
-| `session`  | string | yes      | Session name                        |
-| `position` | string | yes      | Tile position (see below)           |
+| Field       | Type            | Required | Description                              |
+|-------------|-----------------|----------|------------------------------------------|
+| `wid`       | number          | no       | Target window ID                          |
+| `session`   | string          | no       | Target lattices session                   |
+| `app`       | string          | no       | Target app name                           |
+| `title`     | string          | no       | Optional title substring for app matching |
+| `display`   | number          | no       | Target display index                      |
+| `placement` | string \| object | yes     | Placement shorthand or typed object       |
+
+Target resolution priority is `wid` → `session` → `app/title` → frontmost window.
 
-**Positions**: `left`, `right`, `top`, `bottom`, `top-left`, `top-right`,
+**Placement strings**: `left`, `right`, `top`, `bottom`, `top-left`, `top-right`,
 `bottom-left`, `bottom-right`, `left-third`, `center-third`, `right-third`,
-`maximize`, `center`
+`top-third`, `middle-third`, `bottom-third`, `left-quarter`, `right-quarter`,
+`top-quarter`, `bottom-quarter`, `maximize`, `center`, or `grid:CxR:C,R`.
+
+**Typed placement examples**:
+
+```json
+{ "kind": "tile", "value": "top-right" }
+{ "kind": "grid", "columns": 3, "rows": 2, "column": 2, "row": 0 }
+{ "kind": "fractions", "x": 0.5, "y": 0, "w": 0.5, "h": 1 }
+```
+
+**Returns**: execution receipt including resolved target, placement, and trace.
+
+#### `window.tile`
+
+Compatibility wrapper for `window.place` when the target is a lattices
+session window.
+
+**Params**:
+
+| Field      | Type   | Required | Description                             |
+|------------|--------|----------|-----------------------------------------|
+| `session`  | string | yes      | Session name                            |
+| `position` | string | yes      | Placement shorthand or grid syntax      |
+
+This method exists for compatibility. New integrations should prefer
+`window.place`.
 
 #### `window.focus`
 
@@ -375,9 +452,31 @@ Return all current window→layer assignments.
 
 Keys are CGWindowIDs (as strings), values are layer IDs.
 
+#### `space.optimize`
+
+Canonical space-balancing mutation. Use this when the goal is to make
+the current workspace coherent rather than placing one specific window.
+
+**Params**:
+
+| Field       | Type     | Required | Description                                         |
+|-------------|----------|----------|-----------------------------------------------------|
+| `scope`     | string   | no       | `visible`, `active-app`, `app`, or `selection`      |
+| `strategy`  | string   | no       | `balanced` or `mosaic`                              |
+| `app`       | string   | no       | App name for `app` scope                            |
+| `title`     | string   | no       | Optional title substring for app matching           |
+| `windowIds` | number[] | no       | Explicit window IDs for `selection` scope           |
+
+If `windowIds` is provided, scope is inferred as `selection`.
+If `app` is provided and `scope` is omitted, scope is inferred as `app`.
+
+**Returns**: execution receipt including resolved scope, strategy,
+affected window IDs, and trace.
+
 #### `layout.distribute`
 
-Distribute all visible lattices windows evenly across the screen.
+Compatibility wrapper for `space.optimize` with `scope=visible` and
+`strategy=balanced`.
 
 **Params**: none
 
@@ -512,7 +611,8 @@ Restart a specific pane's process within a session.
 | `projects.list` | read | Discovered projects |
 | `projects.scan` | write | Re-scan project directory |
 | `layers.list` | read | Workspace layers and active index |
-| `layer.switch` | write | Switch workspace layer |
+| `layer.activate` | write | Activate a workspace layer using an explicit mode |
+| `layer.switch` | write | Compatibility wrapper for launch-style layer activation |
 | `group.launch` | write | Launch a tab group |
 | `group.kill` | write | Kill a tab group |
 
@@ -569,20 +669,33 @@ List configured workspace layers and the active index.
 
 Returns empty `layers` array if no workspace config is loaded.
 
-#### `layer.switch`
+#### `layer.activate`
 
-Switch the active workspace layer. Focuses and tiles all windows in the
-target layer, launches any projects that aren't running yet, and posts
-a `layer.switched` event.
+Canonical layer mutation. Use this when an agent wants an explicit
+activation mode instead of implicit "switch" behavior.
 
 **Params**:
 
-| Field   | Type   | Required | Description                    |
-|---------|--------|----------|--------------------------------|
-| `index` | number | no       | Layer index (0-based)          |
-| `name`  | string | no       | Layer ID or label              |
+| Field   | Type   | Required | Description                                 |
+|---------|--------|----------|---------------------------------------------|
+| `index` | number | no       | Layer index (0-based)                       |
+| `name`  | string | no       | Layer ID or label                           |
+| `mode`  | string | no       | `launch`, `focus`, or `retile`              |
+
+Provide either `index` or `name`.
 
-Provide either `index` or `name`. If both are given, `name` takes priority.
+**Modes**:
+
+- `launch` — bring up the layer, launching missing projects and retiling
+- `focus` — raise the layer's windows in place
+- `retile` — re-apply the layer layout without launch semantics
+
+**Returns**: execution receipt including resolved layer, mode, and trace.
+
+#### `layer.switch`
+
+Compatibility wrapper for `layer.activate` with `mode=launch`.
+It keeps the old semantics and still posts a `layer.switched` event.
 
 #### `group.launch`
 
@@ -839,13 +952,19 @@ project knows how to control the workspace:
 This project uses lattices for workspace management. The daemon API
 is available at ws://127.0.0.1:9399.
 
-### Available commands
-- List windows: `daemonCall('windows.list')`
-- List sessions: `daemonCall('tmux.sessions')`
+### Search (find windows)
+- Search by content: `daemonCall('windows.search', { query: 'myproject' })`
+  Returns windows with `matchSource` ("title", "app", "session", "ocr") and `ocrSnippet`
+- Search terminals: `daemonCall('terminals.search', {})` — tabs, cwds, processes
+- CLI: `lattices search myproject` or `lattices search myproject --deep`
+
+### Actions
+- Focus a window: `daemonCall('window.focus', { wid: 1234 })`
+- Place a window: `daemonCall('window.place', { session: 'name', placement: 'left' })`
 - Launch a project: `daemonCall('session.launch', { path: '/absolute/path' })`
-- Tile a window: `daemonCall('window.tile', { session: 'name', position: 'left' })`
-- Switch layer: `daemonCall('layer.switch', { index: 0 })`
-- Switch layer by name: `daemonCall('layer.switch', { name: 'web' })`
+- Activate a layer: `daemonCall('layer.activate', { name: 'web', mode: 'launch' })`
+- Optimize the workspace: `daemonCall('space.optimize', { scope: 'visible', strategy: 'balanced' })`
+- CLI: `lattices place myproject left` (search + focus + tile in one step)
 
 ### Import
 \```js
@@ -872,8 +991,8 @@ const sessions = await daemonCall('tmux.sessions')
 const fe = sessions.find(s => s.name.startsWith('frontend'))
 const api = sessions.find(s => s.name.startsWith('api'))
 
-await daemonCall('window.tile', { session: fe.name, position: 'left' })
-await daemonCall('window.tile', { session: api.name, position: 'right' })
+await daemonCall('window.place', { session: fe.name, placement: 'left' })
+await daemonCall('window.place', { session: api.name, placement: 'right' })
 ```
 
 ### Reactive event pattern

package/docs/app.md

@@ -143,10 +143,21 @@ 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.
 
+## Voice commands
+
+> See [Voice Commands](/docs/voice) for the full guide.
+
+Press **Hyper+3** to open the voice command window. Hold **Option** to
+speak, release to stop. Lattices transcribes via Vox, matches to an
+intent, and executes. Built-in commands: find, show, open, tile, kill, scan.
+
+A Claude Haiku advisor runs in parallel, offering follow-up suggestions
+in the AI corner. Configure the model and budget in Settings > AI.
+
 ## Settings
 
 Open via the command palette or the gear icon in the main view.
-The settings window has three tabs:
+The settings window has four tabs:
 
 ### General
 
@@ -162,6 +173,17 @@ The settings window has three tabs:
   (helpful while getting used to tmux)
 - **Auto** — detaches sessions automatically (fewer prompts)
 
+### AI
+
+| Setting              | Default        | Description                              |
+|----------------------|----------------|------------------------------------------|
+| Claude CLI path      | Auto-detected  | Path to `claude` binary                  |
+| Advisor model        | Haiku          | `haiku` (fast) or `sonnet` (smarter)     |
+| Budget per session   | $0.50          | Max spend per Claude CLI invocation      |
+
+Shows live session stats: context usage %, session cost, and learned
+pattern count.
+
 ### Shortcuts
 
 Shows keyboard shortcut reference:
@@ -169,6 +191,12 @@ Shows keyboard shortcut reference:
 | Shortcut          | Action              |
 |-------------------|----------------------|
 | Cmd+Shift+M       | Open command palette |
+| Hyper+1            | Screen map           |
+| Hyper+2            | Window bezel         |
+| Hyper+3            | Voice commands       |
+| Hyper+4            | Desktop inventory    |
+| Hyper+5            | Omni search          |
+| Hyper+6            | Cheat sheet          |
 | Cmd+Option+1/2/3  | Switch workspace layer |
 | Ctrl+B  D         | Detach from session  |
 | Ctrl+B  X         | Kill current pane    |