Skip to content

Features

Session management

  • Session browser — every Claude Code project and session, sorted by recency
  • Quick-resume — ★/☆ shortcuts on the main screen jump straight back into recent sessions across all projects
  • Search — type to filter sessions live; 🔍 Search all sessions finds and resumes any session across every project
  • Transcript viewer & export — read any session in a pager (v) with full-text search inside the conversation (/, n/p to jump between matches) and a message-position counter; export to markdown (e)
  • Session info — per-session tokens, est. cost, models, git branch, duration (i)
  • Archive — move sessions to a restorable archived/ folder instead of deleting (d, toggle view with A)
  • Rename / Fork / Continue — rename (r), fork (f), or continue the latest session (claude -c)
  • Tags — tag sessions (t); tags show inline and are searchable
  • Changed files — list the files a session edited/created, derived from its tool calls (F)

MCP servers

  • Full management — add, remove, and inspect MCP servers via claude mcp (scopes local/user/project, transports stdio/http/sse, env vars and headers)
  • Three states, all visible — ✔ connected, ! needs authentication, ✘ failed to connect or timed out. A server that cannot connect is the one you most need to see, so it is listed with its error rather than omitted
  • Status footer — connected servers shown live on the main screen
  • Tool documentation — analyze any server's tools and write the docs into the global ~/.claude/CLAUDE.md

Agents (subagents)

  • Agent library — a category-organized store at ~/.claude/claudectl-agents/<category>/ (not auto-loaded by Claude, so sessions stay lean). Roll your own or bulk-install the awesome-claude-code-subagents catalog (154 agents across 10 categories) — see Installing the agent library.
  • Per-project selection (g in the sessions menu) — pick agents from a category checklist (optional, default none). The chosen agents are copied into <project>/.claude/agents/ where Claude auto-discovers them, so they apply to every launch of that project and the selection auto-restores next time. claudectl only manages the files it placed (tracked in .claudectl-managed.json) — your own project agents are never touched.
  • Scaffold — create an agent into a chosen or new category: pick tools (multi-select) and model, edit the body
  • AI-generated — Claude analyzes the project and authors a focused subagent (role, when-to-use, tool subset, system prompt); you review before it's written
  • Lead agent — also set a single --agent (from ~/.claude/agents/) in launch options
  • Why copy, not --agents — inline --agents JSON rides the command line (Windows ~32KB cap); a handful of real, multi-KB agents overruns it (WinError 206). Copying into .claude/agents/ has no size limit and matches how Claude Code natively loads project subagents.

Project memory

  • Scaffold CLAUDE.md (c) — build project context mechanically from git repos, recent commits, READMEs, and prior session topics
  • AI CLAUDE.md generation (a) — Claude deep-analyzes the codebase and writes/updates a comprehensive CLAUDE.md; reviewed before writing
  • System prompts (s) — AI-generate or hand-edit a per-project system prompt injected on every launch
  • Memory map (M) — see which CLAUDE.md files load for a project (user / project / .claude / local) and their @imports; open any in your editor

Architecture graph (n → o)

An interactive, whole-project dependency graph rendered as a self-contained HTML (no CDN), opened in your browser.

  • Expandable hierarchy — opens at the workspace root + its repos (sized by importance); click a node to drill in (repo → module → file) with a smooth opening animation. The complete tree is embedded, so any size is explorable via progressive disclosure; small projects auto-expand fully.
  • Real dependencies, multi-language — edges come from actual imports: Python import (AST) + C/C++ #include + C# using→namespace + JS/TS import/require. Edges lift to the visible level: collapsed shows repo↔repo bundles, expanded reveals module- and file-level links.
  • Reads as architecture — each project sits in its own contained bubble (never overlaps others), nodes sized by importance (file count + dependency degree), colored per project, animated rotating dodecahedra with flowing connection particles on a neural-network-style canvas.
  • Controls — search (expands the path to matches), filters (dependency / containment / hulls / labels), Fit / Reset / Expand-all / Collapse; zoom-aware labels; hover highlights neighbors. Built graph is cached (.claudectl/connections-cache.json) so reopening is instant; r forces a rebuild.

The animation at the top of this README is captured from the real HTML view (docs/graph-real.gif, regenerate with py tools/capture_graph_gif.py). The graph is a self-contained interactive HTML you open in the browser.

Intelligent project memory (m)

The feature that makes claudectl unique: task-scoped, token-budgeted memory injection at the launcher. Claude remembers the whole project while paying the fewest possible tokens — three injection surfaces, zero duplication:

Surface What Claude sees Cost
CLAUDE.md micro-index repo one-liners + module names + recall pointer ≤250 tok, every session
.claude/rules/claudectl-mem-*.md per-module entities & relations, globs:-scoped 0 until Claude touches those files
UserPromptSubmit hook (opt-in) the subgraph relevant to your current prompt, budget-cut ≤600 tok/prompt, <1s local
  • Whole-project extraction — claude.exe summarizes every repo and module (incrementally by file hash), merged with the real dependency graph (cross-module edges + importance rank) from the connections engine. Stored in .claudectl/memory/graph.json.
  • Bounded & self-consolidating — the graph stays lean as the project grows: duplicate entities merge across modules, and a global importance cap (memory_max_entities, default 500) evicts the least-connected. So the always-on token cost stays flat while accuracy rises — the memory gets leaner and sharper the more you build, not heavier.
  • Temporal facts (Graphiti-style) — when the code changes and a fact is superseded (you migrated Flask→FastAPI), the old fact is invalidated with a timestamp, not deleted — kept as history, never injected. Memory tracks what's true now and what changed, instead of drifting stale.
  • Reinforcement + rollups — entities recalled often gain weight and survive consolidation; dead knowledge fades (access-based, like a forgetting curve). Per-repo rollup summaries (GraphRAG-style, built locally — no extra Claude call) give an accurate one-line repo overview and cheap global answers. Plus Obsidian-style unlinked-mention edges enrich retrieval for free.
  • Recall engine — local scoring (IDF keyword + path match + dependency rank + graph expansion), no embeddings, deterministic, <0.5s on 500 entities. On-demand CLI: claudectl recall "<topic>" — Claude itself can call it mid-session via Bash.
  • Session learning — after each session claudectl distills durable lessons (error→fix pairs, decisions, preferences) from the transcript. High-confidence lessons auto-approve (memory_lessons_autoapprove); the rest wait in the ⇧L review screen. Approved lessons boost recall and decay if unused. The project literally gets smarter the more you use it.
  • Cross-project conventions — preferences/corrections that recur across your repos (or you pin) are promoted to a small block in your user-level ~/.claude/CLAUDE.md, so a convention learned once ("this machine uses PowerShell 5.1", "prefer pytest") is remembered in every project. No competitor spans projects.
  • Auto-refresh — memory refreshes incrementally on project open (memory_auto_refresh, capped so a big rebuild never runs silently). Zero user action. The update runs in a detached background worker that survives launching a session, saves after every step (an interruption never loses progress), and shows live progress in the sessions menu — so you can open a chat immediately instead of waiting for the scan to finish.
  • Memory hub (m in the sessions menu) — one screen for everything: status, build, ask, injection preview with live "what would my prompt inject?" probe, lessons, work suggestions (s — next-steps from lessons + graph + health, local), since-last-session diff (d — git + session-log), per-surface toggles.
  • Ask the project — grounded Q&A over the graph, answered by Claude with only the relevant subgraph as context.
  • (Graph memory inspired by cognee; retrieval budgeting inspired by Aider's repo-map; both reimplemented from scratch — pure stdlib.)

Project health & auto-fixes (w)

Launcher-side mitigations for the most common Claude Code problems (2026 field research):

  • Pre-launch health card — CLAUDE.md over-budget (loads every session!), missing --add-dir/PATH entries, non-UTF-8 CLAUDE.md, stale memory, MCP failures, session-window burn ≥70% (suggests cheaper model/effort for routine work).
  • Context-loss insurance — after every session a 5-line summary (goal + files touched) is appended to .claudectl/session-log.md, so the next session can recall what happened even after /compact wiped the context. Local, free.
  • Permission fatigue killer — P in the workspace screen scans your history for repeatedly-used Bash commands and proposes permissions.allow rules for the project settings.json (diff-previewed, you approve).

Multiple Claude accounts (⚙ Accounts)

Run two (or more) accounts with almost no friction — claudectl owns the config dir (CLAUDE_CONFIG_DIR), which is what decides the account:

  • Named accounts — add an account (name + config dir; claudectl creates it and can open /login right away), rename it, switch the active one, or open it in a new terminal with one key so both accounts run at the same time.
  • Per-launch account — the launch-options screen has an Account field: pick which account this specific session starts under, without changing your default.
  • All accounts in the usage bar — the plan-usage banner shows one bar per account (labeled by email/name) and updates dynamically, so you see every account's session/weekly limits at a glance. A single account stays a single compact bar.
  • One row per project, not per account — if the same folder has sessions under two accounts, the project list shows a single row (default account primary, tagged [+other-account]) instead of a duplicate. Opening it merges every account's sessions into one list, foreign-account sessions marked inline ([account-name]); rename/archive/delete/fork/view all act on that session's own account, and resuming one launches under the right account automatically.
  • Inject context across accounts (⇧K in the sessions menu) — start a new session seeded with the transcript of any prior session for this project, including ones from a different account.
  • Account-accurate memory — the memory graph lives under the project's real path (shared by every account), and the features that feed it now read every account's sessions: lesson extraction, the CLAUDE.md session-topics block, per-project usage stats, workspace freshness counts, and the recent-sessions quick-resume list. A project used under two accounts is one merged row in the usage dashboard, not two.

Plan→Execute — two models, one task (⇧X in the TUI; its own Plan → Execute project tab in the GUI)

Plan with an accurate model, execute with a cheaper — or completely free — one, for the same result. claudectl plans the task headlessly with plan_model (default Opus 5, effort picked per task), shows you the plan to approve/reject, saves it to .claudectl/plan-latest.md, then launches a real, full interactive claude session — same account, agents, skills, system prompt, and --add-dir roots this project already has — on exec_model (default Sonnet 5), seeded to read and execute that plan. Expensive reasoning happens once; the build runs on the cheap tier.

Free execution via OmniRoute — point the execute half at a local OmniRoute proxy instead of your Anthropic account, and it runs on OmniRoute's aggregated free-tier providers. Left on Auto (the default), OmniRoute itself scores every currently-healthy free model per request (health/quota/cost/latency/task-fit) and transparently falls back to the next-best one if the current one is rate-limited or exhausted — no manual model juggling, and claudectl auto-starts OmniRoute in the background the moment you run a task through it, so there's no terminal to babysit.

Setup (one-time): connecting at least one provider happens in OmniRoute's own dashboard — claudectl never touches that credential. The CLI commands for adding providers are broken on Windows (confirmed upstream), so the dashboard is the only reliable path.

  1. Install OmniRoute: npm install -g omniroute (PowerShell: run on its own line, or ;-chain — no &&).
  2. Set a dashboard password once: omniroute setup --password <yours>.
  3. Start it (omniroute, or let claudectl auto-start it on first use) and open http://localhost:20128 → log in → Providers → Add Provider, or go straight to Free tiers. Several are genuinely zero-signup (Pollinations, Puter, NVIDIA, OpenCode, FriendliAI, Coze, and more) — connect one or two. (Note: OmniRoute's marketing claims ~90 free providers; what's actually reachable without a real signup is a smaller genuinely-keyless subset — worth checking the current list yourself in the dashboard. The CLI omniroute providers add commands crash on this platform — dashboard only for now.)
  4. In claudectl's GUI Settings → Free execution — OmniRoute: leave the base URL at http://localhost:20128, click Refresh — the status dot shows provider(s) active once step 3 is done. The built-in connection self-check can report false negatives (confirmed: reports working no-auth connections as broken); use Send a live test for the real answer. Leave Execute model on Auto, Save.
  5. Open a project's Plan → Execute tab, describe a task, pick Execute via → OmniRoute, approve the plan. First run starts OmniRoute for you if it isn't already running.

Troubleshooting: - Status dot shows "not running" — OmniRoute auto-starts on first Plan→Execute run; click Start now on the Settings page to start it immediately, or run omniroute in a terminal. - "0 providers connected" — open the dashboard at http://localhost:20128, log in (password from step 2), and add a provider under Providers. No providers = no free model to route to. - Live test fails — use Send a live test on the Settings page; if it fails, the connection is genuinely broken. Try a different free provider in the dashboard (some providers are rate-limited or have exhausted daily quotas). - Self-check says connected but live test fails — OmniRoute's own per-connection self-check can be wrong (confirmed). The live test is authoritative.

Nobody else orchestrates this from the launcher.

OmniRoute standalone session — claudectl also supports launching a standalone interactive claude session through OmniRoute, not just the Plan→Execute execute half. When you open a project in the TUI and pick a model from the OMNIROUTE menu (appears only when OmniRoute is reachable on a configured base URL), your session runs entirely on OmniRoute's free/cheap tier, with full access to every Claude Code feature:

  • Agents & subagents — all work. CLAUDE_CODE_SUBAGENT_MODEL=claude-sonnet-5 is automatically set, so subagents always run on a capable model (Sonnet 5) even when the main session uses a free-tier model that may lack tool_use or have a small context window.
  • Skills — load on demand, unchanged. Skills are client-side SKILL.md files discovered from .claude/skills/; the Sonnet 5 subagent model handles them correctly.
  • Per-project memory, hooks, MCP servers — all client-side, model-agnostic. They load from CLAUDE_CONFIG_DIR and the project's .claude/ as usual, unchanged.
  • Plan→Execute — the plan-execute modal in the GUI has an Execute via toggle (Anthropic / OmniRoute). Selecting OmniRoute routes the execute half through OmniRoute (same agent/skill/memory guarantees). The Plan→Execute TUI path automatically picks OmniRoute when omniroute_exec_model is configured.

Caveats: - Anthropic usage tracking won't reflect OmniRoute spend (cost tracking is separate). - Free-tier models often have small context windows (<16K tokens). Use the TUI's context-warning on CLAUDE.md + rules + plan over ~8K tokens. - Some free models lack tool_use, which degrades agents, skills, and MCP tool calls. The Sonnet 5 subagent override covers the common case, but the main model's own capabilities remain the free model's. - CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 is set automatically to block telemetry that free models might reject or that unnecessary calls to the Anthropic API may fail on.

Adaptive agent selection (g)

The agents screen opens with a "Suggested for this project" section — library agents ranked against the project's languages (from the dependency graph), memory entities, and name. Local scoring, instant, free. Setting agents_auto: 'auto' applies suggestions automatically on first open (your manual picks are never touched).

Token economy — shrink the per-turn cost

CLAUDE.md and memory files ride in the model's context on every message, so their size is a permanent per-turn tax. claudectl makes that cost visible and cuts it:

  • Context weight audit (⇧W) — one screen estimating the tokens auto-loaded on every turn for this project: CLAUDE.md broken into its blocks (manual / autogen / session topics / memory digest), the global ~/.claude/CLAUDE.md, .claude/rules/* (marked lazy when glob-scoped, so they cost nothing until a matching file is touched), system-prompt.txt, SessionStart hook injections, and MCP servers — with a running always-on total and inline warnings (CLAUDE.md over 200 lines, an unbounded session-topics block, a global CLAUDE.md that loads in every project).
  • Prune the unbounded bits (p in the audit) — the CLAUDE.md session-topics log used to grow forever; it's now capped to the most recent N entries (claude_md_sessions_cap, default 10) and the autogen commit list is configurable (claude_md_commits). Prune rebuilds them in place without touching your manual prose or the memory block.
  • Compress CLAUDE.md with AI (⇧C) — rewrites the hand-written part into a lean lookup-table style (targets under 500 tokens), shows a before→after token count and a git-style diff to approve, keeps a CLAUDE.md.bak, and preserves the machine-maintained blocks verbatim.
  • Launch economy controls — the launch-options screen adds a Think cap (MAX_THINKING_TOKENS) and Subagents model (CLAUDE_CODE_SUBAGENT_MODEL) field, plus an e economy preset (Sonnet · 8k thinking cap · Haiku subagents) in one key. Set defaults in Settings or per project.
  • Deny heavy reads (d in the audit) — scans the project and writes permissions.deny rules (node_modules/**, dist/**, lockfiles, …) into the project's .claude/settings.json so a stray read can't pull thousands of tokens of generated content into context. Merges without clobbering existing settings.
  • Token-saver hooks — concise-output (a SessionStart rule: no narration, no re-printed code) and filter-test-output (rewrites pytest/npm test/go test commands to pipe through a failures-only filter before the output hits context) join the hooks manager alongside the existing code-minimization hook.
  • Compact instructions — scaffolded/AI-generated CLAUDE.md now includes a # Compact instructions section that steers Claude Code's auto-compaction toward what matters; the audit offers to add one (i) if it's missing.

Daily token tracking (⚙ Usage stats → d)

Per-day table of the last 14 days — tokens in/out/cache, est. cost, sessions, bar chart, today highlighted, live plan-window % alongside. Optional daily_token_alert badge on the main screen when today's tokens cross your threshold.

Workspace provenance & freshness

  • Provenance manifest — <project>/.claudectl/workspace-manifest.json records where generated context came from: repo HEAD, source-file hashes (CLAUDE.md/README/configs), sessions analyzed (count + range), CLAUDE.md files, MCP server snapshots + tool counts, and last-run timestamps for scaffold / AI-analyze / launch. Updated automatically after those operations (best-effort — never blocks them).
  • Freshness check — claudectl workspace status (run inside a repo) or w in the sessions menu shows 🟢 Fresh / 🟡 Stale / 🔴 Invalid per component and an overall freshness score. Detects when the repo HEAD moved, README changed, or new sessions accrued since the memory was generated, plus a safe_to_launch flag. Status is read-only — viewing never mutates the manifest.
  • Change diffs — when AI-regenerating CLAUDE.md (a) or a system prompt (s), the approval step shows a git-style colored diff (old → new) so you decide before writing (f toggles to the full proposed text; ENTER approve, ESC reject). The previous version is snapshotted under .claudectl/snapshots/, so the workspace screen (w) lists recent changes with +/− counts and re-opens the last diff on c (CLAUDE.md) / s (system prompt).

Hooks

  • 19 ready-made templates — one-key install, toggle, or remove (edits settings.json safely). Formatting (Prettier, Ruff, ESLint, gofmt), safety guardrails that block dangerous tools (rm -rf, git reset --hard, force-push, sudo, curl; reading .env; writing secrets — exit-code-2 blocks), audit/notify (log Bash commands, beep on finish / when input is needed), context injection (git status at session start; a compact code-minimization rule that curbs over-engineering — inspired by Ponytail), and token savers (concise-output trims narration and re-printed code; filter-test-output pipes test runs through a failures-only filter before the output enters context). Guards/blocks run as bundled Python (shell-agnostic); formatters no-op when the tool is absent.
  • AI-generate a hook — describe what you want in plain language; Claude returns a validated hook spec (event + matcher + command) you preview and confirm before it's saved.
  • Remove broken/legacy hooks — one action purges hook commands that error under a bash hook shell.

Model failover — retry a dead model instead of hanging (⚙ Settings → Failover)

Claude Code sends every turn as a fresh request and, when one fails, retries the same request against the same model with backoff. So a model deregistered upstream, or a tool schema the backing provider rejects, makes a session look frozen forever — nothing ever tries a different model, because Claude Code has no such concept.

claudectl's failover proxy sits between claude.exe and the OmniRoute upstream. It forwards bytes verbatim and, when a turn errors before any response body byte has reached the client, rewrites the request's model and tries the next candidate. Request-level retry is per-turn failover, because every turn is its own request. The routing log is the point — the original complaint was not "a model died", it was "I could not see that a model died" — so it runs in its own console window unless you hide it.

Configure the fallback list, port and log visibility in ⚙ Settings → Failover (GUI: Settings → Failover), or drive it directly:

claudectl --failover-serve [port]   # run the proxy in the foreground
claudectl --failover-stop           # terminate the daemon named in the lock file

It runs as a detached child so closing claudectl does not leave every live session with connection-refused, binds 127.0.0.1 only, and requires the configured OmniRoute key — claudectl hands that to the session as ANTHROPIC_AUTH_TOKEN, so no extra setup is needed. Requests carrying browser fetch metadata are refused outright: the proxy spends your upstream quota, so a web page must not be able to reach it.

Status line (claudectl statusline)

Renders the Claude Code status line: model, cwd, git branch and worktree, context pressure, and the 5-hour / 7-day rate-limit windows. Install it from ⚙ Settings, or point statusLine in settings.json at:

"<python>" -m claude_sessions statusline

It runs on every conversation turn, so it is built to be cheap: the subcommand is dispatched before the TUI or the usage poller is imported, the branch is read straight from .git/HEAD, and repo state comes from a disk cache that never spawns git. The rate-limit and context numbers come from the payload Claude Code already sends — no network call is ever made.

Checkpoints (sessions menu)

Read-only view of Claude Code's own file-history store: the whole-file snapshots it takes before edits, paired with the files the session actually touched. The store is undocumented, so claudectl never decodes the snapshot names — it hashes the paths the session edited and looks those up, which means a change to the scheme surfaces as "cannot read the store" rather than as filenames paired at random. Restoring is left to Claude Code's own /rewind; claudectl only reads.

Usage analytics

  • Usage stats dashboard — tokens (in/out/cache) and estimated cost per project and per session, parsed from local transcripts; cached for instant reopening
  • Plan usage — daily/weekly limit bars with reset times shown on the main screen

Per-project launch control

  • Effort / model / permissions / agent — reasoning effort, model override, --permission-mode, and --agent before each launch; effort/model/permission remembered per project
  • New-session options — name the session (-n) and launch in a git worktree (-w)
  • Extra PATH entries / Add directories — per-project PATH dirs and --add-dir context roots

Desktop GUI (claudectl --gui)

Everything above, as a native desktop app — full feature parity with the TUI, served locally (loopback-only, works offline). No Python dependencies; the browser bundle vendors three.js and anime.js (both MIT, served from /vendor/, never a CDN):

  • Shells — PyQt6 native window if installed, else an Edge app-mode window, else the browser (gui_shell setting: auto / qt / edge / browser). The bottom-left toggle (or ui_mode) picks which interface starts by default; --tui/--gui always override.
  • Projects & sessions — sidebar with live filter and quick-resume; per-session resume / fork / rename / tag / archive / restore / delete / export markdown / transcript with session info / changed files.
  • Launch modal — effort, model, permission mode, account, thinking cap, subagent model, session name, worktree — as one-click chips, prefilled from your defaults. Sessions open in a real new console window.
  • Project tabs — Memory (build / ask / recall preview / lessons review / workspace status, with live scan progress), CLAUDE.md (view / scaffold / AI analyze / AI compress / prune / edit + memory files map + system prompt), Audit (context weight + deny rules), Usage, Plan → Execute (plan model + effort, execute via Anthropic or free OmniRoute, full explanation inline), Tools (inject context from any session/account, project agents picker mirroring the TUI's category multi-select with suggestions, extra PATH entries, --add-dir directories), and the architecture Graph.
  • Managers — MCP servers, agent library + AI-generate, hooks + AI-generate, accounts — same operations as the TUI, with the same diff-approval gate for AI-written files (jobs run server-side, you approve a git-style diff before anything is written).
  • Usage banner — one live bar-row per account (session/weekly/model windows with reset times), auto-refreshes every minute, refresh button for an immediate re-fetch.
  • Themes — all 17 TUI palettes restyle the whole app (backgrounds, panels, text — derived from each theme's hue); pick in Settings with live preview before saving. Icons are inline Material SVG — no CDN, no emoji.

GUI enhancements (latest)

  • Stacked toasts — multiple simultaneous notifications (errors, success, info) stack instead of overwriting; each auto-dismisses after 3.5 seconds.
  • Job cancel — running background jobs (plan generation, memory build, review) show a Cancel button; cancelled flag is cooperative (checked at loop top, no thread kill).
  • Persistent preferences — theme and account selection saved to localStorage, restored across page reloads.
  • Editable Plan → Execute — generated plan appears in a monospace textarea for inline editing before approval; "Re-plan" button sends feedback to regenerate; "Per-step approval" checkbox gates execution step by step.
  • Plan persistence — every generated plan is auto-saved to last_plan.json; save_plan()/load_plan() helpers for programmatic access.
  • Skills / Worklog / Review / Model-routing panels — all already integrated: Skills manager, worklog toggle + entry history, one-click code review (working diff or staged-only), and OmniRoute free-tier configuration — all surfaced with zero extra deps.
  • Error surfacing — job failures show the error message in a red toast instead of a generic "Failed".

Quality of life

  • Themes (17) — switch palette in Settings (live preview, cursor stays on the selection): default, ocean, forest, mono, ember (red), plus Catppuccin Mocha, Catppuccin Latte, Tokyo Night, Dracula, Nord, Gruvbox, Rosé Pine, Kanagawa, Everforest, Ayu, Monokai Pro, Solarized
  • AI session titles — unnamed sessions show their AI-generated transcript title
  • Settings screen (⚙) — editor, claude.exe path, config dir / account (CLAUDE_CONFIG_DIR), theme, and default launch options (~/.claude/claudectl.json)
  • Confirm dialogs & multi-select — modern yes/no and checkbox pickers throughout; command keys accent-colored on every screen
  • Help screen — press ? for a keyboard reference