ccch1mneyyy/dsh-TUI

dsh-TUI

An interactive terminal UI for DeepSeek Harness. It ships a pixel-whale header, live work status, streaming thinking, double-Esc time rewind, a context progress bar, and a TPS gauge. Zero core changes: it consumes only DSH's public exports, and is moving from a mounted plugin to an app with its own entry and composition root, where DSH loads in process as the first-party backend. Install to enable; uninstall leaves no patches behind. The prompt footer hides completed goals once the turn is idle; the Todo side panel retains their history. Ctrl+Q folds todos while working and hides/restores the idle goal/todo footer. Clicking its todo header also hides it while idle. Hiding changes only this display: a new goal/todo snapshot or session reveals it again, and /goal clear does not clear todos.

Split diff cards give one-sided additions and deletions the full body width, without an empty opposite pane. Ordinary edits remain side by side, and mixed files choose their layout separately before folding or streaming reveal.

Compaction status stays on one line in narrow panes: phase and cancellation hints yield first, then the label is shortened; elapsed time is shown only as a complete field.

Image files referenced with @path use the same admission and resize/conversion policy as pasted images. Adjustment notices report the stored dimensions and format; required animation conversion is refused instead of dropping frames. Mention images and staged images still share count and stored-byte limits in source order.

Highlights

Panels without a verified Component identity are temporary: settings show their title and a distinct number for this run. Their toggles take effect immediately without being saved, and unrelated settings changes preserve that choice. Old actN:panel entries cannot be mapped safely: remove the placeholder and select the current panel again. Verified Components named actN keep their public runtime address; an explicit selection uses component:actN:panel in saved preferences to avoid claiming an old anonymous entry.

The default reasoning-effort setting offers the current backend/model’s declared tiers, including custom IDs. Saved values absent from that catalog stay visible and stored; while loading or unavailable, only Auto is selectable. On DSH, Auto follows the saved /effort choice, then the configured effort, then the model default. Claude/Codex retain backend preferences for Auto at startup and for resumed sessions; explicitly choosing Auto resets the model default. Explicit settings changes affect the next request; unsupported preferences fall back with a notice and are never forced onto a route.

Resuming a DSH session preserves its recorded reasoning effort (or its live selection when reattaching). The saved default seeds new sessions; explicit /effort and effort-default settings changes still apply to the current session’s next request.

• Pixel whale pet — three startup intros, click to wake; freezes after the first task.
• Launchpad and first-run guide — every ordinary launch lands on a landing page with a real input box (big text + whale + quick actions, dropping whole blocks on short/narrow terminals; whale-girl images use a compact native-canvas footprint instead of leaving a large gap before the title; on by default — /settings launchpad off boots straight into chat); command completion matches chat: Tab fills the input, Enter runs the command and clears it. The first run walks a four-step wizard (accounts & models / language+theme / model+workspace / shortcuts), re-runnable with /setup; its first step signs in to a subscription and catches the models it brings in (none → no question, one → that one, several → you choose), or adds an API key through the /provider wizard, which asks which of the enabled models to switch to or keeps the current one.
• Terminal-native UI — streaming Markdown, tool cards, / and @ completion, #L12-14 ranges, history search, zh/en UI.
• Notifications — one switch covers four system notifications: task completion, a tool approval waiting for your decision, a question waiting for your answer, and a plan review waiting for your decision. Task completion: DSH, Claude and Codex notify after successful live work settles, with no queued follow-up or active goal. The title is “dsh-TUI · Task complete”; the body shows the latest settled reply as a single-line plain-text preview (Markdown formatting removed, up to 200 characters). OSC 777/9 apply an additional 2048-byte sequence budget, including title and protocol bytes, preserving whole graphemes. No reply shows only the title; BEL only rings. /settings → Conversation: taskNotifications = unfocused (default), always, or off; notificationMethod = auto (default), osc9, bel, or windows. Auto uses separate title/body fields on Ghostty/WezTerm (OSC 777) and Kitty (OSC 99); iTerm2/Warp and explicit osc9 use a title prefix; other terminals ring the bell; delivery follows your terminal's notification/bell settings. On local Windows, auto resolves to windows, the system's native notifications: a task-completion toast. The first toast registers that user's AppUserModelID under HKCU, the toast appears about 3 seconds after the task ends (the PowerShell cold start that buys the no-extra-install route), and for DSH sessions an enabled, active external DSH notification plugin in the running profile makes dsh-TUI yield to it (no toast, no bell); an installed but disabled plugin does not suppress notifications; if that AppUserModelID cannot be written, the notification falls back to the bell instead of going silent. jumpBack (Windows, off by default) turns these toasts into a way back to the pane that raised them; it needs the native toast path (notificationMethod = windows, which auto picks on local Windows). With /settings → Conversation → jumpBack on, the pane title ends with [dsh-tui:<16 hex>], one marker for the life of the process; switching it off removes the suffix at once. While it is on, this process refreshes a marker file at ~/.dsh-tui/notify/jumpback/<session>.json (schemaVersion: 1, marker, pid, startedAt) when the setting is turned on and before each notification it sends, and the first toast that can promise a jump registers the per-user protocol handler (URL Protocol plus shell\open\command) under HKCU\Software\Classes\dsh-tui; a normal exit removes the file, and removes the key once no other live instance still needs it. Only a pre-send probe that finds exactly one target pane (or tab title) puts an activation URI on the toast; clicking it re-runs five checks — same pane, keyboard focus, marker still in the title, foreground window, not minimized — and refuses rather than jumping anywhere else when any of them fails. A click whose target has gone away changes nothing. Layouts that cannot be verified — a pane in an unselected tab that is not that tab's focused pane, profiles using suppressApplicationTitle, and terminals other than Windows Terminal (tested on Windows Terminal 1.24) — get a plain toast whose click changes nothing. The probe adds about half a second before each toast; the first one after enabling can also wait for the helper to compile (a few seconds, once), and a machine whose in-box compiler keeps failing retries it at most every five minutes. External notification senders can read the same marker file and point their own toast at dsh-tui:activate?m=<marker>; the URI and file format are a read-only contract, and this release ships no plugin-side implementation. SSH sessions keep the attached terminal's notification protocol in auto mode; explicit windows still selects the host's native transport. tmux requires set -g allow-passthrough on for OSC notifications and set -g focus-events on for focus reporting. Terminals without focus reporting need always. Replay, cancellation and failures do not notify. Works in inline and fullscreen modes. A tool approval adds its own notification: the title is “dsh-TUI · Approval needed”; the body carries the session name, the tool name and the asker's reason. The reason is host-provided text (the model's own justification can appear verbatim), so it is normalized to one plain line and length-capped, but the body makes no redaction promise; the tool call's arguments are never read for it. A native toast still being prepared is dropped if the switch turns off, the session is no longer the attached one, or the approval, question or plan review is no longer waiting. Every approval notifies, and only the current session’s does; background sessions and subagents stay quiet. The switch covers all four, so off silences approvals, questions and plan reviews along with completions. An enabled, active external DSH notification plugin still makes dsh-TUI yield for completions, approvals and questions; a plan review never yields, and outside local Windows (or in SSH) the existing terminal notification protocol or bell is used. An ordinary question adds its own notification: the title is “dsh-TUI · Waiting for your answer” and the body carries the first question's header and question; options and detail stay in the panel. Local wizard and sign-in questionnaires announce the same way; a subagent's question stays in the panel in this release; the 0.2.2 approval-intent asks are announced the same way as an ordinary question. A plan review is announced as “dsh-TUI · Plan review” and carries the question header and question, never the plan itself, and it is the one notice that does not yield: an external notifier maps approvals and ordinary questions to its own notification but not a plan review, so yielding would leave only its generic idle notice, which never says a plan review is waiting.
• Native cursor — focused text inputs inherit your terminal's cursor shape, color, blinking, and enabled animation or trail effects in both inline and fullscreen modes. The /model picker shows the same cursor during movement between provider tabs, model rows, and effort levels, then hides it after 0.5 seconds at rest; clipped regions fall back to the model row. The session manager also moves this cursor between the workspace rail, session rows, and search box; typing claims the search caret, and navigation returns it to the focused row. Configure animation and trail effects in your terminal.
• Images — Kitty/Sixel thumbnails, centered preview with zoom and pan, paste-time fitting, text fallback. Kitty images scale to the reserved cells' physical pixels, including on HiDPI terminals.
• Mermaid diagrams — mermaid fences drawn as Unicode diagrams.
• LaTeX math — $…$ and $$…$$ formulas as Unicode text, fractions and limits stacked in display blocks; mathRendering: image typesets block and one-row inline formulas as terminal images on graphics terminals.
• Timeline rail — every turn clickable; timeline / scrollbar / hidden gutter.
• Side panel — Ctrl+B splits the chat with a panel column once the terminal is wide enough; drag the divider to resize it. All eight built-in panels are enabled by default, and so are plugin panels registered later (sidePanel.panels: '*'; untick a row in /settings to switch to an explicit list). The header shows each inactive panel's symbol; hover to see its name. Narrow terminals and inline mode keep full-screen panels. In the todo panel a long goal wraps to the panel width with its phase on a separate row; when the content exceeds the viewport, focus the panel and scroll with ↑/↓ or the wheel (every todo is reachable too) (the compact goal row above the chat input stays a single truncated line with a hover tooltip).
• Live state — activity animation, context bar, TPS, cache hit rate, effort, tokens, session cost estimate (main + subagents), Git and session metadata. Title, trajectory-strip and session-state animations update independently of the transcript and pause when idle or unfocused. Context-bar fill follows backend occupancy; colors estimate content composition. Compaction clears obsolete estimates, and missing composition displays a single used block with a measured used count in both hover details.
• One session manager — /resume /home /agentview /bg ⌸.
• Live Compact partial checkpoints appear as folded summaries in chat and summary entries in /tree; they do not reset the whole context composition. Occupancy follows the host token meter. Folded previews use the durable summary with the same compactionId; expansion retains the complete text, which is also the fallback when the summary event is missing.
• Session workflow — /new /compact /export /btw, model hot-switch, fork, rewind, vim, fullscreen draft editor. /btw uses an overlay when its sidebar cannot render. Main-task questionnaires and the fullscreen draft editor take priority while preserving the side question and draft.
• IDE selection channel — a VS Code selection lands in the prompt.
• DSH integrations — presets, skills, MCP, goals, todos, subagents, questionnaires.
• Account sign-in — the standard profile offers pi-ai OAuth for ChatGPT/Codex, Claude, and Grok (plus OpenAI direct and Meta Muse when available), and Host-owned DeepSeek browser sign-in as deepseek-account on DSH 0.2.0-rc.1+. Use /provider or /auth without another plugin. A profile-only update from a global TUI patch that already mounts dsh-tui-auth can still start the official loopback callback listener on demand; fixed-port SSH forwarding still requires the global package to be aligned.
• Extensions — browser interaction, computer use and more.
• Built for long sessions — event-driven projection, virtualization, bounded caches.

Keys and commands: Interaction and commands. Everything else: documentation index.

Plugin side panels stay enabled when unrelated settings change. Editing the enabled panel list still applies your explicit selection.

Workspace side-panel counts match the session manager: the current conversation counts; empty logs, subagents, fork ancestors and archived sessions do not. Registered workspaces with no visible conversations remain at zero. Loading and read errors are shown separately; press r to refresh.

When a DSH 0.2.1+ Agent moves its session to another directory (the working_directory tool or a Git worktree), the status line, Git branch, @ completion, ! commands, clicked paths, skill commands and loaded context follow it, including after /resume. The session stays registered under the project it started in. Relative paths in cards rendered before a move resolve against the session's current directory when clicked; absolute paths keep their target.

Fullscreen mouse selection stays in the pane where the gesture starts, including chat, sidebar and either diff column. Diagonal, word and line selection copy that pane’s text; soft wraps join independently, source newlines remain, and divider drags only resize.

Preview

Featured & Listed

Among the community plugins recommended by the official lead of DeepSeek Harness, dsh-TUI is the first.

Featured by the DeepSeek Harness official WeChat account, listed in the dshfind plugin directory, and ranked #7 on GitHub Trending daily (TypeScript).

Quick Start

Windows one-click installer (x64)

Download dsh-tui-setup-win-x64.exe from Releases and run it. Per-user, no administrator, fully offline, and no preinstalled Node or DSH.

Command-line installation

Prerequisites: Node.js and deepseek-harness. The deepseek-official API-key route needs DEEPSEEK_API_KEY. On DSH 0.2.0-rc.1+, the standard profile can instead use /auth login deepseek-account and select the separate account route through /model. Other supported accounts can sign in through /provider or /auth after startup.

The primary compatibility target is DSH 0.2.2-rc.1. This adapter supports its Shell API, V4 session messages, declarative presets, and profile-backed settings; older supported hosts retain their compatibility paths. See configuration.

On DSH 0.2.1-rc.2 and later, /settings also selects DeepSeek Search / Fetch APIs and edits their endpoint and result limits, supporting custom Loader entry IDs and a masked API key input saved through DSH's credential store. Official Flash model labels show the 1017 release marker while retaining the deepseek-flash model ID.

/settings groups its sections into pages: the TUI's own settings sit under General, and plugins that declare a page get their own tab (Tab / Shift+Tab, or a click on the strip in fullscreen, switches pages; the strip is hidden when only one page exists).

On DSH 0.1.7, /settings uses the TUI's actual Loader entry ID, including custom IDs. It requires matching profile dependencies with @deepseek-ai/schemastery 3.18.3 or newer; an incompatible schema stops TUI startup with repair guidance instead of showing an uneditable settings page. Older hosts keep their legacy settings scope.

The dsh-tui section of /settings is saved in ~/.dsh-tui/settings.json, shared by every kernel; the first launch imports it once from the profile's cordis.patch.yml (and an older host's ~/.dsh/settings.yaml) (see configuration).

# Install the CLI and this plugin globally (ships the dsh-tui command)
npm install -g @deepseek-ai/dsh @deepseek-harness-tui/dsh-tui

# Start (first run auto-initializes the profile; needs pnpm)
dsh-tui
# Both `dsh-tui` and the short `dst` alias start the same TUI.
dst

Manual alternative: dsh plugin --profile dsh-tui add @deepseek-harness-tui/dsh-tui. The repo's sh install.sh runs that step and checks the required commands. Afterwards dsh-tui and dsh --profile dsh-tui are equivalent.

New-user note: pnpm ≥11 blocks dependencies with install scripts by default and reports ERR_PNPM_IGNORED_BUILDS. Updates skip foreign-platform natives — the @img/sharp-* packages and the Claude SDK's per-platform bundles — so only this machine's binaries are fetched. /update and dsh-tui update write both settings automatically. An update never installs the Claude SDK on its own: it enters a profile only when you pick that backend in the kernel picker, which then installs the pinned SDK for the running platform. No manual step needed. Details: Getting started.

After startup the TUI checks for newer versions in the background. It never blocks the first frame. Type /update for a one-shot upgrade of the whole set — TUI, dsh engine and global launcher. It restarts automatically and resumes the current session, and refuses instead of leaving an incompatible or unbootable TUI/engine combination. Launcher alignment is normally best effort, but a failure after the engine advances blocks the restart and prints a repair command. If the registry has a newer dsh release outside the TUI's validated line, it says so and waits for a TUI update rather than installing an unvalidated engine. Launcher alignment only touches proven global installs; local npm/npx packages, ambiguous aliases and multi-member pnpm groups stay unchanged. See Getting started for the profile lifecycle, source builds, and troubleshooting, including migration from the former dsh-cc-tui package.

CLI

Automation: dst -p "task", dst run --json, dst session list --json. The independent engine does not load the TUI or inherit its profile/preferences; it uses official DSH headless/services (validated on 0.2.0-rc.2, 0.2.1-rc.2, 0.2.1-rc.3, 0.2.1-rc.4 and 0.2.1-rc.5). dst cli --help lists its commands; dst dsh <argv...> forwards native DSH. See Automation CLI for protocol, limits, resume restrictions, and Node/Python/PowerShell integration examples.

Command	Purpose
dsh-tui / dst	Start the TUI; dst is a short alias for the same program
dsh-tui --resume [id] · dsh-tui update · dsh-tui doctor	Resume a session · align the TUI, dsh engine and global launcher as one set · pre-flight environment checks
dsh-tui safe	Read-only diagnostics, plugin inventory and repair guidance; safe --rescue builds a clean rescue profile
dsh-tui version · dsh-tui help	Launcher and profile versions and usage; both work even without a dsh install

Leading DSH options such as --dump-config and --patch <path> are forwarded unchanged; other arguments go to the app in dsh --profile dsh-tui. Use dsh-tui -- --resume=sid-1 ./notes to send --resume=sid-1 ./notes as literal prompt text, without selecting a session or workspace. When invoking DSH directly, use dsh --profile dsh-tui -- -- --resume=sid-1 ./notes: the first -- belongs to DSH, the second to the app. Host options can precede a literal prompt: dsh-tui --patch ./overlay.yml -- --resume=sid-1 applies the overlay and sends --resume=sid-1 as prompt text without resuming that session. Safe mode: Getting started.

Importing conversations from other agents (dsh-tui migrate)

Bring Claude Code, Codex, OMP, zcode, or Grok Build conversation histories into the DSH session store, then browse and resume them by their original working directory via /resume:

dsh-tui migrate                # list importable counts per agent (writes nothing)
dsh-tui migrate claude-code    # import every Claude Code conversation (likewise codex / omp / zcode / grok-build)
dsh-tui migrate codex --dry-run  # preview what would land, write nothing

• Read-only source: migration only reads the foreign agent's local store; artifacts are written through the official JsonlSessionPersistence backend, so imported sessions are first-class (openable, continuable).

• Idempotent: one deterministic UUID per source conversation — re-importing skips what is already present instead of stacking duplicates.

• Structure preserved: user/assistant messages, reasoning traces, tool calls with their results, and the source's context compactions (as native compaction checkpoints) are rebuilt turn by turn; harness-injected machine text opens no turn. An imported session can pick the work straight up. In-TUI browsing: the session screen (/resume) shows a tab per agent that has conversations; picking one imports just that conversation and opens it. In-TUI: /migrate (optionally /migrate <agent> [--dry-run]) runs the same import in a child process and reports through the notification flow. CLI alternative: dsh-tui migrate ... from any shell runs the same import. Full guide: Session migration.

• More agents (pi, opencode, …) extend the adapter registry as adapters land; grok-build reads GROK_HOME when set.

VS Code: use the integrated terminal or the dsh-tui-vscode extension. See VS Code guide. Herdr: run dsh-tui in a Herdr pane; idle / working / blocked are reported through its local integration API. Any terminal: dsh-tui reports idle / working / blocked / done / error over the pty with OSC 7501 (Program Status Protocol), so terminals and agentic inboxes that implement it can show what the session is doing; terminals that do not implement it ignore the sequence. Set DSH_TUI_PROGRAM_STATUS=0 to turn it off.

Bare --resume (-c, --continue) reopens the last session of the backend this launch selected. Startup recovery only ever targets that backend: a backend with no last session, or a derived target that belongs to a different backend than the one that actually booted (an unknown backend id falling back to DSH, --backend naming a backend that is not installed, a remembered kernel that is not the marker's source), refuses with a clear error and exit code 1 — never a silent cold start, never another backend's session, never a new session. An explicit --resume <id> passes that id to the selected backend as-is. The one exception is safe mode's "retry normal startup": it retries the kernel and session recorded in last-run.json, so a record whose backend is gone degrades to a warning plus a cold start — that retry is the last way back.

Experimental: Claude backend

dsh-TUI can also run its session on Claude: the same interface, driving the Claude Code CLI through the Claude Agent SDK. Your project's CLAUDE.md, settings, hooks, MCP servers and plugins load as the CLI loads them.

# once, in the dsh-tui profile directory (the SDK is an optional dependency)
cd ~/.dsh/profiles/dsh-tui && pnpm add @anthropic-ai/claude-agent-sdk@0.3.287
dsh-tui --backend claude     # or pick Claude in /kernel; that choice is remembered

The easiest install: open the kernel picker (the launchpad "Kernel" entry or /kernel) and press Enter on the dim Claude row — the wizard locates the profile directory and installs the pinned SDK for you; the command above is its manual equivalent. The confirmation shows the exact package and version. Closing the wizard, including clicking outside it on the launchpad, cancels a pending installation.

• Sign-in: a /channel relay profile, your dsh-auth anthropic sign-in (/login), ANTHROPIC_API_KEY or cloud-provider variables, or an existing claude login, in that order. A claude on PATH is used when present, then one in the native install directory under your home (~/.local/bin, or %USERPROFILE%\.local\bin on Windows); every candidate has to launch and report a version, and the SDK's bundled binary is used only when none does.
• Works: streaming, tool cards, approvals and questions, /model, /effort, Claude's permission modes (/permission, Shift+Tab), /compact, /context, /mcp, /resume, /fork, double-Esc rewind, subagents, background jobs, images, /btw, and the USD cost Claude reports.
• Not available: DSH-only commands such as /tree, /preset, /provider, /workspace, /agentview and /bg. One process runs one backend; /kernel switches by restarting into a new session.
• Startup: the screen appears before the session opens, with only a light profile composed (this package plus the profile's third-party plugins); see Claude backend. The DSH kernel starts from the same entry and loads DSH in the same process behind its first screen; DSH_TUI_HOST_ENTRY=0 restores the old launch path for every kernel.

Details and known limitations: Claude backend.

Experimental: native Codex backend

Run your own Codex through codex app-server, sharing its configuration, login, instructions, skills, hooks, MCP and native threads:

npm install -g @openai/codex@0.160.1
dsh-tui --backend codex
dsh-tui --backend codex --resume <thread-id>

Protocol baseline 0.160.1, minimum 0.144.0; other versions may show drift. CODEX_EXECUTABLE selects a binary; /kernel remembers the backend. codex resume <id> can open the same thread after the other writer exits. This is not migrate codex, which imports history into DSH. With native credentials, a writer conflict for an idle thread retained by the official background server triggers a reconnection to that server. Managed subscription credentials and /channel connections use private app-server processes.

Streaming/tool cards, approvals, questions, steer/queue/interrupt, model and effort controls, Plan, /review, /diff, /usage, /init, skills and MCP share the existing UI. Async questions open the questionnaire while Codex continues working; answers steer the turn (or queue if unavailable), and dismissing the question leaves work running. Shift+Tab only toggles Plan, keeping its underlying permission preset; Full Access requires an explicit choice. Existing Codex settings are respected, not overwritten with defaults. /login offers ChatGPT OAuth, a device code or an API key (the last writes to Codex’s own credential store). Relay /channel connections take precedence; managed subscription tokens are only injected on first-party routes. dsh-TUI does not write ~/.codex/config.toml or log out your native Codex account. A provider env_key from your own config (e.g. DEEPSEEK_API_KEY) that the shell did not export is injected from the DSH credential store when the ref is stored there — the active store first, then the default ~/.dsh one — so keep the key in the store, no per-shell export needed. When nothing can supply it, the session still starts and the reason is reported once as a start notice: Codex itself rejects every turn of that provider.

For Claude and Codex, /channel tokens (CHANNEL_* refs) belong to the active DSH_HOME only. Disconnecting a channel cannot revive a token from the default home; reconnect it in the active home if needed. Provider env_key credentials retain the fallback described above.

TPS includes hidden reasoning time and excludes tool execution time. Live text estimates are corrected when Codex reports output token usage. Decode spans of 500ms or less are excluded from TPS samples; token and cost totals still include all reported usage.

Native browsing/archive, fork/conversation rewind (the first message requires Codex app-server 0.160.1+), paged history, images, subagents, polled background terminals, goals and /btw//recap use the existing surfaces. /logout removes only the matching dsh-auth credential; already-loaded managed tokens require a normal restart, not native logout. The real 0.160.1 app-server passed nine credential-free offline checks and eight daemon-resume checks, with no model turn or charge; real subscription login, credentialed model calls and real-TTY interaction were not run. Only Codex identification/title changes automatically, not palette or companion. Using ChatGPT subscription tokens in third-party clients is subject to OpenAI’s terms. Full instructions and current boundaries: Codex backend.

Experimental: DSH Agent Teams

DSH's experimental Agent Teams lets the session's agent (the Lead) create named teammates that share the working directory, message each other and coordinate on a shared task board. It ships with dsh, is off by default, and /plugin list advertises it. Switch it on:

/plugin enable @deepseek-ai/dsh-experimental-agent-team-profile

The switch enables or disables the bundle in the profile, so it persists across restarts, and on a dsh --profile launch it applies at once — running sessions included: the model is told which tools came and went. /team appears in Help and / completion only once the team service is mounted, and only reports: /team (or /team status) shows the bundle, the service and this session's teammates. /team on|off was removed; typing it points at /plugin enable|disable. Turning the bundle off while teammates run asks first, and switching off stops them: the team service releases the teammates still running as it unloads. Inside a teammate session the other teammates' runs are not visible, so the question counts them as possibly running. The team record stays in the session and comes back when the bundle is enabled again.

If the running DSH does not ship the bundle (/plugin list stays silent), switch DSH to one of the supported lines first (0.2.2-rc.1, 0.2.1-rc.5, 0.2.1-rc.4, 0.2.1-rc.3, 0.2.1-rc.2, 0.2.1-alpha.5, 0.2.0-rc.1 or 0.2.0-rc.2). To install it into the profile explicitly, run dsh plugin --profile dsh-tui add @deepseek-ai/dsh-experimental-agent-team-profile@<your-dsh-version>: the team packages ship in lockstep with DSH and pin their DSH peers exactly, so the version must match.

While a request carries spawn_teammate, dsh-TUI drops subagent / subagent_fork from it, and the team's send_message / list_agents / interrupt_agent / wait_agent take the place of the legacy controls of the same names, so spawn_teammate is the delegation tool; with the team off the legacy tools are back. Subagents that are not team members (workflow, ralph) keep subagent. A teammate shows up as a subagent row, a message between members as a ✉ <sender> bubble in the receiving session (a teammate's received messages show on its subagent detail as agent messages), and the other team tools as one-line cards (send_message with its target and sent). The agents dashboard (Ctrl+A) and the agents side panel switch to a team view: each teammate under its member name with running / idle / provisioning / failed (a teammate whose turn ended is idle — a message wakes it — not done), the Lead line, the remaining subagents, a read-only task board (status, owner, blocked, write-scope warnings) and a banner when the team record was rejected. A delegation provider whose settled runs fail at least twice and at least half the time gets one degraded-channel line above the list; the built-in subagent route, workflow members and per-type Claude children are excluded because there is no provider to switch to.

Limits: the switch covers the whole profile, not one session (a launch without the profile plugin service, or without hot reload, needs dsh plugin and a restart); there is no "enter teammate session" yet, and /export leaves team messages out. Upstream limits apply: teammates share one working directory, a team lives in one process, and a task owner is never released automatically. Subagent failure badges and the Companion error state share session-scoped unread status. Opening that child’s detail or main view acknowledges only that failure; a new run or failure alerts again. Acknowledgements survive panel remounts and session switches during this process, but a cold restart starts unread. Opening the dashboard alone does not acknowledge every child. Task status stays failed.

Keybindings & Mouse

Enter send · Tab complete · Ctrl+Enter interrupt and send · Alt+Up recall the last message · Esc closes local layers before interrupting a running turn, double-Esc rewinds on empty idle input · Ctrl+B side panel · Ctrl+O details · Ctrl+R history (↑/↓ and Ctrl+R are scoped to the current project) · Ctrl+V paste · Ctrl+Shift+E fullscreen draft editor · ? shortcuts · ← open the session manager (DSH backgrounds the current session first). In both the launchpad and chat, Ctrl+U deletes from the caret to the current line start, preserving text to the right and whole image chips. It edits only the focused input.

In the launchpad input, Shift+Enter (or Option+Enter) opens chat and inserts a newline at the caret, keeping the draft and staged images unsent. Continue typing there, then press Enter to send.

In both the launchpad and chat, Alt/Option+←/→ moves by whitespace-delimited words and Alt/Option+Backspace deletes the previous word, like Ctrl+W. On macOS, configure your terminal to send Option as Meta.

Use Alt+Up / Alt+Down to page through question text and details, or approval previews on very short terminals, without moving the choice focus; these keys are remappable in /settings → Shortcuts. Fullscreen also supports the wheel over the preview. Complete OAuth links remain readable when browser and clipboard helpers are unavailable. Fixed-action permission questions offer only the caller's choices; ordinary questionnaires still accept free text.

Text, cursor position and staged image attachments on the launchpad or in chat while the backend starts are preserved when the session becomes ready. Press Enter after it is ready to send; an earlier Enter preserves the draft without queuing it. Opening a new session while startup is pending clears the previous draft and its images.

The goal bar stays on one summary line: hovering truncated goal text in fullscreen or split shows the whole objective, and a bare /goal prints the full status — objective, phase, rounds or budget, available commands — as a transcript block in the /plugins shape. Inline mode sees no pointer events, so that block is how its users read a long objective.

While the model is working: Enter steers, Tab queues a follow-up, Ctrl+Enter interrupts and sends. Input that names a command is still a command — with or without arguments — so /model or /new reach their own gate (and the / overlay sinks the commands that affect the running conversation) instead of silently becoming an interruption; only text that is not a command — and a direct skill gesture such as /skill-name … — steers.

When DSH ends a turn because its session was disposed, the transcript shows “Session stopped”; user interruption keeps its existing prompt for what to do next. This describes the reported stop reason and does not recover a stuck session or its queued inputs.

Windows Neovim/Vim terminals identified by NVIM or VIM_TERMINAL retain VT input instead of enabling ConPTY mode 9001. For another incompatible embedded host, set DSH_TUI_DISABLE_WIN32_INPUT_MODE=1 before launch (PowerShell: $env:DSH_TUI_DISABLE_WIN32_INPUT_MODE="1"). The same gate applies at startup and after resume. Native Windows Terminal, conhost and VS Code keep their existing mode unless disabled; the opt-out can remove modified-Enter reporting.

Extended key reporting (Kitty keyboard protocol and xterm modifyOtherKeys) is enabled for a fixed terminal list: iTerm2, kitty, WezTerm, Ghostty, rio, Orca, tmux, Warp and Windows Terminal. A terminal missing from that list can opt in with DSH_TUI_FORCE_EXTENDED_KEYS=1, and DSH_TUI_DISABLE_EXTENDED_KEYS=1 opts an allowlisted terminal back out for SSH or nested xterm.js hosts (it wins when both are set). Outside native Windows, where win32-input-mode reports Enter's modifiers instead and is not touched by this switch, a terminal without extended keys cannot tell Shift+Enter from Enter, and Ctrl+J is the newline fallback.

On native Windows, fragmented Win32 input records are reassembled across short input delays instead of appearing as numeric protocol text. The platform check only reports that this machine might run the private mode (win32-input-mode); a bare ESC[ fragment is held only after one record has actually been decoded, while a fragment whose own shape is already record-specific holds on its own (which is how even the first record can survive a split). Windows terminals that never enter the mode (mintty, GitBash) therefore keep the classic VT path: a lone Esc keeps its normal response time, and a letter typed after a timed-out ESC[ is not swallowed.

Incomplete records are held for a bounded recovery window (1 second from first capture, never extended by later input; 64 bytes max); past either bound the hold ends and input is handled as before. Unrecognized complete CSI sequences are not inserted as text; after a damaged CSI prefix, a bare ASCII letter can be consumed as its terminator, while normal Win32 key records and bracketed-paste text retain their own boundaries.

A session's very first record can still leave residue if it is split before its record-specific shape forms; once any record has been decoded, every split position is covered. Inside the recovery window, literal input starting with [digit;… cannot be told apart from a protocol prefix — it may be held, or re-joined to a preceding Esc. To type it, wait for the window to close, or avoid that shape right after Esc.

Terminal replies that arrive split are reassembled the same way (native Windows ConPTY is the common source): while the app still has a query awaiting its answer, an unfinished DA1 / DA2 / DSR / DECRPM / XTVERSION tail — even one split again after the introducer Esc was flushed — is held across input delays, but only while its shape can still complete into the response type that query expects. It is then consumed as the reply it completes instead of entering the prompt as protocol text.

That claim is evidence-gated, and this is the difference from earlier builds: no query awaiting an answer means nothing is claimed, so a literal [?61;4c typed right after Esc still enters the prompt exactly as before.

The window is bounded like the record hold (about a second, never extended by later input; 64 bytes max); past either bound it ends, and bytes still shaped like an unfinished reply prefix are dropped rather than shown.

Inside that window, with a query of the matching response type outstanding, same-shaped literal input can still be claimed as a reply; to type it, wait for the window to close (about a second), or avoid that shape while a query is outstanding.

Fragmented SGR mouse reports no longer land in the prompt as text: an incomplete report header is held until the rest arrives, and a report that completes is handled as a mouse event. The hold is armed only while mouse reporting is actually active (fullscreen, with mouse tracking enabled); inline sessions and terminals that never enable tracking keep the existing behavior. The claim window is bounded from first capture (at most 1 second; 64 bytes max), and a continuation arriving inside it is still claimed rather than replayed. Release has no timer: once a parse call sees either bound exceeded, it replays the held bytes as ordinary keys in arrival order — literal input can be delayed, but is never dropped. A completed text-only assistant reply containing only a leading ⏵ status line remains visible in the conversation and can be selected for copying. Live status lines and status lines followed by a real answer stay out of the transcript body.

Plugin slash-command results, including errors, remain as local transcript blocks for scrolling and copying during the current session. Indentation and line breaks are preserved. Each report retains at most 200 lines, 65,536 UTF-16 code units and 4,000 terminal cells per line, plus a visible truncation marker. The local display rows are not sent as model input or replayed as conversation history. The backend may separately persist command audit events and their results. Older local report blocks are evicted within the shared 600-row budget. Explicit built-in report layouts (such as /goal) keep their existing formatting.

Mouse (fullscreen): drag to select and copy, double/triple click to select a word or line, click tool cards, timeline ticks and [Image #N] previews.

Automatic copies keep the text selected; press Esc to clear it or start a new selection to replace it. Selection highlighting skips trailing padding and blank rows while preserving spaces within text and code indentation. Inline mode uses the terminal's native selection.

When a fullscreen selection starts in a code block's body, soft-wrapped rows join without adding frame padding or newlines, in both light and full frames. Hard line breaks and the existing hard-line inset remain part of screen copying.

During a fullscreen text drag, the native cursor follows the selected text's edge using your terminal's enabled cursor animation or trail effects. Moving into trailing padding or blank rows keeps it at the nearest selected text edge. Releasing or cancelling the drag restores the focused input's caret.

File paths in prose can open the file-action menu; automatic detection does not extract a path from inside a slash-delimited token such as working/idle/needs-input or a date such as 2024/01/15.

Pasting: the launchpad accepts clipboard images and pasted image paths as [Image #N] attachments; Enter sends them with the first message. Commands that do not accept images preserve the draft and its attachments. Image chips behave like chat: arrows step across them, Backspace at the end or Delete at the start removes the whole image, and Ctrl+W never splits a chip. Text pasted on the launchpad is folded to one line. In chat, native and bracketed paste keeps ordinary text and newlines, and never submits itself on arrival. On Windows terminals that deliver a paste as win32-input-mode key records, a record stream leaked into the payload is decoded back into the characters its Uc field encodes — newlines included — so the composer's line count matches what was pasted; only records with no character meaning are stripped (a multi-line paste no longer leaves stray _), and a complete record is always consumed before an ESC-less tail, so no payload character is deleted along with an orphan escape. Pasted CRLF collapses to a single newline; genuine underscores and bracketed-paste text are untouched.

Dropped files: a native Windows desktop drop (Windows Terminal / OpenConsole) arrives as an OSC 8 hyperlink; the parser restores its file:// URI to a decoded local path before paste hygiene runs, so the ]8;id=…; parameter bytes never reach the draft. Image paths enter the existing image staging pipeline; other files are inserted as a referenceable path (a path containing whitespace arrives in the composer's quoted "…" single-token form). Only file:// URIs are restored, and it is fail-closed: a remote authority/UNC, a payload carrying several distinct URIs, or a URI that carries several tokens is refused and stays literal text rather than guessed. Fullscreen drag-copy uses the final highlight. If a live row changed during a drag, move the selection back to stable text to establish a new baseline. A stationary selection whose copied text changes is still refused; automatic scroll/resize does not clear that protection.

The pixel whale, large title and context/TPS colors follow the same terminal color depth as other text: monochrome, 16-color, 256-color or truecolor. Apple Terminal and tmux use the shared fallback; NO_COLOR and FORCE_COLOR retain the existing shared color policy.

If resume reports that another DSH process owns the writer, release the session in that process (for example, dsh web) and retry in the same TUI. The foreground session stays intact; do not delete session or lock files to bypass single-writer protection.

Full reference: Interaction and commands.

Built-in Commands

/resume · /home · /agentview · /bg · ⌸ open th

…