Command Terminal

The Command Terminal gives you instant access to your default agent without creating a task on the board. Use it for one-off actions like creating releases, running queries, or any ad-hoc interaction that doesn’t need to be tracked as a task.

Opening the Command Terminal

Press Ctrl+Shift+P / Cmd+Shift+P, or click the terminal icon in the title bar (the left-most icon in the row on its right-hand side). The same icon toggles the layer closed again, so there is always a one-click way to hide it, even when a window is maximized. The icon’s border reflects activity across your open terminals: it marches green while an agent is working, holds a steady amber when one needs your input, and stays plain when everything is idle. That border covers the current project’s terminals; the plain activity icon beside it opens the Agent Monitor, where sessions from every project appear.

A window opens over a slight backdrop blur, with an agent session running at your project root on the project’s default agent. A fresh terminal also launches on the project’s default model and effort, so it starts on your preferred combination instead of the CLI’s own default.

How it works

The Command Terminal spawns a transient session - a lightweight agent process that is fully independent of your board tasks:

Runs at the project root on the configured default base branch
Before spawning, Kangentic runs git fetch and fast-forwards the base branch so the session starts against the latest remote state
If the checkout sits on another branch with uncommitted changes to tracked files, a fresh terminal stays on that branch and a toast says so, rather than carrying your work onto the base. Reopening the layer is different again: it reattaches to the running sessions and never fetches or checks anything out
Does not appear in the bottom panel’s terminal tabs
Counts toward the concurrent session limit like any task agent: when agent.maxConcurrentSessions (default 8) is already full, a new Command Terminal waits in the queue for a slot
Produces no toast notifications when it exits or goes idle: a shell back at its prompt is not an agent waiting on you, and there is no task for the toast’s Open button to open
Preserved across project switches - switch to another project and back, and the terminal is still running. Each project keeps its own terminals, so you can leave ad-hoc work going as you move between projects
Non-resumable by design - stopping a terminal ends its session permanently

A shimmer overlay shows while the agent CLI initializes, then lifts to reveal the clean TUI. An idle indicator appears when the session is waiting for input. The Command Terminal session is included in the focused-session set for live PTY data, and idle notifications clearly label it as a Command Terminal session.

Your first prompt names the terminal. The name comes from the Automation agent you choose in Settings > Workflows, on its own model and effort, and only Claude Code and Kimi terminals report the prompt text it needs. With no Automation agent set, naming is off and the window keeps its Command Terminal N title. Each naming call is recorded as a background call. See Auto-Naming.

You can also open the Changes panel from the Command Terminal window to review the diff against the base branch while working. Each terminal window owns its own Changes-panel state, so two side-by-side terminals can have different files and scopes open at once. It is the Uncommitted view only: with no task behind it there is no History section and no single-file diff windows, since both need a task to scope themselves to. Its ahead/behind counts and its Branch scope measure against the project’s default base branch, the same base a fresh terminal spawns on.

Window behaviors

The Command Terminal is a real window, not a fixed overlay. You can:

Drag it by the header and resize it from any edge or corner
Maximize / restore it - double-click the header, click the maximize button, or press Ctrl+Shift+M / Cmd+Shift+M. Maximized, it fills the area between the title bar and status bar so controls and live stats stay reachable
Snap it to a screen half or full screen

The layout (size, position, and maximized state) persists globally across every project and app restart, so the terminal always reopens where you left it.

Multiple terminals

Run up to four Command Terminals at once per project, counting any a paired phone started. While the layer is open, a separate New terminal button (a second terminal icon with a + in its center) appears in the title bar just to the left of the main terminal icon - click it to open another terminal. It disables once you hit the four-terminal cap, and it stays plain during agent activity (only the main toggle icon carries the activity border). Each window titles itself Command Terminal N from a durable slot, so a sibling opening or closing never renumbers it; with an Automation agent set up, your first prompt then replaces the number with a real title. Each terminal also appears as a row in the Agent Monitor under the same title, with its branch as the eyebrow and a live output peek, and every sidebar project row carries a terminal glyph with a count and activity tone for its open Command Terminals - see Multiple projects.

New terminals tile into the current window’s footprint, side by side, so you can keep two or more ad-hoc tasks cooking and glance between them
Drag the seam between tiled terminals to rebalance them
Drag a terminal by its header to dock it. Wherever the cursor goes decides what happens: run it into the left, right, or bottom edge of the board area to snap that half, into the top edge to maximize, or over another window to tile beside it. Press Escape mid-drag to abandon it, and the window returns to where it started. See Docking and pop-out windows
When a terminal is tiled, a pop-out button floats it back out of the tile group
As a window narrows, the quick-action pills (Project, Changes, the branch picker, shortcuts) fold into a ... menu so the title always keeps its space. Commands has no pill of its own; it lives in the kebab menu

A reload keeps your terminals

The interface holds the window-to-session pairing in memory, and reloading the interface, which is what the Reload action offers after a panel fails to load its code, clears that memory. Since v0.39.1 the app records that pairing on its own side, so a reload restores it exactly instead of re-dealing the numbers and putting one conversation under another’s title. The agents are untouched: every Command Terminal keeps running, and the windows come back attached to the sessions they were driving, with the same number, the same branch, and the same auto-derived title. That title is first-prompt-wins and survives too, so the next thing you type does not rename the terminal after it.

One case renumbers. If a terminal you opened after the reload already holds a survivor’s number, the survivor takes the lowest free one instead, on the reasoning that a renamed window beats a live agent with no window at all.

Context bar

The Command Terminal carries the same context bar as a board session - shell, agent version, elapsed time, model, session cost, tool-call count (click for a per-tool breakdown), token usage, and context window fraction. The model and effort pills are interactive here too: click either to switch the running session’s model or reasoning level on the fly. See Context bar.

Branch picker

The header includes a branch picker that lets you switch branches without leaving the window:

Select a different branch from the dropdown
The current session is killed
A new session spawns on the selected branch

The pill names the branch the checkout is actually on. It is re-read from git whenever you reopen the layer and whenever the checkout moves - an agent running git checkout inside the terminal, or your own git usage outside it - so it never keeps claiming a branch the repo has left. The re-read is only ever a read; it never checks anything out.

Hiding vs stopping

Hiding keeps your terminals alive in the background. Press Ctrl+Shift+P / Cmd+Shift+P again, press Ctrl+Shift+W / Cmd+Shift+W, click the title-bar terminal icon, or click the blurred backdrop to hide the layer. Every PTY keeps running, and reopening reattaches - the layout and running sessions are exactly where you left them.

Stopping destroys a single terminal. There is no per-window close button; instead, a window’s Stop control (red, also in the kebab menu as “Stop terminal”) kills that PTY, cleans up its session directory, and closes the window. The other terminals stay open. Stopping the last terminal hides the layer. Because transient sessions are non-resumable by design, a stopped terminal cannot be brought back.

Stop is not instant: it reads Stopping… with a spinner while the kill is in flight, and the window closes either way once it settles. If the kill itself fails, a toast says so rather than leaving you to assume the process is gone - the same warning appears if a branch switch could not stop the terminal it was replacing.

When the agent exits

Since v0.46.0 a terminal ends when its agent does. Type /exit, or let the agent crash, and the terminal ends and its window closes within a few seconds, so you are never left at a bare shell prompt. /clear and /resume keep the terminal. Under WSL the end comes about 5 seconds after the agent exits, because a /clear or /resume in that window starts the agent again and cancels it. A terminal whose agent has not started yet is left alone for up to two minutes, so a slow shell is not mistaken for an agent that exited.

Anything the agent started in the background, such as a dev server or a watcher, is stopped about 12 seconds after the terminal ends and listed in the leftover-processes toast, the same as when a task finishes. With Stop Leftover Processes off it is only listed.

From your phone

A phone paired through Kangentic Mobile can start and stop Command Terminals in any project, on a v0.46.0 or later desktop. A phone start runs the same path as New terminal: the project’s default agent at the project root, on the default base branch, counted against the same limit of four. A terminal the phone starts in the project you have open gets its window the next time you open the layer, and the title-bar icon counts it right away. The phone cannot switch a terminal’s branch, model, or effort, and it never gets a shell: the terminal is the agent CLI, and it ends when the agent exits.

When to use it

Quick questions - ask the agent about the codebase without creating a task
Releases - run release scripts or tag management
One-off fixes - small changes that don’t warrant a tracked task
Exploration - investigate code or debug issues interactively