# Shortcuts

Shortcuts let you open common Scient actions without leaving the keyboard.
Open **Settings → Shortcuts** to see configurable commands and the shortcuts used by
the version you are running.

The settings page shows whether a shortcut is built in or customized and warns
when two active commands conflict. Change a shortcut there, remove a custom
shortcut, or reset it to the default. Use the command list in the app rather
than a copied list because available actions can change between versions.

## Shortcut sections

The Shortcuts page uses the same source selector as Skills. Choose **General**, **Write**, **Source**, **Tables**, **Markdown**, **Math**, or **PDF** to show only that
part of the product. General contains application commands; the other sections
contain document-authoring and reading commands. The selected section stays open.

Use the page search to filter the selected section. Click a document shortcut to
edit it in place, or use **+** to add an alternative. The row menu can disable a
command or reset it to its defaults. A command without a keyboard binding remains
available from its toolbar when supported by the focused editor.

Document preferences belong to this browser or desktop profile and apply to its
open editors across environments. Application rules above them still belong to
the selected environment's `keybindings.json`. This is one place to discover
shortcuts, not a migration of environment settings into browser storage.

The focused document gets first use of its recognized commands. For example,
`mod+b` formats Markdown instead of toggling the sidebar; outside that document
the application shortcut still works. Nested equation and code inputs retain
their own text editing. A disabled document binding no longer reserves that key.
PDF read mode never inserts math.

Sequences display with spaces between strokes, such as `alt+m g a`. Add alternatives as
separate shortcuts in the same row. Click a shortcut, then press the keys in its
inline field; successive keypresses form a sequence. Save the change, or click
outside the field or press Escape to cancel. `mod` means Command on Mac and Ctrl
elsewhere; `ctrl` remains
literal Control on Mac. A pending sequence shows its possible next keys.
Escape, changing focus out of the editor, changing preferences, or the timeout
cancels it. An incorrect continuation is consumed without typing into the file.

Overlapping sequences in simultaneously active authoring contexts are rejected,
including a one-key shortcut that would hide a longer sequence. Application
overlaps are contextual: the edit form explains when the document takes priority.
Clipboard, select-all, save, and native undo keys cannot be reassigned to authoring
actions. OS, browser, and native menu reservations cannot be overridden here.

Open **Math input behavior and preset** for the supported LyX-style sequences,
a minimal palette-only authoring preset, backslash command completion,
matrix Enter behavior, and sequence timeout. The timeout also applies to Markdown
and PDF shortcut sequences. These settings do not alter TeX layout.
See [math authoring](./math-in-chat.md#authoring-math).

Use the small **Import**, **Export**, and **Restore defaults** actions at the top of
any document section. These operate on one versioned profile containing the document
sections and the math behavior settings; they do not change General bindings.
Import validates the complete file before asking to replace the current profile.
Legacy math-binding arrays are also accepted; existing legacy storage is retained.
Conflicting or malformed data is reported rather than partially applied. Another
window's newer preferences are not silently overwritten by an older edit form.

## Shortcuts while writing LaTeX

Use the keyboard button beside Write's document tools, or **Source options ?
Keyboard shortcuts**. These open the same settings without leaving the document.
Bindings belong to the local client profile and update mounted editors immediately.
Your imported LyX files are not installed automatically: the built-in preset uses
common LyX-style math sequences and Scient writing actions.

On Windows/Linux, press **Alt+M**, release it, then the remaining keys:

| Keys after Alt+M   | Action                                                |
| ------------------ | ----------------------------------------------------- |
| F / S / R          | Fraction / square root / nth root                     |
| E / X              | Superscript / subscript                               |
| G, A / G, B        | Alpha / beta (other Greek letters are listed in Math) |
| U / I              | Sum / integral                                        |
| L, U / L, I        | Sum / integral with editable limits                   |
| T, M / T, P / T, D | Bracket matrix / parentheses matrix / determinant     |
| T, C / T, A        | Cases / aligned calculation                           |
| O, S / O, C        | Sine / cosine                                         |
| Q, L / Q, G        | Less than or equal / greater than or equal            |
| A, R / A, L        | Right / left arrow                                    |
| W, I / W, D        | Add / remove matrix row                               |
| C, I / C, D        | Add / remove matrix column                            |

Mac also supports Ctrl+M as the sequence prefix. Ctrl/Cmd+M inserts inline math;
Ctrl/Cmd+Shift+M inserts display math. In an existing visual equation, these change
its type. Operating-system reservations still apply. Matrix copy/swap actions remain Markdown math actions.

Write has configurable formatting, heading, list, insertion, and outline
shortcuts. For example, Alt+P then 1/2/3 chooses a section level, and Alt+P
then B/N chooses a bullet/numbered list. The Markdown editor's keys work too:
Ctrl/Cmd+Alt+0 for Text, Ctrl/Cmd+Alt+1/2/3 for the section levels,
Ctrl/Cmd+Shift+8 and 7 for a bullet or numbered list. Ctrl/Cmd+B and I format
text; Ctrl/Cmd+E is inline code and Ctrl/Cmd+K is a link. Inside
a visual equation, math commands operate on the mathematical selection. Table
shortcuts act while a table cell has focus: Alt+T then R,A adds a row, and C,A
adds a column. The matching D sequences remove a row or column while keeping
at least one. Source uses Scient's ordinary file editor shortcuts.

### Your own math actions

In Math, choose **New math action**, give it a name and enter an expression.
`${selection}` wraps the selected math and `${cursor}` marks an editable position;
for example `\frac{${selection}}{${cursor}}`. Save, then record a shortcut on its
row. Use the row menu to edit the expression or delete the action. Restoring the
whole profile also removes custom math actions. Definitions and
package setup belong in the document preamble; custom macros must already exist
in the document. JSON import/export includes custom actions and their shortcuts.

### Printable reference

Choose **PDF reference** to preview the effective shortcuts, grouped by editor and
including application bindings for the selected environment. Formula previews
use bundled fonts and render locally. Unassigned actions are optional. Choose
**Print / save as PDF**, then Save as PDF or Microsoft Print to PDF in the system
print dialog. The reference uses the current profile, including custom bindings;
there is no separate shortcut list to maintain.

## Composer controls

`mod+shift+d` starts dictation in the focused editor, or the composer, and finishes it on the next press;
`Esc` discards the recording. Change the chord under **Composer: Start or Finish
Dictation**, and the hold or toggle behavior in **Settings → Voice**. See
[Voice input](./voice-input.md).

In **Settings → Chat → Send shortcut**, choose whether Enter sends, requires
`mod+Enter` for multiline prompts, or always requires `mod+Enter`. `Shift+Enter`
inserts a new line. This applies to the web and desktop composer at desktop widths.

**Follow-up behavior** chooses Queue or Steer while the agent runs. Use
`mod+Enter` to do the opposite for one message, even when the send shortcut
requires a modifier. `mod+Alt+Enter` sends, keeps that thread running in the
background, and opens a fresh new-thread composer. In a new thread, `mod+Enter`
does the same. Change these shortcuts in **Settings → Shortcuts** under
**Composer: Opposite Queue or Steer Action**, **Composer: Start in Background**,
or **Composer: Send and Start New Thread**. These bindings take priority over the
send shortcut. Click the send button to use the configured follow-up behavior.

When a thread has queued messages, `mod+Shift+Enter` sends the first one as a steer
while a turn is running, or as a new turn when the thread is stopped. Change it under
**Queue: Send First Queued Message** in Keybindings.

Use `mod+shift+m` to choose a model and `mod+shift+h` to choose a host.
To step a new thread to the next machine instead of opening the menu, bind
**Composer: Cycle Host** in Keybindings. It has no default shortcut.
Use `mod+shift+e` for effort, `mod+shift+a` for permissions, `mod+shift+x` for the
workspace, and `mod+shift+g` for the Git branch. The workspace menu includes the
current checkout, a new worktree, and the previous worktree when available.
Use `mod+shift+l` to reuse the previous worktree directly.

To change effort one step without opening the picker, bind
**Composer: Increase Effort** and **Composer: Decrease Effort** in Shortcuts.
Both are unbound by default. Increase wraps from the highest level to the
lowest, and decrease wraps from the lowest level to the highest.

In the model picker, press Left in an empty search field or Shift+Tab to reach
the provider list. Use Up/Down to move and Enter to choose. Right returns to
model search. Right at the end of the search moves to the highlighted model's effort
levels, and Left comes back. Choosing a model keeps the picker open on its effort. `mod+shift+up` and `mod+shift+down` switch providers directly and clear the
search. These provider shortcuts can also be changed in Settings.

These shortcuts run inside the focused web or desktop client. `mod` uses Command
on macOS and Ctrl on Windows and Linux, including GNOME, KDE Plasma, Niri, and
Hyprland. If a custom desktop shortcut takes the same keys, choose another binding
in Settings.

## Copy pull request references

With a PR open in the right panel or on the Pull requests page, use `mod+shift+c`
to copy its URL and `mod+shift+k` to copy its number with a `#` prefix.
Both shortcuts can be changed in Settings. Search for “Copy Link or Thread”
or “Copy Number”. They copy the selected PR and leave terminal input alone.
Without a PR, `mod+shift+c` copies the thread itself, which pastes into a
composer as a thread chip.

## Find in a diff

Click into a diff in the Diff panel or a pull request's Code tab, then press
`mod+f` to search every file in it, including folded files and unchanged lines
hidden between changes. Enter and `Shift+Enter` move between matches, and a
match in a folded file opens it. Escape closes the search. This shortcut is not
configurable. A very large uncommitted diff loads its files as you scroll, and
find only searches the files loaded so far.

## iPad

With a hardware keyboard, use `Cmd+1` through `Cmd+9` to open the first nine
displayed threads. The shortcuts follow the current list filters and order.
`Cmd+K` opens the command palette to search commands, projects, and threads.
Use the arrow keys and Return to choose a result, or `Cmd+1` through `Cmd+9` to
choose directly. Escape or `Cmd+K` closes the palette. Start a search with `>`
to show only actions.

In a new thread, `Cmd+Shift+H` moves the draft to the next machine.

In the composer, Return sends and `Shift+Return` inserts a new line. `Cmd+Return`
also sends. To make Return insert a new line instead, change **Send shortcut** in
Settings → Chat.

Common searchable commands include opening the command palette, creating a
thread, toggling the terminal or right panel, finding a project file, searching
inside project files, refreshing a preview, and running a configured project
action. Project actions use command IDs such as `script.test.run`.

Useful current commands include:

- `filePicker.toggle` (`mod+p`) searches files in the active project;
- `projectSearch.toggle` (`mod+shift+f`) searches inside project files;
- `themeEditor.toggle` (`mod+alt+shift+t`) opens the floating theme editor;
- `thread.settle` (`mod+shift+s`) settles or restores the active thread;
- `thread.pin` (`mod+shift+p`) pins or unpins the active thread;
- `rightPanel.new` (`mod+t`) opens a side-panel tab on the Tools page;
- `rightPanel.nextTab` and `rightPanel.previousTab` (`ctrl+tab`, `ctrl+shift+tab`) move between
  side-panel tabs;
- `rightPanel.toggleFiles` (`mod+alt+e`) shows or hides the file list beside a side-panel tab;
- `rightPanel.duplicateTab` (`mod+shift+d`) opens a second copy of a browser or terminal tab; and
- `rightPanel.toggleMaximized` maximizes or restores the open right panel and has no default shortcut.

Repeating either search shortcut closes it; opening the other replaces the current search. The theme
editor's **Inspect** mode selects one visible element and reveals its color token, then disarms. Use
**Cancel** or `Escape` to leave Inspect and clear its spotlight.

The command palette searches settings, active thread titles, projects, branches, user messages, and
final agent responses across connected environments. A setting result opens its exact control or
section. Message search needs at least one word of three or more letters, or two for Chinese,
Japanese, and Korean, and keeps the matching thread's project, branch, and machine context visible.

## Edit the JSON directly

Use **Open keybindings.json** only when you want advanced control. It opens the
authoritative file for the selected environment. A remote environment therefore
has its own keybinding file; editing one environment does not silently change
another.

The file is a JSON array of rules:

```json
[
  { "key": "mod+g", "command": "terminal.toggle" },
  {
    "key": "mod+shift+g",
    "command": "terminal.new",
    "when": "terminalFocus"
  }
]
```

Each rule has:

- `key`: a shortcut such as `mod+j`, `ctrl+k`, or `cmd+shift+d`;
- `command`: the command ID to run; and
- optional `when`: a condition that limits where the shortcut is active.

`mod` means `Cmd` on macOS and `Ctrl` on Windows and Linux. Other accepted
modifier names include `cmd`, `meta`, `ctrl`, `control`, `shift`,
`alt`, and `option`.

Scient ignores an invalid rule. If the complete JSON file is invalid, it keeps
the app usable with the valid built-in configuration and reports the problem
in the server log.

## Commands

Commands are IDs like `terminal.toggle`, `commandPalette.toggle`, `preview.refresh`, and
`chat.new`. Project scripts are addressable as `script.{id}.run`, for example `script.test.run`.

`filePicker.toggle` opens file search for the active project and defaults to `mod+p`.
`projectSearch.toggle` searches inside the active project's files and defaults to `mod+shift+f`.
Repeating either shortcut closes that search, and switching shortcuts replaces the open search.
`themeEditor.toggle` opens or closes the floating theme editor and defaults to
`mod+alt+shift+t`. Select a color label to spotlight the elements that use it; select the label
again to clear the spotlight. The swatch and hex field keep that color selected while you edit it.
Advanced mode groups related app tokens into a smaller set of color families. Changing a family
updates its paired text and interaction states while leaving every unrelated imported color intact.
Use **Inspect** to pick an element in the app and reveal its color token. Inspect disarms after one
successful pick; its hover glow and badge preview the element and color family that click will select.
**Cancel** or `Escape` exits Inspect and clears its selection and spotlight.

`rightPanel.toggleMaximized` maximizes or restores the open right panel. It has no default shortcut,
so add one in **Settings** → **Shortcuts** if you want to use it.
Available context keys are `terminalFocus`, `terminalOpen`, `previewFocus`,
`previewOpen`, `rightPanelOpen`, `modelPickerOpen`, `usagePageOpen`, `composerFocus`,
`draftThreadRoute`, `turnRunning`, `editableFocus`, `isWeb`, and `isDesktop`.
`rightPanelOpen` applies only to `rightPanel.new` and is true while the right panel is
open; the default `mod+t` uses it to open the panel's new-tab menu.
`draftThreadRoute` is true on a draft thread, including a restored draft, until it is first sent.
`editableFocus` is true while a text field, the composer, or another editor has
the keyboard. `isWeb` is true in a browser tab. `isDesktop` is true in the
desktop app. Unknown keys evaluate to `false`.

`rightPanel.close` closes the active right panel tab and defaults to `mod+w`. Press it again to close
the next tab. With the terminal focused, `mod+w` closes the terminal instead, and with nothing left
to close it closes the desktop window as before. Browsers reserve `mod+w` for closing their own tab
and never pass it to the page, so in a browser rebind this command (and `terminal.close`) to a
shortcut the browser leaves alone, such as `alt+w`.

`rightPanel.new` opens a new tab in the side panel and defaults to `mod+t`. A new tab shows the
**Tools** page, where you choose what the tab becomes. With the panel closed, the shortcut opens it
on a new tab. It does not run while the terminal has focus.
`rightPanel.nextTab` and `rightPanel.previousTab` move to the next or previous side-panel tab,
wrapping at either end. They default to `ctrl+tab` and `ctrl+shift+tab`, which is Control on every
platform, as in Chrome. Browsers keep `ctrl+tab` for their own tabs, so in a browser rebind these
two commands to keys the browser leaves alone. To open a second copy of a browser page or a
terminal, right-click its tab and choose **Duplicate**, or use `rightPanel.duplicateTab`, which
defaults to `mod+shift+d` outside the terminal. In the terminal, `mod+shift+d` still splits it.
While the keyboard is in a side-panel Files or file tab, `navigation.back` and
`navigation.forward` (`mod+[` and `mod+]`) move back and forward in that tab's own history
instead of between threads.
`rightPanel.toggleFiles` shows or hides the project's file list beside the open side-panel tab and
defaults to `mod+alt+e`. It does not run while the terminal has focus.
`mod+1` through `mod+9` jump to the first nine threads, and to models while the
model picker is open. The thread jumps do not run while the model picker is open.
Those defaults use `isDesktop` so they do not steal the
browser's tab-switch shortcuts. Remove that condition in Settings if you want
the same jumps in a browser.

`thread.copyReference` copies the active thread's pull request link, or its thread ID when no pull
request is available. Its default shortcut is `mod+shift+c`, and it does not replace terminal copy
while the terminal has focus.

`thread.settle` settles the active thread or restores it when it is already settled. Its default
shortcut is `mod+shift+s`, and it does not run while the terminal has focus.

`thread.pin` pins the active thread to the pinned section of the sidebar, or unpins it when it is
already pinned. Its default shortcut is `mod+shift+p`, and it does not run while the terminal has
focus. See [Organizing threads](./thread-sidebar.md) for how pinned threads are ordered.

## Find in the current thread

`chat.find` searches conversation messages and proposed plans in the active thread. Entering a
query searches the entire thread, including older messages. Thread search requires server support;
update an older server to enable it. Select **Retry** if a search fails. It defaults to
`mod+f` outside terminals and previews. Press **Enter** or **Shift+Enter** to move between matches,
and **Escape** to close find.

The command palette searches settings, active thread titles, projects, branches, user messages, and
final agent responses across connected environments. A setting result opens its exact control or
section. Message matches show one labeled excerpt while keeping the thread's project, branch, and
machine context visible. Message search finds threads whose messages contain all your words, and
needs at least one word of three or more letters, or two for Chinese, Japanese, and Korean.

The full command list and the current defaults are shown in **Settings** → **Shortcuts**, which
always matches the build you are running. Use that rather than a copied list.

`thread.stop` interrupts the running turn in the focused thread. It has no default
shortcut; assign one in **Settings → Shortcuts**.

`thread.undo` (`mod+z` by default) reverses the actions shown in the notice at the
bottom of the sidebar, such as unpin, settle, snooze, archive, or discarding a
draft. Consecutive
actions of the same kind undo together. The notice remains available for five
seconds after the latest action. Right after an action, the shortcut works even
in a text field such as the composer. Once you type or press another key, the
field gets its own undo back. Terminals always keep their native shortcut.

`navigation.back` (`mod+[` by default) and `navigation.forward` (`mod+]`) move
through the pages you have visited, like a browser's back and forward buttons.

`chat.new` opens the **New thread in…** picker, including **No project** when the
current machine offers scratch conversations, and **Add project**.
`chat.newLocal` skips that chooser. Both use your
[new-thread defaults](./thread-sidebar.md#start-a-thread).

Note that `chat.new` and `chat.newLocal` both create a thread through the same path. A new thread
inherits the project you were in, along with model and mode selections. Branch, worktree, and
environment mode always come from your configured defaults, not from the thread you were looking
at. To keep a worktree, use the explicit "new thread in this worktree" action in the branch
toolbar. With Scient's sidebar, `chat.new` always opens the chooser, even with no projects;
`chat.newLocal` goes directly to the current project.

`chat.newWithoutProject` (`mod+alt+n` by default) opens a scratch conversation on the
current machine when available. It uses the same flow as **No project** in the picker.

Background submission from a new thread is the exception. `mod+enter` starts that thread and opens
another new thread with the same workspace mode and base branch. **New worktree** remains selected,
but the new thread does not reuse the worktree created for the thread that just started.

In the desktop app, `mod+w` closes the focused terminal or the active right-panel
tab. When nothing remains to close, it does nothing; it never closes the window. In a browser, `mod+w`
closes the browser tab; rebind `rightPanel.close` and `terminal.close` to an available
shortcut such as `alt+w`.

`mod+shift+t` reopens the last closed tab across the app, including files,
diffs, pull requests, browsers, and devices, in the order you closed them.
A browser opens in a fresh session without its old page history. Incognito tabs
can reopen until you reload or quit the app. This shortcut does not undo deleted work.
Browsers also use it to reopen browser tabs; choose another binding in Settings
if the browser takes it first.

Many defaults include `!terminalFocus` so they do not intercept terminal input.
Keep that condition when remapping them if you want the same behavior.

## `when` Conditions

A `when` expression is evaluated against context keys describing the current UI state. The keys
the app supplies today are `terminalFocus`, `terminalOpen`, `previewFocus`, `previewOpen`,
`modelPickerOpen`, `isWeb`, and `isDesktop`. `isWeb` is true in a browser tab and `isDesktop` is
true in the desktop app. The set is open and grows over time, so treat that as the current list
rather than a fixed one. Any key the running app does not supply evaluates to `false`.

`mod+1` through `mod+9` jump to the first nine threads, and to models while the model picker is
open. Those defaults use `isDesktop` so they do not steal the browser's tab-switch shortcuts.
Remove that condition in Settings if you want the same jumps in a browser.

Operators: `!` (not), `&&` (and), `||` (or), and parentheses.

Examples:

- `"when": "terminalFocus"`
- `"when": "terminalOpen && !terminalFocus"`
- `"when": "!terminalFocus"`

Rules are evaluated in array order. For a key press, the last matching rule
whose condition is true wins, even when an earlier rule belongs to a different
command. Use the conflict warnings in **Settings → Shortcuts** to check the
result after editing the JSON.