cc-outline: a viewer for Claude Code in a split pane

cc-outline (command cco) is a terminal viewer for Claude Code that runs in a split pane next to it, in Windows Terminal or tmux. It has seven views:

• Chat renders the answers of the current session as proper Markdown: headings, lists, tables and code blocks with syntax highlighting. It follows the session live.
• Changes lists the files changed in the git repository, and in the repositories in the folders below, and shows their diffs with syntax highlighting.
• Plan shows the plans Claude presented in plan mode, with their status and what changed between versions.
• Sessions gives an overview of your sessions across all projects: when, where, how long, which plans and which changed files. From there a session continues in a new terminal tab, in another Claude account, is exported (Markdown, JSON and a backup to import elsewhere), or goes to the trash. With several accounts it lists their sessions too, each marked in its account's colour.
• Monitor charts how fast Claude answered over the day: output tokens per second, the wait for the first block and the number of responses, compared with the usual values at that time, plus errors such as usage limits.
• Accounts (0, or a click on the "cco" at the left of the top bar) lists the Claude accounts on this machine (config folders ~/.claude*) with their details: organization, plan, colour, whether the cco plugin runs there, the Claude Codes running with them and their sessions of this project. Enter on an account offers to continue the current session there, to start a new session there, or to open its config folder. It also sets up a new account (config folder, start script, cco plugin) and moves one you no longer need to a trash. See Sessions and accounts.
• Settings lists all options in one place: whether the viewer opens by itself when Claude Code starts, and the display options of the other views.

Besides the pane, the Remote Control Viewer (cco rc-viewer or /cco:rc-viewer) is a window of its own that watches every session at once: of every project and account on this machine, and the Remote Control sessions on other machines. It shows which ones wait for you, lets you answer them and sends them prompts. See Every session in one window.

Why

Working with Claude Code in the terminal has seven blind spots. cc-outline fills them without leaving the terminal and without interrupting Claude.

1. Answers are hard to read and quickly gone

The problem. Claude answers in Markdown, but the terminal shows much of it as plain text. Tables lose their shape, and headings and emphasis blend into the text. A plan with several steps looks like a wall of text. Long answers scroll past while Claude keeps working. To read an earlier answer again you scroll back through tool calls and output, and the prompt that answer belongs to is somewhere above it.

How cc-outline solves it. The Chat view renders each answer as Markdown, with real tables, headings, lists and highlighted code. The session is organised by prompt: every prompt is one entry in a list. Select one and you see exactly its answer, with the prompt pinned above it and tool noise hidden. The view follows the running session live and stays at the bottom like Claude Code. You can scroll up at any time without losing your place, and each turn remembers where you left it. Important answers can be marked with Space and found again after a restart.

2. You don't see what Claude changed

The problem. Claude edits files as it goes. The terminal only shows short summaries such as "Updated with 10 additions and 1 removal". To review the actual change you open an editor or run git diff in another window, and then find your way back to the conversation. Claude often touches several files, so reviewing them costs time and focus. Changes also get accepted without a real look.

How cc-outline solves it. The Changes view lists every changed file of the repository: modified, added, deleted and untracked. It shows each diff with line numbers and syntax highlighting, right next to the conversation that caused it. It refreshes every two seconds while Claude works, so you watch the changes appear. You can jump between hunks or open the whole file as it is now. The branch shows at a glance how many commits are waiting to be pushed or pulled.

3. Plans get lost once work starts

The problem. In plan mode Claude writes a plan and asks for approval. Once you approve it, Claude starts working and the plan scrolls away under tool calls and output. To check what was agreed, or whether a step was skipped, you have to scroll back and find it. If you reject a plan with feedback, Claude writes a new version, and nothing shows what changed compared with the one you rejected. Which versions were approved or rejected, and why, is hard to reconstruct later.

How cc-outline solves it. The Plan view lists every plan of the session with its time, title and status: approved, rejected or waiting for your decision. The selected plan stays readable next to the session while Claude carries it out, with the prompt it answers pinned above it, and for a rejected plan your feedback. Enter shows what changed compared with the previous version as a diff, so you only review the changes. Plans appear as soon as Claude writes them, before they are presented and before you decide, and can be marked like answers and files.

4. Past sessions are hard to find, resume and clean up

The problem. Every session is kept, in every project, but only as JSONL files with random names. /resume offers them by title and time. What a session was about, which plans it had and which files it changed only shows once you resume it, and that takes you out of the session you are in. Nothing deletes old or failed sessions, so the list only grows.

How cc-outline solves it. The Sessions view lists the sessions of this project or, with its filter (a), of all projects with their project, name and time. For the selected session it shows when and where it ran and for how long, on which branch, its plans with their status, the subagents it started, the files it changed and its prompts, all without resuming it. Enter continues it in a new terminal tab in the right folder, and c copies the claude --resume command instead. Sessions you no longer need go to a trash with d, where they can be restored until you delete them for good.

5. Several Claude accounts don't know of each other

The problem. Many people run Claude Code with more than one account: a work and a private one, or a team plan next to a personal one, each in its own config folder (CLAUDE_CONFIG_DIR). Claude Code shows nothing of the others. Which account a terminal runs is easy to mix up, and /resume lists only that account's sessions. Setting up another account means writing a start script by hand, and a name like cp or sc quietly runs a PowerShell command instead. Nothing removes an account you no longer use.

How cc-outline solves it. Every account gets a colour and, if you like, an avatar ((^_^), 🦊, ☕💻 or your own): the "cco" at the left of the top bar shows them, and the terminal title ends with the avatar. The Accounts view (0) lists all accounts on the machine with their organization, plan, plugin, running Claude Codes and sessions. The Sessions view's filter (a) lists the sessions of the accounts you check in one list, each with a bar in its account's colour. Any session continues in another account in a new window, the viewer moving along. How to add an account sets one up with Enter and refuses names a shell would run something else for, and d moves an account to a trash, after asking twice, from where it can be restored.

6. A usage limit stops the work

The problem. With more than one account, say a team plan and a personal Max plan, one of them sooner or later reaches its usage limit in the middle of a session. Claude Code stops, and it only goes on after the reset, hours later. The other account still has capacity but does not know the session: it lives in the first account's config folder, and /resume lists only the account's own sessions. In the other account the whole context is missing: the plan, what was discussed and decided, which files are already changed. You start over or explain everything to Claude again.

How cc-outline solves it. Enter on the session in the Sessions view, then Continue it in …; /cco:account <email> does the same from Claude Code, and so does the Accounts view. The session stays as it is, running or not, and so does its viewer. Where the other account lacks the cco plugin, it is installed first. cco then copies the conversation into the other account, with its predecessors from before a /compact, its subagents, file history, pasted images and cco's own marks and positions; the original stays as it is. The copy starts in a new window under the other account, which opens a viewer of its own there (as the auto open setting says): its colour and email show the new account. Claude has the whole history and goes on where the limit stopped it. In the Sessions view the original is marked ⇢ and the copy ⇠, so you can tell where the work went. Once the first account is free again, the session comes back the same way.

7. Sessions on several machines are hard to keep an eye on

The problem. With Claude working in several sessions at once, in a few terminals here and on another machine, you keep checking each one: is it done, does it wait for an answer, did it stop at a permission? Every Claude Code shows only its own session. The ones on another machine are out of sight, unless you open each in the Claude app or on claude.ai, one at a time, with no overview of what waits for you. A question that waits unseen holds up the work for as long as it waits.

How cc-outline solves it. The Remote Control Viewer (cco rc-viewer) is one window for all of them: every session of this machine, of every project and account, and the Remote Control sessions of your other machines, grouped by what they need (Waiting, Working, Idle, Ended). A session that waits for you blinks, and so does one that has just finished; n jumps to the next of them. Beside the list it shows the selected session's turns and chat, live. Its question or permission shows in the prompt line's place: for a session on another machine, or one of this machine connected with Remote Control (⇄), you answer it right there, otherwise Enter brings its terminal to the front. The prompt line below sends any of them a prompt, and Enter offers what fits: interrupt it, continue an ended one, make a session steerable with /remote-control.

In daily work

• Review while Claude works. Keep the approved plan in the Plan view and check the resulting diff in the Changes view, both next to the running session.
• No context switch. No editor, no second terminal, no git diff. One key (1–6) switches views, alt+← returns to Claude Code.
• Better answers stay useful. Tables, code and step-by-step plans are readable, and you can copy an answer's Markdown with c for a ticket, a PR description or documentation.
• Long sessions stay navigable. Prompts are listed with their time, prompts sent while Claude was busy are marked, and marked turns survive restarts, --continue and /resume.
• Pick up older work. Find yesterday's session in the Sessions view by its plans and changed files, and continue it in a terminal window of its own.
• Switch accounts without losing the thread. When one account reaches its usage limit, continue the session in another one from the Sessions or the Accounts view; the copy keeps the conversation, and the viewer follows it there.
• Everything stays where you left it. Every list keeps its selected entry and each entry's scroll position, also across restarts.
• Nothing to manage. The plugin opens the pane with /cco:chat, /cco:git, /cco:plan, /cco:session, /cco:settings or /cco:monitor, follows the active session, closes it with the session and opens it again on every start (with auto open set to remember: only if it was open).
• Set up once, in one place. The Settings view (6 or /cco:settings) lists every option with its default: whether the viewer opens by itself, whether quitting asks first, whether long entries scroll and positions are remembered, and the display options of the other views. A change applies at once in all views and all projects.

Sessions and accounts

cc-outline manages your sessions and your Claude accounts from the pane next to Claude Code:

• Every session, every account. The Sessions view (4) lists the sessions of this project, of the others or of all, of the accounts you check, with or without the background sessions (claude -p, the SDK, the daemon; marked ◌): a opens the filter. A bar in the account's colour marks each row once other accounts are shown, and the header names the account, its organization and folder. See the Sessions view.
• Continue anywhere. Enter on a session continues it here (/resume typed into Claude Code), in a new window (a viewer without a Claude Code can move along), or in another account: a copy of the conversation goes on there, with the cco plugin installed first where it lacks it, and the original keeps running if it runs. /cco:account work does the same from Claude Code.
• Accounts at a glance. The Accounts view (0, or a click on the "cco" at the left of the top bar) lists the accounts found (~/.claude*), the active one first, with organization, plan, colour, the cco plugin, the Claude Codes running with each and its sessions of this project. Enter starts a new session in an account or opens its folder. See the Accounts view.
• Add an account. How to add an account explains the setup and does it with Enter: config folder, start scripts next to claude (cw.cmd and cw), cco plugin, and a window to sign in with /login. Names that a shell would run something else for are refused (PowerShell aliases such as cp or sc, built-ins of cmd and Bash, programs on the PATH).
• Clean up. Sessions go to a trash with d (T shows it, u restores). Accounts too: d on an account, or the menu's Danger zone, moves its folder and start scripts to the accounts trash after asking twice (the second time with the folder's name typed in). The default ~/.claude, the active account and accounts in use are refused.

Every session in one window

The Remote Control Viewer (cco rc-viewer, /cco:rc-viewer, or the row ⊞ Remote Control Viewer above the Sessions list) is a window of its own, one per machine, for keeping an eye on everything Claude does:

• One list for every session. The sessions of every project and account on this machine and, with Sessions: remote API, the Remote Control sessions of your other machines (◈), grouped by what they need: Waiting, Working, Idle, Ended. Each row tells how long it has been so.
• See what waits for you. A waiting session's ⚠ blinks, here and in the Sessions view; one that has just finished blinks its ● until you have looked at it. n goes to the next of them, the one waiting longest first.
• Answer from here. What it waits for shows in the prompt line's place, the question with its options or the tool with its command. A session on another machine, or one of this machine connected with Remote Control (⇄, Sessions: steer remote on), is answered right there; any other is answered in its terminal, which Enter brings to the front.
• Send prompts. Space or a click gives the prompt line the keys; it writes to the selected session, into its Claude Code or through claude.ai, and keeps a draft per session.
• Act on it. Enter offers what fits the session: bring its terminal to the front, interrupt Claude, continue an ended one in a new window, make an idle one steerable (/remote-control typed in), open a session viewer, copy the resume command.

See Remote Control Viewer for the details.

Small screens

On a small screen, or in a narrow pane next to Claude Code, list and preview side by side leave both too narrow. The setting compact (Settings › General) switches the layout:

• stacked. The list is above the preview, both as wide as the pane. The list takes compact split of the height (10% to 50%, default 20%) and has compact columns columns (1 to 4, default 2), filled one after the other like a newspaper; < and > change the columns.
• single. One column: the list, and Enter (a detail) or | shows the preview over the whole pane, Esc or | goes back.
• Both leave out the help line (i still lists the keys), the status and the version, shorten the tabs to their number and keep the preview's header to one line.

Installation

Requirements:

• Node.js 22 or later
• Claude Code
• Windows Terminal or tmux, to open the viewer in a split pane

1. Install the CLI:

npm install -g cc-outline
cco --version

2. Install the Claude Code plugin. It provides the hooks and the /cco:open, /cco:chat, /cco:git, /cco:plan, /cco:session, /cco:settings, /cco:monitor, /cco:releases, /cco:update, /cco:restart, /cco:account and /cco:doctor commands. The npm package is its own plugin marketplace:

claude plugin marketplace add "$(npm root -g)/cc-outline"
claude plugin install cco@cc-outline

3. Restart Claude Code, then run /cco:chat, /cco:git, /cco:plan, /cco:session, /cco:settings or /cco:monitor. The viewer then opens on every start; set auto open to remember or never in the Settings view to change that.

Updating. When a new version is out, the top bar shows it (v0.7.0 → 0.8.0, in narrow panes ↑ 0.8.0) and the Releases entries in the Settings view (/cco:releases) show its release notes; Enter on update to v0.8.0 (or /cco:update, which checks right away and asks) runs the three commands below, then the viewer opens again with the new version (see Settings view). By hand: update the CLI and the plugin, then restart Claude Code. New commands such as /cco:settings only appear after the plugin update:

npm install -g cc-outline
claude plugin marketplace update cc-outline
claude plugin update cco@cc-outline

When something does not work (the viewer does not open on start, /cco:… takes seconds, a pane opens as a window), run cco doctor, see Usage.

To uninstall, run claude plugin uninstall cco@cc-outline, claude plugin marketplace remove cc-outline and npm rm -g cc-outline, then delete ~/.claude/cco/.

From source

npm install
npm run build
npm link            # makes `cco` available globally
claude plugin marketplace add <path-to-this-repo>
claude plugin install cco@cc-outline

To load the plugin for a single session without installing it, run claude --plugin-dir ./plugin instead.

Usage

• /cco:chat, /cco:git, /cco:plan, /cco:session, /cco:settings or /cco:monitor in Claude Code opens the viewer in a split pane (Windows Terminal or tmux), starting in that view. If a viewer is already running for the project, the command switches it to that view instead of opening a second pane. /cco:open opens it in the view the session was shown in last (with the setting view per session, else the chat) and leaves a running viewer as it is. /cco:releases opens the Settings view on the release notes and the update, if one is out. /cco:update checks for a new version right away, also with the setting update off, and asks in the Settings view whether to install it. /cco:restart closes the viewer and opens it again in the same place and view with the version installed now; if none runs, it opens one. /cco:accounts opens the Accounts view. /cco:account continues the session in another Claude account (see Continue it in another account… in the Sessions view); /cco:account work or /cco:account [email protected] names the account by its config folder or email.

• Where it opens: docked right of Claude Code (default), docked left, or in a window of its own, as the placement setting says. p in the viewer moves it: 1 right, 2 left, 3 window. The viewer closes and reopens there, keeping its selection and scroll positions, and the session remembers the place for the next time it opens (on start, /resume in a new Claude Code, /cco:…). A window takes the keyboard focus from Claude Code, also when it opens on start, since Windows Terminal cannot hand the focus back to another window. In tmux, window is a tmux window. A /cco:… command typed while Claude is working only runs when the turn ends; by then you may be in another tab, and Windows Terminal can only split the tab that is active then, so in that case the viewer opens in a window of its own (tmux still splits Claude Code's pane), and p docks it. A viewer that already runs stays where it is when you change the setting or /resume another session.

• cco (or cco watch) in a project directory starts the viewer by hand, in any terminal:

  • --cwd <dir>: the project whose session is shown
  • --session <id>: show this session instead (see Session viewer in the Sessions view): its chat, live, with a prompt line while it runs, and settings of its own
  • --view chat|git|plan|sessions|settings|monitor|accounts: view to start with (default: the session's last view, see view per session, else chat)

  A viewer started this way follows the project's latest session. To tie it to one Claude Code instead, select a session running in it in the Sessions view and press Enter (↵ attach), see Sessions.

• cco open opens the viewer next to the current pane like the /cco:… commands, with --view and --placement right|left|window (default: the session's placement, else the setting).

• cco import <zip> imports the session backups of an archive that the Sessions view exported into the current folder, see Sessions.

• cco doctor checks what cco needs and prints a report, one line per check (✓ fine, ! worth a look, ✗ error), with what to do below each problem:

  • Installation: npm install or checkout, the path the plugin starts cco by (~/.claude/cco/cli.json), whether the plugin cco@cc-outline is installed and enabled, and whether its version matches the CLI.
  • State files in ~/.claude/cco/ of all projects: those of Claude Code processes, viewers and viewers of one session (viewers/, before observers/ and remote-<id>.viewer.json) that have ended, unfinished writes (*.tmp), debug logs, files that are no valid JSON, records of sessions that ended over a day ago, the restore state of projects without transcripts, and trash folders without a readable manifest. Marks, positions and views are never touched.
  • Settings: values of the wrong type or unknown, unknown keys and old formats in settings.json and in settings.session-viewer.json (the viewers of one session's).
  • Environment: Node version, Claude Code's folder (CLAUDE_CONFIG_DIR), and the terminal (Windows Terminal, also without WT_SESSION, or tmux).
  • Hooks: while a Claude Code runs in the project (--cwd, default: the current folder), whether the plugin's hooks recorded its last prompt.

  It exits with 1 if an error is found. --fix repairs without asking what it can: deletes or renames (.corrupt) the state files above, records the CLI's path, rewrites settings.json with the values that apply, and for an npm install updates an older plugin (claude plugin marketplace update, claude plugin update; restart Claude Code afterwards). Then it checks again. /cco:doctor shows the report in Claude Code, and doctor in the Settings view's Reset group checks and repairs, each after asking.

All views share one layout:

• Top bar: the view tabs, a status summary and, on the right if there is room, the version of cc-outline. Options that are on are not repeated there; the help line highlights them.
• Body: a list on the left and a preview on the right. When the preview is longer than the pane, its first or last row becomes a blue badge that says how many lines are hidden above (↑ 5 more lines (ctrl+Home)) or below (↓ 15 more lines (ctrl+End)), with the key that jumps there; a click on the badge jumps as well. In a narrow preview the key is left out. A scroll bar on its right edge shows which part is in view: the thumb touches the top or bottom of the track only when the preview is at its very top or end. A click on the bar jumps there. The status in the top bar names the position: top, end, the lines in view in between (121–160/300), or all when everything fits.
• Help line: the keys of the current view at the bottom.

The viewer sets the terminal title to the session title, the one set with /rename or else the one Claude Code gave the session; until the session has one, the project folder. So its tab, and a window of its own in the taskbar, show which session it follows instead of just cco. Like Claude Code, the title starts with a status mark: ◐ and ◑ in turn while Claude works on the last turn, ✳ when it waits for you. A viewer of one session (--session, --remote; a remote one's title starts with ◈) shows the status mark only while its session runs in a Claude Code. A Windows Terminal profile with suppressApplicationTitle keeps cco.

Press 1 to 6 to switch between the views, or Tab and Shift+Tab (or → and ←) for the next and previous one (hidden views are skipped; past the last comes the first again). All of them keep running in the background, so the chat keeps following the session while you look at the changes.

Lists. All lists work the same way:

• ↑/↓ select the previous or next entry, Home/End the first or last one. The preview next to the list scrolls by page with PgUp/PgDn and by line with Ctrl+↑/Ctrl+↓; Ctrl+Home/Ctrl+End go to its top and bottom. ←/→ switch to the previous or next view.
• Chat and Plan show the oldest entry at the top; s turns the list around and remembers it (the order settings). Sessions (with its trash) and Monitor always show the newest at the top. The keys follow what you see: ↑/↓ go up and down, Home/g to the top, End/G to the bottom; in the chat, whichever of them reaches the newest turn resumes follow mode.
• If the text of the selected entry (prompt, file path, plan or session name) is too long for the list, it scrolls: at most 250 characters, then it starts over from the beginning. The other entries are cut with …. The Settings view switches this off.
• If the list is longer than the pane, its first or last row shows how many entries are hidden above (▲ 12 more Home) or below (▼ 5 more End), together with the key that jumps there.
• Chat, Plan and Sessions (with its trash) show only the time of an entry; a dimmed line with the date (── Mon 28 Sep 2026 ──) starts each day, above its entries in either order. A list whose entries are all from today has none. The date separators setting turns the lines off. The lines cannot be selected (a click on one selects the day's first entry), and when the day's line has scrolled away, the ▲ row names the day (▲ 12 more · Mon 28 Sep Home). In a session's preview, plans, agents and prompts get these lines if the session spans several days. The Monitor's list of days gets a line per year (── 2025 ──) once it reaches into another year.
• Mouse: a click on a tab in the top bar switches to its view, a click in a list selects an entry, a double click does what Enter does (in every view; a confirmation still asks first), the wheel moves to the previous or next one. ↓ more ↓ loads with a single click. In the preview the wheel scrolls, and a click on a web address (https://…, also one wrapped over two lines) opens it in the browser when you let go. Dragging in the preview selects text in the preview only, not the list beside it, and copies it when you let go (copied 4 lines); dragging past the top or bottom scrolls on. The header above it (the prompt in the chat, the path in Changes) selects the same way, on its own and without the ❯ in front. A selection that starts right of the line numbers (Changes) leaves them out. A click or the right mouse button drops it. To select across the whole pane as the terminal does, hold Shift while dragging. The mouse setting turns this off.
• Space marks the selected entry as a favourite (★ at the start of its row) or removes the mark. Shift+↑ and Shift+↓ jump to the previous and next marked entry, and the top bar counts them (★ 2).
• With the pinned favorites setting (off by default), every list but the trash shows its marked entries once more at the top, under ── ★ Pinned ──, in the list's order, and below a plain line (or the first date separator) the whole list, where they keep their place; both rows show the ★. ↑/↓, Home/End and the wheel follow the rows on screen, through both copies; Shift+↑/↓ steps through the pinned rows (from the list below, up to the last one). Following (Chat, Plan) and a restored selection go to the entry's place in the list. Marking or unmarking an entry in the list keeps the selection there; unmarking a pinned row selects the next pinned one (after the last, the one above), and the only one stays selected in its place in the list. A filter applies to the group too, and Sessions and the Monitor pin only what their range has read. The pinned sessions setting (on by default) also puts the active session (●) and those running in another Claude Code (▶) into the Sessions view's group, marked or not and also with pinned favorites off; a session that ends leaves it, and a selected copy hands the selection on as unmarking does.
• Ctrl+F filters the list. A dialog opens; the list shrinks while you type and the dialog counts the matches (12 of 340). Enter keeps the filter, Esc drops it; ↑/↓ and the wheel select in the filtered list meanwhile. While a filter is on, the list's top row shows it (⌕ plan*view · 12 of 340 · ^F clear) and the top bar counts 12/340; Ctrl+F again drops it, and the next Ctrl+F offers it again (selected: type to replace it, → to add to it). Case does not matter, every word must occur (in any order), * stands for any text and ? or _ for one character. The dialog's [x] in the list (^L) and [x] in the details (^D) choose where it looks; the choice is kept as the filter in setting (default: the list only). The list is what a row shows: the prompt (Chat), the path (Changes), the plan's title (Plan), the title and project (Sessions), the date written several ways and the weekday (Monitor), value, group and name (Settings). The details are what the preview adds: attached files and subagents (Chat), the former path and the status (Changes), the plan text, status and feedback (Plan), folder, branch, id, prompts, changed files, plans and agents (Sessions), the models of the day (Monitor), the description (Settings). Each view keeps its filter while the viewer runs; the trash has none. Following (Chat, Plan) goes to the newest entry that matches, and Shift+↑/↓ jump only between marked entries that are shown.
• Marks are saved per project in ~/.claude/cco/<project-slug>.favorites.json: turns by prompt, files by path, plans by their id, sessions by their id, Monitor days by their date. The settings are global, and so are their marks, in ~/.claude/cco/favorites.json.
• Every list remembers its selected entry, and the preview remembers its scroll position for each entry: switch to another entry and back, and you are where you left it. Detail views keep their own position (the whole file of a changed file, the changes to a plan's previous version). Both survive closing and reopening the viewer; they are saved per project in ~/.claude/cco/<project-slug>.positions.json. A list that was following the newest entry (Chat, Plan) follows it again. With remember positions off in the Settings view, they are kept only while the viewer runs.

Chat view

The Chat view shows the session turn by turn. A turn is one prompt plus everything Claude answered to it.

List (left). One entry per prompt, with its time.

• Slash commands appear as /name args, with the command's name in orange in the list and above the answer, shell commands run with ! as ! command, with their output as the answer. Claude Code writes a ! command to the transcript only when it has ended, so it shows up then.
• Side questions asked with /btw do not show up: Claude Code keeps them in memory only and writes neither the question nor the answer to the transcript.
• Pasted images keep Claude Code's placeholders in the prompt, [Image #3], in cyan and with a dimmed (o); a click on one opens it. Images without one (older transcripts, a prompt of images only, listed as [Image] or [3 images]) get theirs added at the end.
• Browser calls (Claude in Chrome, and the Browser pane of the Claude desktop app) show one line per browser action, verb first: ↗ navigate example.com/…, ⊙ click (451, 265), ⌨ type "…", ▣ screenshot · 1568×744, ⌕ browser find "…" → 2 elements, ⇄ browser network; a browser batch lists its actions below it. A dimmed line names the page whenever it changes (on CloudWatch | eu-central-1). At full, scripts, search results and console messages follow. Screenshots are numbered through the turn, [▣ 3] after the action that took them (a scroll or click can bring one too): a dimmed (o) after the mark names the key. A click on the mark opens it in the system's image viewer; o lists the turn's images, the prompt's pasted ones first, then the screenshots with their action and page, to open one (Enter keeps the list open, Esc or o closes it). The image is the copy the desktop app saved next to the transcript, otherwise the image data from the transcript, written to a temporary folder.
• Subagents. Where Claude starts a subagent, the answer shows it as a block: ◆ Explore · Map the order flow · sonnet · background, below it its status (⠿ running, spinning, then ✓ completed · 1 min 13 s · 12 tool uses · 41k tokens, or ✗ failed). In the list, ◆2 marks a turn that started two subagents, and the spinner stays while background agents of that turn still run. a shows what the turn's subagent did instead of the answer: its task and its answers, with tool calls and thinking as t and h say, read live from its own transcript in ~/.claude/projects/<project-slug>/<session-id>/subagents/. With several agents, a goes on to the next one and A back to the previous one, past the last or first back to the answer; Esc goes back at once. ↑/↓ switch turns as always, which closes the agent's page. When a background agent hands its report back, the report gets a turn of its own (↩ Agent "…" reported back, magenta): the report comes first with a magenta bar, then Claude's reaction to it. a shows it as the agent's result too. The Settings view hides the blocks (Chat: agents).
• Workflows. Where Claude starts a dynamic workflow (the Workflow tool: a script that runs agents in the background), the answer shows it in a magenta frame like a question or browser actions, ◇ Workflow · ticket-rating · background on its top line, inside it its description, its status (⠿ running · phase 1/2 Rate · 3 of 8 agents done, spinning, then ✓ completed · 18 min 24 s · 8 agents · 356 tool uses · 862k tokens) and its agents by phase, each with its status. The agents are read from the run's folder next to the transcript (<session-id>/subagents/workflows/<run-id>/) every second while the workflow runs, so they show as they start and return. They are the turn's subagents: ◆8 in the list, + ◆8 862k in the stats, and a/A show each one's page, where the request the workflow relays and the task its script computed are shown without the harness's preamble, and the agent's structured result as a JSON block at the end. A resumed run shows ↻ resume <run-id>. The notification at the end is an entry of its own like any task's; Enter shows how its agents went (8 agents · 1 failed) and its result, JSON as an indented code block; Claude Code cuts a long result and keeps the whole one in a file, which o opens. Like agents, the blocks follow Chat: agents.
• When a background agent or command stops, Claude Code reports it to Claude. That report becomes an entry of its own, marked ↩ (green when it completed, red when it failed), with Claude's reaction as its answer. Enter shows what the task returned.
• Images and PDFs other tools return (Read of a .png or a .pdf, MCP tools) are marked like screenshots: images go on in the same numbering, [▣ 4], PDFs have their own, [▤ 1]. With tool calls off they still show, as a line of their own (▣ diagram.png [▣ 4] (o)). A click on the mark opens the copy in the transcript, what Claude saw.
• What came with a prompt and what the turn's tools returned is named in a line below the prompt: 📎 2 pasted images · @src/Order.cs · 12 lines selected in Foo.cs · 1 tool image · 3 screenshots · 1 PDF (o) (files and folders mentioned with @, lines selected in the IDE or a diff). The list shows the number of images and PDFs before the prompt, ▣4. Enter lists them below the full prompt, with where each pasted image is stored. o lists them all to open one in the app the system uses for it (Enter keeps the list open, Esc or o closes it): a pasted image from the copy Claude Code keeps in ~/.claude/uploads, or, when that is gone, from the transcript, written to a temporary folder; a file or folder mentioned with @ where it is now; a tool's image or PDF from the transcript. On a subagent's page, o and the marks are that page's. Files Claude Code attaches again after /compact are not the user's and are left out.
• /compact shows the summary Claude Code compacted the conversation into as its answer, under a heading with the tokens before and after and how long it took. An automatic compaction gets an entry of its own, ⟳ Conversation compacted automatically, with Claude's work after it.
• When you come back after a while, Claude Code writes a recap of the session. The chat shows it below the answer it follows, set apart with a yellow bar and ※ Recap.
• /compact can move the session to a new transcript, for example when it sends the session to the background. The viewer then reads on in that transcript, so the chat keeps the turns so far and shows what follows. Where it went on, the list has an entry of its own, ⤷ Session continues in …: its details name both sessions, the compaction (tokens before and after, how long it took), whether the session was sent to the background, and the command to resume it; Claude's answers after the switch belong to it. Opened on the new transcript later, for example after /resume, it reads the earlier one first. The Sessions view shows both as one session, resumed under the newer id.
• Prompts you sent while Claude was still working are marked with ↳. Claude Code stores these separately; cc-outline shows them as turns of their own.
• The turn Claude is working on has a spinning ⠋ in front of it, and its answer ends with Claude is working… until Claude finishes. With tool calls off, that line counts the turn's calls so far (Claude is working… · 12 tool calls), so you can see it getting on. A turn you stopped with Esc in Claude Code is marked with a red ⊘, and its answer ends with ⊘ Interrupted by user (or … during a tool call).
• Turns keep their marks across restarts and when you continue a session with --continue or /resume, which starts a new session id but keeps the turns.

Prompt (top right). The selected prompt stays pinned above the answer while you scroll.

• It shows at most five lines (blank lines left out) and never more than half the pane height.
• If it is cut, its last line ends in … and the separator reads ↵ full prompt. Press Enter to read the whole prompt, then Enter or Esc to return to the answer.
• Below it, marked with $ like the prompt with ❯, what the turn took: 2 min 14 s · ↓ 3.2k · ctx 84k · opus-5.5 · 12 tools · + ◆2 58k. That is how long it ran (counting up while Claude works), the tokens Claude wrote (thinking included), how full the context was at its end, the models, the tool calls and the subagents it started with their tokens. A second line counts the files it created and changed and their lines: files +2 ~5 · lines +184 −37. Files deleted with a shell command are not counted, nor what subagents wrote. Turns without an answer from Claude (! commands, /rename) have no such line. Parts that do not fit the pane width are left out from the end.
• Enter shows it in full below the whole prompt, under its own $ Details heading: when the turn ran (14:02 – 14:09 · 6 min 41 s), the tokens per model, the context, the tool calls per tool (Edit 6 · Read 9), each subagent with its type, description and status, and each file it created (+) or changed (~) with its lines. While Claude works, the duration counts up and the rest grows with the transcript.

Answer. The answer is rendered as Markdown and wrapped to the pane width. List items keep their indentation when they wrap.

• Browser. With tools off, what Claude did in the browser still shows, in a cyan frame (╭─ Claude in Chrome · 6 actions · 2 screenshots, Browser for the desktop app's pane): one line per action as above, the page in between, and below an action what it found, dimmed and at most five lines: the elements a search matched, a script's value of several lines, console messages. Claude's text between the actions starts a new frame; tool calls hidden with off do not. c leaves the frames out.

• Questions. When Claude asks you something (a multiple-choice question in Claude Code), the answer shows it in a yellow frame (╭─ Claude asks). Each question starts with a yellow badge (its number and header, e.g. 1/4 Focus), then its options: the one you chose marked ● in green, the others dimmed ○. Below, your answer in green as ┃ You: … ((own answer) when you typed it, and your note if you added one). A dimmed line separates the questions. The frame is only for tools off (t), so questions show even then; with compact and full a question is a tool call like the others: ⚙ AskUserQuestion with the question and your answer, in full each question with its answer below.

• Tool calls. t steps through three levels:

  • off (default): no tool calls.
  • compact: one line each, with its result: ⚙ Read src/open.ts · lines 85–145 of 300, ⚙ Edit src/open.ts · +12 −3, ⚙ Bash Run the tests · ✓ · 14 lines, ⚙ Grep TODO in src · 3 files, ▤ Plan presented → approved. ✗ marks a tool that failed, ⊘ denied one you rejected.
  • full: also the command, the last 10 lines of its output, the files found and the pages a web search returned.

  Claude Code writes a tool call to the transcript only once it has finished, so a call shows up together with its result: a question appears when you have answered it.

• Tool calls (t) and thinking blocks (h) are hidden by default.

• With w, wrapping is switched off: paragraphs and code lines stay whole, and Ctrl+←/→ scrolls sideways.

• c copies the turn's Markdown (without tools and thinking) to the clipboard.

Follow mode is on by default.

• The newest turn is selected, and the view sticks to the bottom while the answer grows, like in Claude Code.
• Scrolling up or selecting an older turn leaves follow mode. The badge ↓ 15 more lines (ctrl+End) at the bottom of the preview then shows how much is left below; Ctrl+End or a click on it goes there. Scrolling back down to the end, ↓ to the newest turn, Ctrl+End or G resumes following. f toggles follow mode directly.
• Each turn remembers where you left it scrolled. An older turn that is not scrolled to its end also shows the badge; there Ctrl+End jumps to the end of that answer.

Status. The top bar shows:

• the session id
• the number of turns
• the scroll position (top, end, the lines in view such as 121–160/300, or all)
• the number of marked turns (★ 2)
• with wrapping off, how far the answer is scrolled sideways (→ 16 cols)

Which options are on (f follow, t tools, h think, w wrap) shows in the help line at the bottom, where they are highlighted.

The viewer switches sessions automatically after /clear or /resume.

Changes view

The Changes view shows what Claude has changed in the working tree, compared with HEAD.

Repositories. The view shows the repository the project folder is in and every repository up to 3 folder levels below its top level (or below the folder, when it is in none): repositories inside it, submodules and worktrees, also in folders the repository ignores. Hidden folders, node_modules, bin and obj are not searched. Each repository gets a separator with its path and branch (── tools/bar · main ──; the project's own repository first, by its folder name, then the others by path), also when it is the only one. The separator can be selected: its preview names the folder, then in one line a git operation in progress (REBASE 3/7, MERGE, CHERRY-PICK, REVERT, BISECT, AM), the branch with ↑/↓, its upstream and when it was last fetched (fetched 3 h ago; yellow after a day, never fetched only with an upstream). Below it: the remote (the upstream's, else origin, else the first; +1 for each other) and what kind of repository it is (submodule, worktree of its main folder, shallow), the tag git describe --tags names and the stashes (yellow), the identity commits are made with (no user.email in yellow when none is set), the changes in one line (3 files · +40 -12, or No changes) and the last 100 commits (Last 100 of 1 234 commits:, with older commits: git log below when there are more). What is missing is left out. All of it is read again with every refresh, the remote, kind and identity every 30 seconds; Enter opens the folder. An operation in progress also shows in the separator, which turns yellow (── proj · main · REBASE 3/7 ──). A nested repository or submodule no longer shows as an entry of the repository around it; its files show under its own separator. The first 10 repositories are read; with more, the last entry ↓ more ↓ reads the others (Enter or a click) until the viewer restarts, every 10 seconds. The Changes: sub-repositories setting turns the search off: then only the project's repository shows, under its separator.

List (left). One entry per changed file, with its status and line counts, its path relative to its repository. A marked file keeps its mark by path, also after it was committed and changed again; in the Pinned group it shows its repository's path in front. The statuses:

• M modified, A added, D deleted, R renamed, C copied, U conflict
• ? untracked, counted as all-added lines

File header (top right). It stays in place while you scroll, like the prompt in the Chat view. It shows:

• the full path, from the project's repository (with the repository's path in front for one below), wrapped at /
• the status, the line counts and the current mode (diff or whole file)
• for renames, the old path

Diff. Each hunk starts with its @@ header.

• Every line shows its old and new line number, a +/- sign and a colored background for added and removed lines.
• ] and [ jump to the next and previous hunk.
• Repositories without any commit are diffed against the empty tree.
• Binary files are only named.

Whole file. Ctrl+Enter switches to the complete file as it is now, with line numbers and highlighting but without change markers. There, ] and [ jump between the changed blocks. Ctrl+Enter or Esc returns to the diff. Deleted files have no content after the change, so the view says so.

Opening. Enter or a double click on a file in the list opens it as it is now in the app the system uses for its type (via explorer.exe, open or xdg-open). Deleted files cannot be opened. In tmux, Ctrl+Enter only arrives with extended-keys on.

Wrapping. Long lines wrap by default. After w, lines stay whole and Ctrl+←/→ scrolls sideways in steps of 8 columns. The line numbers and hunk headers stay in place.

Status. The top bar shows the branch of the selected entry's repository, the number of repositories (when there are several), the files and line counts over all of them, and the scroll position. If the branch has an upstream, ↑ is followed by the number of outgoing commits (not yet pushed) and ↓ by the number of incoming ones (not yet pulled), e.g. main ↑2 ↓1. Non-zero counts are highlighted. cc-outline never fetches, so the incoming count is as of your last git fetch or git pull.

Refresh. While the view is visible, it re-reads git every 2 seconds and searches for repositories every 30 seconds; F5 does both at once, so a repository created or cloned since (git init, git clone) shows. The selected file stays selected as long as it is still changed.

Syntax highlighting exists so far for C# (.cs, .csx). Add more languages through the LANGUAGES map in src/render/diff.ts.

Plan view

In plan mode (Shift+Tab in Claude Code), Claude first writes a plan and asks for approval. When you ask for changes, it writes a new version. The Plan view keeps every plan of the session.

List (left). One entry per plan, with its time, its title (the first heading) and its status:

• ✓ approved
• ✗ rejected
• ● waiting for your decision
• ✎ being written: Claude is still in plan mode and has not presented it yet

Plan (right). The selected plan rendered as Markdown. Above it, pinned while you scroll:

• the title
• the version, status and time (v2 · approved · 11:15)
• the prompt the plan answers
• your feedback, if you rejected it with a comment

Changes between versions. If there is an earlier version, the separator below the header reads ↵ changes to v1. Enter then shows what changed compared with that version, as a diff with line numbers. Enter or Esc returns to the plan.

Following. The newest plan stays selected while Claude presents new ones; selecting an older plan stops that, and End resumes it.

While Claude writes. A plan shows up as soon as Claude writes it, not only once it is presented. Claude Code records the presented plan in the transcript only after you decided; but when plan mode starts it names the plan file (in ~/.claude/plans/), and Claude writes the plan there first. The Plan view shows that file as ✎ and updates it while Claude revises it. Once the plan is presented and you decide, it becomes a regular entry (✓/✗); after a rejection, the next revision shows up as ✎ again, and Enter shows what it changes. c copies the plan's Markdown.

Wrapping. Long lines wrap by default. After w, lines stay whole and Ctrl+←/→ scrolls sideways; in the changes between versions the line numbers stay in place.

Status. The top bar shows:

• the number of plans, and how many are approved, rejected and waiting
• the scroll position
• the number of marked plans (★ 2)
• with wrapping off, how far the plan is scrolled sideways (→ 16 cols)

The help line highlights w wrap while wrapping is on and End follow while the newest plan is followed.

Sessions view

The Sessions view is an overview of your Claude Code sessions: of this project by default. a opens the filter, a dialog of check boxes remembered in settings.json (Sessions: folders, accounts, background): the folders (this one, the others, or both), the accounts found on the machine (shown with two or more; checking all of them also takes an account signed in later) whether the background sessions show and, with the remote API, the remote ones. ↑/↓ pick a row, Space switches it, Enter applies, Esc cancels; the last box of a group stays checked. Below the rows the dialog names every mark of the list in short; the Sessions rows of the Settings view explain them in full. The help line shows a filter highlighted while it differs from this folder, this account and all sessions. The active session always shows. It only reads them: the other views keep showing the active session.

List (left). One entry per session, the one last written to first, with the time its transcript was last written (under a line per day; for a session continued under a new id, its latest transcript). Any write counts: a prompt, Claude working, a report of a background task, a rename, an import or a move. Each row shows, with all projects, the project's folder name and then the session's name: the name given with /rename (bright), otherwise its first prompt (dim and in quotes, „like this“). Background sessions, those started with claude -p or the Agent SDK and those the Claude Code daemon runs, have a dim ◌ before their project and name, and the header says how they ran (◌ background: claude -p / SDK, or daemon with the claude attach command while it runs). The active session is marked with a green ●, sessions running in another Claude Code with ▶, and a session whose folder is gone with a gray ∅ (with all projects, its folder name is struck through; the preview says folder gone, and the filter finds it by that). Whether a folder exists is looked up once while the view runs, again after F5. While Claude works in one of them, its mark blinks; while it waits for you (a permission, a question), the mark is yellow. The preview's header says working or waiting for input. Both come from the status Claude Code writes to ~/.claude/sessions/ (version 2.1.283 on), read every second. A blue ◎ marks a session open in a session viewer (◎2 for two), see Session viewer below. A magenta ◇ marks a session in which Claude started a dynamic workflow (◇2 for two). Sessions that only ran slash commands such as /resume or ! commands and changed nothing are left out.

Other accounts. With the last two scopes, the list also holds the sessions of the other Claude accounts signed in on this machine (the ~/.claude* folders, see the Accounts view), sorted in with this account's. Every row then starts with a bar ▌ in its account's colour (the colour chosen in that folder's settings, else the one from the email; gray where it is off), this account's too. The preview's header names the account (email, organisation, folder) and whether the cco plugin is installed there; whether the session runs in a Claude Code there shows like for this account's. Enter on another account's session offers to continue it there, in a new window under that account's folder (cco claude --config-dir … -- --resume), to switch to its tab while it runs there, or to copy the command (CLAUDE_CONFIG_DIR=… claude --resume …, a folder in the home folder written as %USERPROFILE%\… or $HOME/…; also c). Such sessions can be marked, but not deleted, renamed, exported or moved; the trash holds this account's only. The filter also finds a session by its account's email. A session continued in another account shows in both, each with its ⇢/⇠.

Range. The list holds the sessions written to in the last 7 days (the Sessions: range setting: today, 7, 30 or 90 days, or unlimited; days count from midnight, today included). The active session and sessions running elsewhere are listed even if that was earlier. When there is no session at all, the list's top entry is ⤓ import sessions…, which opens the import (Enter or a double click). The last entry, ↓ more ↓ (centred, blue like the previews' "more lines"), reads the whole history with Enter or a click (↓ loading… 42/97 ↓ meanwhile) and then goes; that holds until the viewer restarts, also if the setting changes. Transcripts last written before the range are not read at all, so a short range is quicker. A filter never hides it.

Details (right). Pinned at the top:

• the name
• the date, start and end time, duration and git branch
• the number of prompts, plans, subagents, workflows and changed files
• the folder the session ran in, where the resume command has to be run
• the command that continues the session: claude --resume <session-id>. c copies it to the clipboard. In a running Claude Code, /resume <session-id> does the same.

Below it:

• Plans with their status (✓ approved, ✗ rejected, ● waiting), time and title
• Attachments (only if there are any): images pasted into the prompts (⎘, with the prompt), files and folders mentioned with @ (@, once per path, (3×) for three prompts), images (▣) and PDFs (▤) tools returned, with their time. A click on one opens it, o lists them all; the list counts the images and PDFs in the row (▣3). For a session in the trash they are read from there.
• Workflows (only if the session started any, after the plans): each dynamic workflow with its status, start time, name, number of agents, duration and description
• Agents (only if the session started any): the subagents with their status (✓ completed, ✗ failed, ⠿ running), start time, type, task and duration
• Changed files: every file Claude edited or wrote. Files of the project come first, relative to it; files elsewhere (such as plan files) are dimmed.
• Prompts with their time. Reports of background tasks (↩ in the chat) are not counted as prompts.

Remote sessions (experimental). With the setting Sessions: remote API on, the list also shows the Remote Control sessions of this account that claude.ai knows (a Claude Code started with claude remote-control or /remote-control, as the Claude app lists them), marked with a cyan ◈ before their title. Use it to see from another machine what runs elsewhere. cco reads them through an interface of claude.ai that Anthropic does not document and may change at any time (hence experimental and off by default), with the login Claude Code keeps in .credentials.json: it only reads that file, never writes or renews it, so once the login has expired the top bar says so and Claude Code has to be started or /login run. It needs a Pro, Max, Team or Enterprise login; behind a company proxy that replaces certificates, start cco with NODE_OPTIONS=--use-system-ca. The preview shows what claude.ai reports (◈ remote · working · connected) and, once the session is selected, its prompts, plans and changed files read from its events; Enter offers its address (https://claude.ai/code/…), c copies it. Like the app, the list leaves out the sessions claude.ai has archived (a Remote Control session is archived once its Claude Code has exited). A session of this machine that is connected to claude.ai shows ⇄ instead of appearing twice: its transcript records the id claude.ai lists it under. remote in the filter (a) lists them with the others or not at all. Enter on a remote session also offers Open it in a session viewer: like a session of this machine (see Session viewer below), a session viewer (cco watch --remote <id>) follows the whole session live in its chat (no other views but its own settings), as the app shows it, refreshed every second; any number of them, ◎ in the list, Bring its session viewer to the front. With the setting Sessions: steer remote (also experimental, off by default), cco steers them like the app: the Enter dialog in Sessions starts with what fits what the session does (Send a prompt while it is idle, Interrupt Claude while Claude works), and the prompt line below the chat of every viewer of the session sends (without the setting it says steer remote is off; switching the setting takes effect at once): the chat has the keys at first, Tab or i hand them to the prompt line, which grows with its text up to six rows (Ctrl+J starts a new line, Enter sends, also while Claude works, which takes it in when it can); Esc stops Claude while it works, else hands the keys back to the chat; PgUp/PgDn and the wheel scroll the chat meanwhile. Several viewers, the app and the terminal can steer the same session at once. The prompt window of Sessions takes several lines too and keeps an unsent text until it is opened again. A session whose Claude waits for you, for a permission or a question, gets a yellow ⚠ (and joins the Pinned group); its ◈ blinks while Claude works there. Its Enter dialog starts with Allow or deny (with the command it wants to run) or Answer Claude's question, and in its own viewer it takes the place of the prompt line, as in Claude Code: the command with Allow, Deny and Deny, saying why… (↑↓ and Enter, or 1–3), or the question. A permission is allowed once, denied, or denied with a reason Claude reads, as in the app (which offers no always allow either); a question shows its options like the filter dialogs ((•) one, [x] several, Other… with a text field) and is sent once every question has an answer. When the app or the terminal answers first, cco's window closes with already answered in another app, and what was typed in it is copied.

Refresh. Sessions are read when the view is first shown and re-read every 3 seconds while it is visible. The first read fills the list as it goes (reading 42/97 in the top bar); with many projects it takes a few seconds. After that only files that changed are read again, and of those only the part that was appended. Only what the overview shows is kept in memory, not the answers.

Enter: attach, resume, detach. Enter (or a double click) on a session always opens the same dialog: the actions that make sense for it, the usual one selected (↑/↓ and Enter, or its number; Esc cancels), the others greyed out with the reason they cannot be chosen now. The help line names the action selected (↵ switch, ↵ attach, ↵ resume in this Claude Code, ↵ new Claude Code, ↵ new Claude Code + attach, ↵ move to this project, ↵ session viewer, ↵ copy). A viewer attached to a Claude Code is one opened by a /cco:… command or on start, or attached later; one started by hand (cco watch) is detached and follows the project's latest session. Only one viewer runs per Claude Code: cco watch --claude-pid refuses to start a second.

| The session | Viewer attached | Viewer detached | |---|---|---| | the viewer's own | Stay attached · Detach this viewer | (as any other) | | runs in another Claude Code | Switch to its Claude Code tab · Attach this viewer there | Attach this viewer · Switch to its Claude Code tab | | runs nowhere | Continue