Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

The panel

The web panel (web/, SvelteKit) is served by the hub at / and is built phone first. Every view can be narrowed to workspaces and hosts: the scope is kept per device (browser storage), across pages and reloads, until you change it. The time range and the analytics section live in the URL, so links can be shared and the back button works.

  1. Now and Sessions
  2. A session’s page
  3. Projects
  4. History and Analytics
  5. Machines, Claude state and Workspace
  6. Themes
  7. Desktop (DankMaterialShell)

1. Now and Sessions

  • Now is the page to leave open on a second monitor; a look at it should replace opening the sessions. What needs you has the answer inline (permission prompts, questions, plans, sessions on your turn with a quick reply) and Resolved and Kill at hand. Every session that needs you or is working shows what you asked, what Claude last said, its last steps with the running one under them (failures in red with their error), tasks, subagents, the files of the turn and its numbers. A working session that has sent no hook for 10 minutes (30 while a tool runs) says “quiet” with how long: most likely a hung command or a dead process. The other open sessions follow in a line each. On wide screens a column beside them holds the limits, the system (machines and their link, open issues, the workspace sync, Claude’s state) and the last progress across projects by day, with the issue and the session of each entry; a phone stacks them. Start a session is here (sessions).
  • Sessions groups every session: those that need you, then working, parked and idle, then the ones Claude started (which show the session that started them and “Finished” instead of “Your turn”).
  • Sessions › Past is every earlier conversation the hub holds, from every machine: a search over what was said, filters for the machines (any number), project and time, cards with what you asked and where it ended, an overview and the conversation beside the list, and Resume… on the machine you pick (sessions). Resume… on Now opens it.
  • A session left on your turn for an hour is parked: most likely done, it no longer counts as needing you.
  • Every session card has an Actions menu: Open on, Resolved, Keep open, Resume, Kill, Forget, whichever apply (sessions).

Limits on Now

Each limit’s tile draws its current window behind the numbers: the readings so far, a dashed line to where the recent pace leads at the reset, and a faint diagonal for an even pace, so a line above it is running hot. Hovering reads the value off the line and a click opens Analytics › Limits. A window that reset with no reading since says so, rather than keeping the old number.

2. A session’s page

TabShows
Chatthe exchanges with Claude’s text, its steps, subagents, task notifications, subagent messages, messages between sessions
Shellits Bash calls as a terminal transcript with their output
Detailsthe project (pick one), the turn, files, tasks, processes, the claim, totals

Steps are the tool calls between Claude’s messages, written to be read at a glance: a run of them has one line (“Ran 9 commands, edited 2 files · 1 failed · 2m”) and its time range; each step is a sentence with an icon for what kind of thing it is: for a shell command, what Claude said it does (“Run the tests through the dev env”, the command dim below it; older calls, recorded before the description was kept, show the command), for files “Edited src/state.rs”, for searches the pattern, for a plugin tool its server and action with the argument that tells most (“playwright: click Units tab”). Consecutive reads, edits or searches of one kind fold into one row (“Read 4 files”, their names below). A failed step is red with the error’s first line. Tap a step for the command, its output and when it ran; the Shell tab has every command in full. The run of the exchange Claude is working on stays open, older ones are folded.

The block under the newest exchange shows what is happening now: the state, the running tool (what it does, the call below), the text Claude is writing, the turn’s tools and files, subagents and tasks, and a pending Stop (sessions).

Code blocks in replies, notes and the steps of a command have syntax colours in the theme’s palette, line numbers (kept out of a selection) and a copy button. A language the panel does not know, or a chunk it could not fetch, leaves the block plain.

Task notifications are what Claude Code tells a session when a background task reports: a subagent finished, a background command exited, a monitor saw an event, an MCP task completed. Subagent messages are a subagent’s report handed back, or a message it sends while it runs. Both reach the hooks as if you had typed them; the hub records them apart, so the chat shows them on Claude’s side in their own colour (what it is, the subagent’s or task’s name, the outcome, the report or event) and they never count as your prompts: not in the prompt history, the session’s last prompt, prompt counts or waits. A notification Claude Code appends to Claude’s text, when one arrives while Claude writes, is cut from it; Claude Code delivers it again on its own.

Open prompts are pinned above a composer that sends a turn through the channel or leaves a note for the next prompt; while Claude works, Stop interrupts the turn, so what you type next is what Claude reads (sessions). The composer is an editor made for long prompts: Enter is always a new line and only Ctrl Enter sends, on every device; it wraps, highlights markdown lightly, keeps an undo history that survives what the toolbar inserts, and Expand (Ctrl Shift F) gives it most of the screen. Vim keys are off until Settings › Composer turns them on (On, or Auto: on with a mouse, off on touch); it also holds a vimrc of maps they start with (jk leaves insert mode, Space w is :w); :w keeps the draft now, :x is done editing. Line numbers (none, absolute, or relative to the cursor’s line with the current one absolute, as Neovim’s number + relativenumber; Auto is relative with vim keys), the markdown highlighting and the wrapping are switches there too, kept per device. Two more go with vim keys, each a switch: the system clipboard is the unnamed register (yanks and deletes go to it; the browser’s paste keys, Ctrl Shift V and Shift Insert, paste as p does with no prompt anywhere, and a bare p reads the clipboard, which is a permission: Chromium asks once, Firefox puts a small Paste button under the cursor whenever the text came from another program, unless the helper below is installed; Settings can make p read the register instead), and hop: , in normal or visual mode, then two characters, labels every match in view with the keys you set (asdfghjkl, nearest match first, two-character labels when one does not suffice) while the rest of the text dims and a line under the text echoes what was typed; the label puts the cursor there, or in visual mode extends the selection through it; Escape or any other key cancels. When a message starts with / the composer offers the skills Claude Code loads for that session (the machine’s, the plugins’, the workspace’s), as the terminal does.

The field and its buttons are one frame, and the buttons are one row on every screen, so the chat keeps the height:

  • + adds to the prompt: a photo or a file (attachments; pasting a screenshot or dropping files on the field does the same), a template (Settings › Composer holds them), a [[note]] link, a skill, the text opened in your editor on a machine (below), and the panel’s keys.
  • The microphone dictates (Ctrl Shift D): it records, a machine puts the recording into words, and they land at the cursor to read over (dictation). It shows when a connected machine offers it; on a phone it takes Expand’s place in the row, and Expand moves into +.
  • Aa shows the formatting bar above the text: bold, italic, strikethrough, code, a code block, a link, lists, a quote, a heading, and Preview, which renders the markdown in place. Each button works on the selection and takes its mark away again when it is there. The bar stays as you left it on each device; it is off at first, since with vim keys or on a phone it is rarely worth its row.
  • Prompt history (Ctrl R) is a dialog over every prompt of the session and its workspace. The search takes several words in any order and asks the hub, so it reaches past the recent prompts; matches are set apart. Each prompt shows its session, its time and its length, a wide screen shows the picked one in full beside the list, a phone opens it in place. Enter or a tap uses it instead of the text (undo brings the draft back), Shift Enter inserts it at the cursor.
  • Expand (Ctrl Shift F), then the session’s own buttons: Stop while Claude works, Send, Next prompt.

? anywhere outside a field, or Keys and help at the end of the sidebar, lists every key:

KeysDoes
Ctrl EnterSend (Enter is a new line)
Ctrl Shift EnterNext prompt instead of a turn
Ctrl Shift 1–9That quick reply
Ctrl .Stop the turn
Ctrl GEdit in the editor on a machine (below)
Ctrl Shift FExpand the field, and back
Ctrl Shift DDictate; again to finish
Ctrl JGo to the open question
Ctrl ↑ Ctrl ↓Walk the prompt history
Ctrl RSearch the prompt history
Ctrl B Ctrl IBold, italic (with vim keys: in insert mode)
Ctrl ECode block around the selection
Ctrl PPreview
Esc, then iLeave the field (vim: normal mode), come back
?Every key, outside a field
Ctrl KSearch everything

The Firefox helper. Firefox lets only extensions read the clipboard without its Paste button (the clipboardRead permission is checked on the extension, never on a site), so firefox-ext/ holds one of a few lines: a content script on the panel’s origin that answers the page’s request for the clipboard. With it, p reads the clipboard at once, as in Neovim; without it the page falls back to the browser’s own read and its prompt. Settings › Composer says whether it is on the page. To use it: set matches in firefox-ext/manifest.json to your hub’s address, sign it (release Firefox installs signed extensions only; web-ext sign --channel unlisted with an AMO API key, from nix run nixpkgs#web-ext, gives an .xpi in a minute), then install the .xpi from the file, or through Home Manager with buildFirefoxXpiAddon from the NUR. The extension asks for nothing but reading the clipboard, and answers only the page it runs on.

Drafts live on the hub. What you type is kept there after a short pause (and on the device meanwhile), so a prompt begun on the phone is on the desktop, a reload or a closed tab loses nothing, and the start sheet opens with what you left in it. A draft is dropped when its prompt is sent, or after 90 days untouched.

Edit in the editor (Ctrl G, the terminal button) opens the draft in an editor on a machine, as Claude Code’s own Ctrl G opens the prompt in $EDITOR: the collector there writes the text to a file and runs its edit.command (off by default; the Home Manager module’s terminal and editor set it, such as ghostty -e nvim {file}, configuration); the field waits, with Cancel, until the editor closes, then takes the file’s content. Exit without saving (:cq) and the text stays as it was. Which machine: Settings › Composer names one; else the machine this device sits on, which the hub tells from the address (a connected collector linking from the same one; behind the module’s nginx the client address is passed on); else the session’s own machine; else the first connected one whose collector has the command. A machine without the command cannot be picked; one that disconnects while the editor is open frees the draft, and the text saved later still lands when its collector comes back.

The title renames in place; Open on and Resolved sit beside it, the other actions in its Actions menu, Resume at the foot once it ended (sessions).

3. Projects

Each workspace’s projects with their board (open issues), live sessions, progress, documents, memories and the note graph, and a reader and editor for every note (knowledge).

Search is one thing everywhere: the box on Projects and Ctrl K, from any page. It looks through every note’s title, summary and body by word prefix, ranked across workspaces (those in the scope), with the matching text shown. Narrow it by kind (or kind:issue in the text), order it by best match, newest or most recalled, and leave out retired notes, which otherwise come after the live ones. Ctrl K finds sessions and pages too (and offers to search the past sessions for the text), and a note opens beside the page you are on. Typing [[ in the composer searches the same way and inserts the link.

Graph is for exploring what the notes say about each other.

  • Search (/) is the same full-text search: matches stay bright and the rest dims, n steps through them, Only matches hides the others.
  • A click selects a note: it and its neighbours stay bright, and the panel beside the graph shows its links to walk along. A double click, or Open, reads it. With nothing selected, the panel has the numbers and the most linked notes.
  • Local graph (l) keeps only what is within 1 to 4 links of the note.
  • Path from here (p), then a click on another note, finds the shortest way between them.
  • The bar filters by kind, project, retired notes and notes without links; the slider goes back in time and plays the growth.
  • Display sets the colour (kind, project, age, links, recalls), the size, the layout (free, by project, along a timeline), which kinds of link count and the physics. It is remembered on the device.
  • 2D or 3D (d). 3D uses WebGL and is fetched the first time it is asked for; drag rotates, the wheel zooms, right drag pans. Layouts are 2D’s.
  • Full screen (f). Notes and the start sheet open on top of it.
  • 0 fits the view, Esc steps back: the path, the selection, the local graph, then full screen. Two fingers zoom on a phone.

In the graph, on any note, opens the graph with that note selected.

Work on this, on an open issue’s card and in the issue itself, opens the start sheet with its workspace and project picked and a prompt written, to edit. The session claims the issue as soon as it reports, so the card moves to In progress with the session on it.

Progress is a timeline, newest day first (with its entries, issues and sessions counted): each entry with its time, title and first lines, the issue it is on and whether that is open or closed now, the session that logged it (a link, with its host) and the project. All of it unfolds the whole entry in place.

4. History and Analytics

History draws the sessions of a time range as lanes coloured by state, with the totals, time per project, the most used tools and the 5-hour limit over time.

Analytics sections:

SectionAnswers
Overviewdaily activity, when you prompt (weekday × hour), work per prompt, cost, lines changed, CPU and memory per project
Waitshow long sessions waited on you and how fast you replied, apart from parked time
Parallelhow many sessions worked or waited at once; time everything waited with nothing working
Limits5-hour, 7-day and per-model weekly limits, their pace, each workspace’s share
Projectstime, prompts, cost, lines, tool calls, compactions and CPU per directory
Turnswhat fills a turn, the slowest tools and commands, the commands that fail most
Contextcompactions and how full sessions got
Tokenstokens by type, cache hits, API latency, commits, edits by language (needs telemetry)
Permissionswhat asks you most, grouped by the rule that would cover it, how you answered

A wait runs from Claude handing the turn back to what came next: a reply within an hour counts as waiting on you; a later reply, closing the session or leaving it open counts as parked; Claude carrying on by itself (a task notification, a wakeup) counts as neither. Permission prompts always count.

The time range in the top bar: quick ranges or an exact span, ‹ › to step, ⊖ to double it, and dragging across a time chart zooms in. Every chart has a tooltip and a table view.

The Tokens section and the approval sources under Permissions need Claude Code’s OpenTelemetry export: services.ccdash.claudeCode.telemetry.enable sets the OTEL_* variables and starts a receiver in the collector on 127.0.0.1:7839. It keeps counts and timings only; prompt text stays redacted, as Claude Code sends it by default.

5. Machines, Claude state and Workspace

The sidebar has three groups, a line between them: the work (Now, Sessions, Projects, Reports), what is kept and measured around it (Files, History, Analytics, Machines, Claude state, Workspace) and the panel’s own (Settings, Keys and help). Files lists what was attached to prompts and is still on the hub, with Keep and Delete (attachments).

Machines shows the hub’s own machine (uptime, CPU, temperature, memory, disks, system), then every node, that is every machine with a collector. A node’s card has how it is doing (up, CPU, temperature, memory, battery), its link and round trip, the sessions on it, its copy of Claude’s state, its share of the workspace sync, whether its screen is unlocked (with Lock), and Wake while it is down. A node’s page starts with the machine itself:

  • tiles for uptime (with the time slept and the last resume), CPU, memory, each disk and the battery
  • the OS, the kernel and whether a reboot is pending
  • its power: Lock, Suspend, Wake, Forget (machines and power)

Then it gathers what the other areas know about the node:

  • the sessions on it now
  • Claude’s usage there over the range in the bar (sessions, working time, cost, lines, CPU, activity by state)
  • its copy of Claude’s state
  • its workspace sync (units in step, what moved and what it cost in the range, the units not in step there, its large transfers)

Host names on the Now page and in the Workspace area open it.

Claude state is each machine’s copy of ~/.claude (the state sync): machines with Resync, conflicts with their resolutions, sizes and growth.

Claude state and Workspace are in the sidebar only while their sync is on (a collector with sync.enable, a hub with workspace.enable); so are their lines on the Now and Machines pages. Each collector tells the hub what it does, so Open, Edit, Start and Resolved show only on machines that can.

Workspace is the workspace root on every machine (the workspace sync), in sections: Overview (the tiles, what needs you with the buttons at hand, the machines in a line each, the last day’s traffic, the units that changed last), Units (a sortable table with a search, state filters and a chip per machine, new directories, held snapshots, conflicts; a unit’s page with its state on every machine, diverged branches, conflicts, the ignored directories with a switch each, overrides and the snapshot history), Machines (a card per collector: the link’s round trip, what it moved today and this week, the rate of its large transfers, what the sync cost in CPU, I/O and memory), Statistics (the range in the bar, a year back: traffic, pushes, CPU and memory per machine, the hub’s repositories, conflicts) and Configuration (the rules with live match counts and what each never- travelling name keeps home, previewed by the hub as you type; then the coverage: what travels and what stays home on every machine, and why).

6. Themes

Settings › Appearance › Size sets how big the panel is on this device: text, buttons and spacing change together, in five steps from Smallest (80 %) to Largest (125 %). Auto, the default, is Small (87.5 %) on a phone and Normal on a tablet or a computer: a phone’s own apps set their text a size under a web page’s, and at Normal the panel’s bars take the room the chat needs. A zoom set in the browser, or in an installed app’s site settings, applies on top; set it back to 100 % before judging the sizes.

The theme menu in the top bar and Settings › Colours pick the mode (system, light, dark) and the colour scheme, per device: Neutral, ccdash, Catppuccin, Gruvbox, Nord, Tokyo Night, Rosé Pine, Everforest, Kanagawa, Solarized, Dracula (dark only), or Wallpaper.

Wallpaper follows a machine’s desktop colours, as they change. The collector reads them from the files the desktop already generates, on every machine that has one, and reports them to the hub, so the phone can follow them too:

Read firstOtherwise
DankMaterialShell/dms-colors.jsonwal/colors.json

Both under $XDG_CACHE_HOME (~/.cache).

DankMaterialShell’s has both modes and Material’s colour roles; pywal’s has one mode, which then decides light or dark. The newer file wins, so running wal on a machine that used to run DankMaterialShell takes effect. pywalfox needs nothing here: it shows the same wal/colors.json in Firefox, and a page cannot read an extension. With several machines reporting, Settings › Colours picks which one to follow; a machine that stops reporting leaves its last colours in place.

A palette names colours, not meanings: pywal fills its slots in any order. So the panel takes each state’s hue from the nearest colour the wallpaper has, makes one at the wallpaper’s strength when it has none, and moves lightness until text reads against the background (web/src/lib/theme.ts).

7. Desktop (DankMaterialShell)

services.ccdash.dms.enable = true links the plugin into DankMaterialShell: a bar pill with the sessions that need you, a dash tab and card, notifications when a session starts waiting, and dms ipc call ccdash focusWaiting to jump to the session that has waited longest. Enable it once under Settings → Plugins and add the widget to a bar. niri binds:

Mod+C { spawn "dms" "ipc" "call" "dash" "toggle" "plugin_ccdash"; }
Mod+Shift+C { spawn "dms" "ipc" "call" "ccdash" "focusWaiting"; }

Clicking a session focuses its terminal window. The plugin opens the panel without a token, so pair the desktop browser once (security).