Terminal

The built-in terminal, available as a tab in Panes A and B and as a view in the nav pane. It starts in the current folder, and Claude Code is one button away.

What you can do

To do this	Do this
Use a terminal in Pane A or B	The terminal button to the right of "+" on the tab bar
Use a terminal in the nav pane	Place the terminal view in the nav pane (up to four, left/right and top/bottom)
Go to the folder shown in a pane / open the terminal's location in a pane	"Folder" in the action bar
Start Claude Code	"Claude" or "Skip" in the action bar
Pass the selected files' paths	Right-click in the file list → "More actions ▶" (see Sending the Selection to the Terminal or Claude Code)

The shell is Command Prompt (cmd.exe). It starts in the current folder and works in UTF-8.

How to use it

• Terminal Tabs (A/B Pane): Click the SquareTerminal icon in the file list tab bar to add a terminal (cmd) tab within A/B panes. The same button is also in the "Pane A" and "Pane B" headings of the nav pane's "Tab Management" view (showing Tab Management hides the tab bar itself).

  Launches with the currently displayed folder as the working directory, enabling seamless switching between file-browser tabs and terminal tabs. Multiple terminal tabs can be open simultaneously and work with working sets.

• Terminal View (Nav Pane): Displays an embedded terminal (cmd) in the nav pane. You can directly execute CLI tools (Claude Code, etc.) using the folder currently viewed in the A/B pane as the working directory.

• Up to four at once: Nav-pane terminals are independent per slot. You can place one above and one below in each of the left and right nav panes — four in total, or six counting the terminal tabs in the A and B panes.
  • How: open the cross-shaped layout screen (Setting all four nav-pane slots at once (the cross-shaped layout window)) from the ∨ button at the end of an icon bar, pick "Terminal" for the top left, "Terminal 2" for the bottom left, "Terminal" for the top right and "Terminal 2" for the bottom right, then press Apply. All four are set in one pass.
  • The two entries exist purely so you can stack them; they are otherwise identical, and either can go in either slot.
  • Choosing a terminal in the right nav pane does not remove the one on the left. Every other view still moves (disappearing from wherever it was) as before.
  • Each is a fully independent session, and the Claude Code usage readout shows that slot's own figures.
  • Nav pane terminals always share one set of settings (font, colours, scrollback and so on). Terminals in Panes A and B can have their own when "Sync all terminals" is turned off (see below).
• Tab management: Manage multiple terminal sessions via the tab bar at the top. Use the "+" button to add a new tab, and the "X" button on each tab to terminate the session. Each tab has an independent cmd process.
• Keyboard focus: a nav pane terminal appearing does not move your typing into it; focus follows only when you add a tab or click one yourself. A terminal tab in Pane A or B takes focus when it opens (including when a tab restored at startup finishes connecting).
• Full-featured terminal: Uses the same rendering engine as the A/B panes (WebView2 + xterm.js), supporting ANSI colors, mouse operations, copy/paste, scrollback (5000 lines by default, configurable), URL clicking, and more.
• Terminal Common Features (All Panes):

• Action bar (the buttons along the bottom): The commands are gathered into five groups. Every button only opens a menu — nothing runs until you pick an item from it, so hitting the wrong button never runs a command you did not intend.

  Button	Contents
  Folder	cd to a folder open in pane A or B / open the current location in pane A or B
  Claude	Launch Claude Code in the current folder / pick a folder you have launched it in before
  Skip	The same, with --dangerously-skip-permissions
  History	Command history (Ctrl+R) / Claude prompt history
  Run	dotnet run / dotnet publish -c Release (nav pane only) / clear the screen
  Options	Show the usage meter / Enter for a newline / key reference / terminal settings

  • Folder pickers show the full path dimmed to the right of each folder name, so a run of similar names is never ambiguous. In the Claude and Skip menus, the first entry, "Launch in the current folder", carries a "Current" badge
  • The first nine entries can be picked with the number keys 1–9, so once the menu is open there is nothing to aim at
  • While either option toggle (usage meter, Enter for a newline) is on, the Options button's icon turns the accent colour, so you can see it is lit without opening the menu
  • Key reference: Keys that act while the terminal has focus. Anything not listed here is passed straight through to the shell (Command Prompt). See the entries below for details on each feature. The same list is available at any time from Options → "Show the key reference" in the action bar.

  Key	Action	Conditions / notes
  →	Accept the inline suggestion	Only while a suggestion is showing and the cursor is at the end of the line; otherwise passed to the shell
  Ctrl+R	Open the command history	Only at the shell prompt; goes to the tool itself while vi or a CLI tool is running
  Ctrl+↑ / Ctrl+↓	Jump between commands	Passed to the shell when no command markers exist
  Ctrl+C	Copy when text was freshly selected / interrupt (^C) otherwise	When "Copy and paste with Ctrl+C / Ctrl+V" is on (the default)
  Ctrl+V	Paste	Same as above; passed through to full-screen apps such as vi
  Ctrl+Shift+C / Ctrl+Shift+V	Copy / paste	Always available, even with the setting above turned off
  Ctrl+F	Search within the terminal	Enter for next, Shift+Enter for previous, Esc to close
  Esc	Close search, history, or the paste confirmation	Passed to the shell when none of them is open
  ↑ / ↓ / F7	Command Prompt's own history (doskey)	The app does nothing with these

  Note that pressing End does nothing (the app stops it on arrival). cmd's own "move to end of line" has never worked in this terminal either. Use → to move to the end of the line. - Moving to a folder open in pane A or B (Folder group): All terminals (A/B pane and nav pane) have a "Folder" button in the action bar. Pressing it lists the folder tabs open in pane A and pane B in one menu, under a heading for each pane; picking one instantly cds to it. Leveraging the dual-pane file manager design, any terminal can access folders from both panes. - Launching Claude Code (Claude / Skip buttons): Pressing "Claude" opens a menu for choosing where to launch. The first entry launches in the current folder; below it are all the folders you have started Claude Code in. Picking one changes to that folder and launches Claude Code (it runs cd /d "path" && claude as a single line, so it also leaves a single entry in the command history). - The target folder is always chosen from the menu. The button alone never launches anything, so a mis-click cannot start Claude Code in a folder you did not intend - Entries are ordered most recently used first, up to 15 of them. Each shows the full path to the right of the folder name, so a run of similar names is never ambiguous, and the first nine can be picked with the number keys 1–9 - The list comes from Claude Code's own records (~/.claude.json), so sessions you started in a terminal outside this app are included too. Folders that no longer exist are left out - The folder you are currently in is omitted from the list below, since the first entry already covers it - If you have never started Claude Code, the menu reads "No workspaces yet" - The skip-permissions launcher is the "Skip" button next to it. The menu is identical; the only difference is that the launch adds --dangerously-skip-permissions - Claude prompt history (History group): "History" → "Claude prompt history" lists the prompts you have sent to Claude Code, newest first, each with its date and time. Picking one does not send it — it drops the text into the terminal's input so you can adjust the wording first. - Entries read 08/02 01:53 the start of the prompt…. Hovering shows the full text and the folder you were working in at the time - The list is read from Claude Code's own conversation logs (under ~/.claude/projects). That means prompts you typed in a terminal outside this app are included, and they survive a reinstall. The app does not keep a separate record of its own - Only lines you typed yourself are picked up. Tool results, hook output, sub-agent internal exchanges and task notifications never appear in the list - Identical wording is collapsed to its most recent entry, and the 30 most recent are shown - If you drop a prompt into a terminal where Claude Code is not running (a plain Command Prompt), a prompt containing newlines goes through the "confirm multi-line paste" step, because there a newline means execution. Dropping into Claude Code's input skips the confirmation, since a newline there is not execution - Opening session logs (History group): The "Session logs" group at the bottom of the "History" menu opens the logs collecting in data\logs\terminal\ directly, with no need to walk the path by hand. - Open log folder: a submenu of four destinations — the opposite pane (pane B if the terminal sits in pane A, pane A if it sits in B), pane A, pane B, and Explorer. Pick the opposite pane and the logs line up without displacing the terminal you are looking at - Choosing pane B while in single-pane view widens to two panes first. In a pane with no folder tab (only terminal tabs) it opens as a new tab - Terminals in the nav pane do not offer "the opposite pane", because the nav pane belongs to neither pane A nor pane B, so there is nothing for it to be opposite to - Open the current terminal log / Open the current Claude Code log: opens the running session's screen log (.log) or Claude Code conversation log (.md) in the associated application - While nothing has been recorded yet the entries are disabled, with the reason in a tooltip. The screen log is written within 15 seconds of the first output; the Claude Code conversation log is created once the usage-meter mechanism is registered and the first response comes back (see "Session logs" below) - Opening the current location in a pane (Folder group): "Folder" → "Open the current location in pane A" (or B) opens the terminal's current working directory in a folder tab of that pane — the reverse of the cd entries above. If that pane currently has a terminal tab selected, the folder tab you were on most recently is the one that moves. - Notice when a pane moves: Whenever a pane actually moves — whether by following or by the buttons — a cyan line such as Moved to "C:\..." in pane B appears in the blank line below the command. Long paths are elided from the front so the line always fits the width. If that line already holds command output, the notice is skipped rather than overwriting it, and is shown briefly overlaid on the terminal instead. - Follow target for cd: Pick A or B (the default is "Don't follow") and that pane follows every cd without pressing a button. The target is shared by all terminals. Working in a terminal in pane A while pane B follows is the setup worth recommending, because the moves stay visible — if you point the target at the terminal's own pane, that pane is showing the terminal, so the folder tab moves behind it and nothing appears to change. Moves caused by following are not pushed onto the back/forward history, so that history does not fill up with every cd. Moves from "Open the current location in pane A/B" are explicit actions and are recorded in the history. - Click a path to open it in a pane: Paths printed on screen are underlined when they actually exist, and a single click shows them in pane A or B — no selecting, copying and pasting into the address bar. - Click opens pane A, Ctrl+click opens pane B. Hovering shows the resolved full path and this hint in a tooltip. - Shift+click is deliberately not used: the terminal needs Shift for selecting text, which is the only way to select inside a full-screen app such as Claude Code. - Relative paths work too (src\Foo.cs, ..\other), resolved against that terminal's current directory — so they keep working after you cd. - Line-number forms such as Services/Foo.cs:123 (Claude Code, compilers) are recognised as just the path part. Surrounding brackets and punctuation are excluded from the link too. - A path pointing at a file opens its parent folder with that file selected. - Only paths that exist are underlined. Verification runs asynchronously and only for the line under the cursor, so it never stalls the terminal — including on cloud storage folders. - Paths containing spaces are recognised when quoted, as in "C:\Program Files\...". URLs still open in the browser on click as before. - Copy & paste: right-click copies the selection (and clears it) if there is one, or pastes otherwise, the same as Windows Terminal. Ctrl+Shift+C / Ctrl+Shift+V also work. A selection only counts if it was made after the last output on screen, or within the last 5 seconds; with an older selection still showing, right-click pastes and Ctrl+C interrupts. - Ctrl+C / Ctrl+V: When "Copy and paste with Ctrl+C / Ctrl+V" is on (the default), the plain Ctrl+C and Ctrl+V also work as copy and paste. Ctrl+C only copies when text is selected; with nothing selected it still sends the interrupt (^C) to the running command, so interrupting keeps working. Even with an old selection still showing, interrupting works (see "Copy & paste" above). In full-screen apps such as vi, Ctrl+V is passed through to the app. - Command history (Ctrl+R): Commands you run are recorded and kept across restarts, in a single history shared by every tab and pane. Press Ctrl+R — or History → "Command history" in the action bar — to open the list: type to filter, use ↑↓ to select, press Enter to run, Shift+Enter to insert it at the prompt without running, and Esc to close. Up to 1000 entries are kept, and repeating a command moves the existing entry to the top rather than duplicating it. The ↑↓ keys themselves are unchanged, so Command Prompt's own history (doskey) and F7 work exactly as before. - The history is stored as plain text in terminal_history.json in the data folder. If you would rather not keep commands that contain passwords or similar, turn off "Record command history" in the settings or wipe it with the "Clear history" button. - Command colorization: The prompt and the command you are typing are colored by syntax (on by default). Colored parts take priority over the "Foreground" setting. The coloring follows your keystrokes and stays in place after you press Enter. It is suspended while an IME conversion is in progress (so the text being composed is never disturbed) and does not run inside full-screen apps such as vi.

  Element	Color
  Current path in the prompt	bright blue
  > in the prompt	gray
  Built-in commands (cd, dir, set, …)	bright yellow
  External commands (git, dotnet, …)	bright green
  Subcommands (status in git status)	bright cyan
  & && \| \|\| > >> <	bright magenta
  "..."	cyan
  %PATH% / the name in set NAME=	magenta
  /w --force -x	gray
  Paths (C:\dir\file, ..\foo)	bright blue
  Numbers	yellow
  Other arguments	your configured foreground color
  - Error messages in red: While "Colorize commands as you type" is on, output lines that look like errors are shown in red. A mistyped command name ("… is not recognized as …") is detected reliably. Everything else — "Access is denied" and friends — is matched against a list of known error phrasings, so a log file containing the same wording can also come out red. Note that Command Prompt cannot report a command's exit code to the terminal, so coloring every failed command's output red is not possible in principle.
  - Inline suggestions while typing: A past command that starts with what you have typed is shown dimmed as the rest of the line (on by default). Press → while the cursor is at the end of the line to accept it. When no suggestion is showing, → is passed through to Command Prompt as usual (where it pulls one character from the previous command). Suggestions are hidden during IME composition, while text is selected, while scrolled, and when the cursor is in the middle of the line. They are drawn on top of the terminal rather than written into it, so they never end up in copied text or the scrollback.
  - Confirmation for multi-line pastes: Pasting text that contains line breaks asks for confirmation first (on by default), because Command Prompt runs each line break as a command. The dialog shows the line count and a preview of the first three lines; "Don't ask again" skips it from then on (and updates the setting). Lines that are actually executed by the paste are added to the command history.
  - Pasting an image (converted to a file path): When the clipboard holds an image but no text, a paste (Ctrl+V / Ctrl+Shift+V / right-click) saves that image as a PNG and pastes the quoted path to that file instead. Claude Code running in a terminal cannot take an image directly, but it can read one from a path. Snip the screen with Win + Shift + S and paste straight away.
  - Files go to the Windows temporary folder (%TEMP%\ZenithFiler_TerminalPaste), named paste_<date>_<time>.png. Anything older than seven days is deleted automatically — enough of a window to refer back to the same image later in a conversation
  - If the clipboard holds text, the text is pasted as before, even when an image is present alongside it
  - Jump between commands (Ctrl+↑ / Ctrl+↓): Move through long output one command at a time. When there is nothing to jump to, the keys are passed through to the shell as usual.
  - Marks at the start of each command: Turn this on (off by default) to get a thin bar at the left edge of the line where you typed each command, with a matching tick in the scrollbar. Only a mistyped command is marked in red. The terminal has no gutter, so the bar overlaps the first character of the prompt; since the prompt colorization already shows you where a command line is, the marks are off by default. Turn them on when you want an overview of command positions in the scrollbar. Note that Command Prompt does not expose a command's exit code, so unlike VS Code the marks cannot be colored by success or failure.
  - Pin the command to the top while scrolling: Turn this on (off by default) and, while you are scrolled into the middle of some output, the line holding the command that produced it stays pinned at the top. Click it to jump back to that position.
  - Search (Ctrl+F): Press Ctrl+F inside a terminal to open a search box in the top-right corner. Enter moves to the next match, Shift+Enter to the previous, with a match-count indicator. Press Esc to close it.
  - Show backslash as ￥: Turn this on to render a path such as C:\work with the yen-sign glyph, as C:￥work (off by default). Only the appearance changes, not the character, so copying the text and pasting it elsewhere gives you a normal \. The glyph comes from a Japanese font (MS Gothic and friends); on systems without one, backslashes keep rendering as \.
  - Per-pane settings: choose Options → "Terminal settings" in the action bar to open the settings window. With "Sync all terminals" off, terminals in Panes A and B can each have their own font, font size, background, foreground and theme sync (copy-on-select and scrollback lines are always shared). Nav pane terminals always use the shared settings. The color picker previews changes live.
  - Confirming/discarding settings: changes in the settings window are not saved right away. OK confirms them and Cancel returns to how things were when you opened it (the preview still updates as you edit). Closing the window with × confirms, the same as OK.
  - Copy on select: Turn on "Copy on select" in the settings popup to automatically copy text to the clipboard the moment you select it (off by default).
  - Font: The "Font" list in the settings popup offers every font installed on your system, split into two groups: "Monospace (recommended)" at the top and "All fonts" below. The default is Consolas, the same font VS Code uses on Windows out of the box. With the dropdown open, typing the first letters of a name jumps to it. Note that a proportional font makes columns fail to line up, so the monospace group at the top is normally the better choice.
  - Scrollback lines: Choose how many lines to retain — 1000/5000/10000/50000 — in the settings popup (default 5000).
  - Session logs: Terminal activity is recorded automatically to data\logs\terminal\. No setting is needed — it is always on.
  - How to open them: "History" → "Session logs" opens the log folder in a pane of your choice, or opens the running session's .log / .md directly (see "Opening session logs (History group)" above).
  - Screen log (.log): Records what was actually shown on screen. It is appended when a tab closes, when the shell exits, every 15 seconds, and written up to the moment you quit the app. The file name is "date and time plus the folder the terminal was started in". Nothing is written while the terminal is visible, so this has no effect on terminal speed. If older output was lost because the scrollback limit was reached, that is noted at the top of the log. For a full-screen, interactive app like Claude Code, this record will not contain the conversation (see below) — use it as a record of ordinary command-line activity instead.
  - Claude Code conversation log (.md): While you're using Claude Code in the terminal, the conversation is recorded automatically as Markdown. Unlike the screen log, this cannot come from the screen buffer — Claude Code works by redrawing only "the current screen", a mode the screen log has no way to capture text from. Instead, the Markdown is built directly from the record Claude Code itself keeps of the conversation. Your messages and Claude's response text are kept in full; actions such as running a command or editing a file are recorded as a one-line summary, like > Bash: git status (the results of those actions are not included). Each of your messages gets its own heading, making it easy to read back and searchable with Grep from inside the app. The file name follows the same convention as the screen log with _claude_ and part of the session ID appended, and the extension is .md. This works regardless of whether the usage meter is displayed — all it needs is the usage meter's underlying mechanism (the statusLine hook in ~/.claude/settings.json) to be registered. Claude Code used outside Zenith Filer (in VS Code or Windows Terminal, for instance) is not covered.
  - Retention: Both the screen log and the conversation log are deleted automatically after 30 days.
  - Options shared by all terminals: "Record command history", "Copy and paste with Ctrl+C / Ctrl+V", "Show inline suggestions while typing", "Confirm before pasting multiple lines", "Show backslash as ￥", and "Follow target for cd" apply to every terminal rather than per pane — regardless of the "Sync all terminals" checkbox.
  - Sync all terminals: the "Sync all terminals" checkbox in the settings window switches the terminals in Panes A and B between one shared set of settings and separate settings per pane. It is on (shared) by default.
  - Theme integration: Enable "Sync with theme" to automatically match terminal colors with the app theme. When disabled, custom colors are preserved.
  - Claude Code usage: When you are running Claude Code in the terminal, the current model, context usage and how much of the 5-hour and weekly windows you have spent are shown on a single line just above the action bar: Opus 5 │ ctx ■□□□□□□□□□ 8% │ 5h ■□□□□□□□□□ 6% (2h33m left) │ 7d ■■□□□□□□□□ 21% (2d3h left). The bar and the figure shift from gradually from green through amber to red (blended around 0%, 50% and 100%), and hovering shows the exact reset times along with when the reading was last updated.

  The line is drawn by the app rather than as terminal text, so the bar characters stay crisp whatever font you have chosen. It appears the same way in the nav pane and in the A/B pane terminals.

  Each terminal reports on itself. Run Fable in the A pane, Opus in the B pane and Sonnet in the nav pane, and each terminal shows the figures of the Claude Code session running in that terminal. Switching tabs switches the reading with it, and closing a terminal removes its line. A Claude Code session started outside ZenithFiler (in Command Prompt, Windows Terminal, …) belongs to no terminal here and is therefore not shown.

  • Turning it on: press Options → "Show the usage meter" in the action bar once. If the hook is not registered yet, that same press registers it. Registering means adding a small relay program, shipped with the app, as the statusLine entry in Claude Code's config file (~/.claude/settings.json). There is no separate tool to install. Backups of the original file are made first (settings.json.zenithfiler.bak, plus settings.json.zenithfiler.orig.bak the first time). The "Register hook" button under "Claude Code usage" in the settings popup does the same thing.
  • The entry in the Options menu: while the readout is on, the entry shows ON at its right edge and the Options button's icon turns the accent colour. Pressing it again stops the readout but leaves the hook registered, so the figures come straight back the next time you press it. To remove the hook entirely, use "Unregister hook" in the settings popup. Registering or unregistering from the settings keeps this display in sync.
  • What each figure means: the values are exactly what Claude Code reports, and they line up with the "Usage" tab of /status as follows.

  Shown	Row in /status	Meaning
  ctx	context usage	How much of the context window the current conversation occupies (counted from input tokens only)
  5h	Current session	Consumption of the rolling 5-hour window
  7d	Current week (all models)	Consumption of the weekly window across all models

  The per-model weekly windows that /status also lists ("Current week (Fable)" and the like) are not sent over this channel, so they cannot be shown. 5h and 7d are only reported on a Claude subscription (Pro / Max). - When it takes effect: registration applies from the next terminal you open. The per-terminal identifier is handed over when the terminal starts, so terminals already open will not show anything — open a new terminal tab, or restart the app. - How it fills in: right after you launch claude, Claude Code only reports the model, so the line reads the model name plus "usage appears after your first message". Exchange one message and 5h and 7d join it; ctx follows once the conversation actually starts consuming context. If nothing appears at all, either the hook is not registered or Claude Code is not running in that terminal. - If you already have your own status line: it keeps working. The app stores your original command, calls it, and passes its output straight back to Claude Code, so what you see in the terminal does not change (except while this meter is on screen inside the app, where relaying is stopped — see below). - The numbers never double up, and the freed-up line becomes a cumulative-work meter: while this meter is on screen, the line Claude Code prints in the terminal is replaced with something the app's meter does not show. Claude Code always reserves that line while a status line is configured, so printing nothing would leave an empty row rather than closing the gap. What goes there instead is the total tokens used since this session began, as a single gauge (Work ■■■■■□□□□□ 2.5M tok). The meter stretches to the full width of the terminal and the gauge runs as a left-to-right gradient, so how far along you are reads from both length and hue; resizing the window or the pane redraws it on the next turn. No text is ever cut off — the width is worked out so the line cannot wrap, and where space runs short the padding, then the label, then the unit are dropped so the figure survives. The gauge is scaled so that a full five-hour budget's worth of work reads as exactly 75% (going past the budget still leaves headroom, so it never pins). It grows logarithmically, so it starts moving in the tens of thousands of tokens and never goes backwards (for reference: 9% at 17k, 47% at 1M, 66% at 4.2M). How many tokens a five-hour budget amounts to is learned automatically from the growth in the rate-limit percentage against the growth in tokens, since a percentage costs very different numbers of tokens from one model to another. Unlike the usage figures (ctx / 5h / 7d) it never goes down, so you can watch the work pile up. The gauge's full mark steps up as you pass it — 100k, 250k, 500k, 1M, 2.5M and so on — so it never sits pinned at full. Tokens spent re-reading the same content (cache reads) are not counted, since those would grow to drown out the work actually added. If you have your own status line configured, relaying it stops inside the app too. This replacement applies only inside Zenith Filer's terminal — Claude Code used outside the app, in VS Code for instance, is unaffected. To get Claude Code's own line back inside the app as well, turn "Show usage meter" off. - Turning it off: the same button ("Unregister hook") writes your original setting back. If you had none, the statusLine entry is removed entirely. - If you move the app folder: the registered path no longer matches, and the status reads "Path changed. Please re-register". Pressing "Re-register hook" fixes it. - Hiding the line: press Options → "Show the usage meter" again, or clear "Show usage widget", to stop displaying it while leaving the hook registered. The line also hides itself automatically once the last reading is more than 24 hours old. - Gauge length: the gauges stretch to fill whatever width is left on the line, so the wider the pane or window, the longer they get and the easier they are to read as a scale (where there is not enough room they fall back to the default length). A faint outline runs around each gauge so you can see where the 100% mark sits. - On a system without Claude Code installed (no ~/.claude), the status reads "Claude Code not found" and the button is disabled. - Entrance animation: when the gauges appear they sweep all the way up and settle back to the real figure, like a car's speedometer at ignition, with each of the three starting a beat after the last. With Windows animation effects turned off (Settings > Accessibility > Visual effects), or in lightweight mode, the sweep is skipped and the final values show immediately — the app respects the OS setting throughout. - Gauge design: eight to choose from. Besides the default blocks (■■■□□□□□□□) there are fine blocks that render each cell in eight steps, dots, diamonds, arrows and more. Braille splits every cell into two columns, giving twice the resolution in the same width. The settings list shows a live preview of each. - Gauge colors: four to choose from.

  Scheme	What it does
  By usage (default)	Shifts green → amber → red continuously as it approaches 100%, so you can see the danger zone coming rather than crossing fixed steps
  Gradient	Runs between two colours derived from the theme's accent colour, left to right. Colour reaches the right-hand end even at low usage, so it reads like a dial. The cumulative-work meter on Claude Code's status line uses the same colours
  Rainbow	Hues spread evenly for a rainbow-leaning look
  Theme color	The app theme's accent colour in varying brightness — the closest fit to whichever theme you use

  • Reset time format: choose "time left" ((2h33m left), the default) or "clock time" ((00:29), or (8/3 20:00) when it falls on another day).
  • Enter for a newline, Ctrl+Enter to send: Writing a longer instruction for Claude Code, Enter sends by default, so reaching for a line break can fire off a half-written message. Turn this setting on (off by default) and Enter inserts a newline while Ctrl+Enter sends. Options → "Enter inserts a newline (Claude Code)" in the action bar does the same thing; while it is on the entry shows ON and the Options button's icon turns the accent colour.
  • The swap applies only while Claude Code is running. At the Command Prompt Enter still runs the command as always, so you can never end up unable to type a command
  • The swap is suspended while a list of choices is on screen. For a confirmation like "Do you want to proceed? 1. Yes / 2. No", model selection, @ file suggestions and anywhere else Claude Code asks you to pick, Enter confirms as usual — reaching for Ctrl+Enter on every confirmation is more of a nuisance than it is while typing
  • The swap is also suspended while you are typing a slash command. When the input is just a command such as /status, Enter runs it. There is never a reason to break a command across lines, so this holds even after the suggestion list has narrowed away. Ordinary text that happens to start with a slash, such as /path/to/file — take a look, is not affected and still takes a newline
  • The check runs only at the moment you press Enter and looks at the cursor's line and below it. The conversation above is never scanned, so stray symbols in the output cannot trigger it, and typing stays as responsive as before
  • Detection uses both "was claude launched from the prompt" and "is that CLI presenting its own input box". Chained launches such as cd /d "path" && claude count too, as do launches from the Claude or Skip menus in the action bar
  • Alt+Enter (Claude Code's own newline key) keeps working regardless of this setting
  • This setting is shared by all terminals

How it works

What a terminal is made of

• Each tab runs one helper program (conpty_host.exe), which runs Command Prompt through Windows' pseudo console (ConPTY). Running Command Prompt straight from the app lost its output on some Windows 11 builds, hence the extra step in between.
• Command Prompt is switched to UTF-8 with chcp 65001 before it starts. The bundled, newer pseudo console (from node-pty) is used first, with Windows' built-in one as the fallback.
• The screen is drawn by xterm.js inside WebView2, on the GPU (WebGL) when available and with ordinary drawing otherwise. WebView2 is prepared while the app is idle, so even the first terminal opens quickly.
• The shell gets TERM=xterm-256color and similar settings so colour output works. Variables starting with CLAUDE in the environment the app was started from are removed, so a Claude Code session outside the app doesn't leak in.

How the current folder is tracked

• Invisible markers are embedded in the prompt, so Command Prompt reports the current folder every time it shows a prompt. The first report is only kept as a starting point; the app acts only when the folder changes.
• When you type cd with an absolute path, the destination is also read from what you typed (only if that folder exists).
• With a pane chosen in "Follow target for cd", that pane follows your moves in the terminal. Those moves are not added to the pane's Back history (opening a folder with the action bar button is).

How long a terminal lives

• A nav pane terminal is created the first time its slot is shown (left/right × Terminal/Terminal 2, up to four). Switching to another view does not end it; the session lasts until the app exits. Nav pane terminals do not come back the next time the app starts.
• A terminal tab in Pane A or B starts afresh the next time the app starts, in the folder it was opened in (not the last folder you cd'd to). Terminal tabs are exempt from the six-tab view cache (see Tabs) and are always kept.
• On closing, the helper program is told to exit; if it hasn't after 0.5 seconds, it is stopped along with everything running under it.

Keys

• While you are typing in a terminal, input to the terminal takes priority over the app's shortcut keys (browser keys are disabled too, so Ctrl + R doesn't reload the page).
• The End key would take focus away from WebView2, so the app catches it and passes it on to the terminal.

Related

• Sending the Selection to the Terminal or Claude Code — pass the selected files' paths to the terminal
• Nav Pane — choose which slot shows the terminal view
• Tabs — open a terminal tab