Conversations

File > Save conversation as... exports a chat as Markdown.

⌘K on Mac or Ctrl+K on Windows and Linux opens the command palette: jump to another contact, find a past conversation, open a file of the contact's folder or run an action from this window's menus. To message your last viewed contact from another app, use Quick send.

↑ in the message box brings back the messages you sent, as it does in a terminal:

With the caret on the first line of the box, ↑ goes back one message at a time, the newest first. ↓ on its last line comes forward again, and past the newest, what you were writing is back.
In a message of several lines, also a long one the box wraps, ↑ and ↓ move the caret between its lines as always. With Shift, ⌥ or ⌘ they select and jump as always too, and while the list of slash commands or names is open they pick from it.
They are the messages of this conversation, also after you closed its window or restarted the app. In a group conversation they are yours, not the agents'. A new chat (New Chat, or /clear) starts with none: the ones before it are in Message history.
Only the words come back, not a picture you sent with them.
Change a message you brought back, and it stays changed while you go through the others. Send it, and what you were writing before is back in the box.

Mention a file. Type @ in the message box to find files in the contact's working folder. Keep typing a file name or part of its path to narrow the list. In a group, the agents' names come first, then files. Use ↑ and ↓, then Enter or Tab to choose; Esc closes the list. Enter while the list is open chooses a suggestion without sending your message. Paths with spaces are quoted for you. To search a path with spaces, start with @".

Git's ignored files are left out. The list shows up to 30 matches and refreshes its file catalog after two seconds. Very large folders have a bounded scan; if it leaves files out, the list says so. Attach files (the + beside the composer tools) opens the same picker as Send Files, starting in the contact's folder, including files outside the suggestions. Pictures appear as thumbnails; other files as cards, sent as @ mentions. The empty message box hints at files and, for services that offer them, / commands.

Quick messages are what you ask for again and again, kept to put in the message box with a click. The button with a speech balloon under the conversation lists them:

Choose one, and its words go in the message box where the caret is. Nothing is sent: change it or add to it, then send it.
Save as quick message... keeps what is in the box as one, with a name for the list. The name starts out as its first words.
Edit quick messages... opens Settings > Quick messages, where you add, change and take them out (see Settings).
They are the same in every conversation. The app starts with a few, such as Run the tests and fix the ones that fail.

Under a message, while you point at it, is a row of what can be done with it. Under one of yours it says when you sent it, like Sunday 12:20 AM, and has Rewind (↶), Edit (✎) and Copy. Under a contact's reply it has Copy.

Copy copies a message as it was written: a reply as its Markdown, not as the window draws it, and yours with its quotes and the files it names. A tick says it was copied.

Code in a reply is in colour when its block says what language it is written in: keywords, strings, comments and names each in a colour of their own, as in the Changes tab. A block is coloured once it is closed, and a block too long to colour quickly stays plain.

Rewind to a message you sent. Point at it and click ↶ under it:

The conversation goes back to just before it, and nothing is sent: your contact forgets it and everything said after it, as /rewind does in a terminal. What it was doing stops, its subagents and what it left running in the background too.
The message is in the message box again, with its pictures, ahead of what you were writing: change it and send it, or don't.
Where your contact did something after it, such as running a command or changing a file, or is at work, you are asked first. Its files are left as they are: only the conversation goes back.
A message that still waits to be read is taken back instead, as Cancel under it does, and what is going on goes on.
It goes for the same messages as Edit, below.

Edit a message you sent. Point at it and click ✎ under it:

The message is in the message box, with its pictures, under a line that says you are editing it. What you were writing waits until you are done, and ↑ brings back no other message meanwhile.
Send it, and it takes the place of the one you sent: the conversation goes back to just before that message, and your contact forgets it and everything said after it, as /rewind does in a terminal. What it was doing stops, its subagents and what it left running in the background too. The lines after it fade while you edit, to show what goes.
Cancel, or Esc, leaves the message as it was, and the box as it was before.
Your contact's files are left as they are: only the conversation goes back.
Editing your first message starts the conversation over with the new one.
A message that still waits to be read is taken back instead, as Cancel under it does: it is in the message box again, with no line over it, and what is going on goes on.
It is for a Claude contact on its own. Codex, Gemini, OpenCode and Hermes can't go back to a message, a slash command is no message to go back to, and with several agents in a group conversation the others heard it too. Nor can a message from before Claude compacted the conversation be edited: the conversation says so.
A message sent while Let Claude decide picks the effort is not one either: its effort check went first.

Fork chat from here. Point at one of your contact's replies, and click the fork under it:

A new contact goes on with the conversation up to and including that reply: Claude (fork), in the same folder, with the same service, model, effort level, fast mode, mode, output style, picture and group. The window goes on to it.
Its agent's conversation is copied at that reply, so the two go on apart from there. This conversation stays as it is, and so does its agent.
Both work in the same folder, on the same files: what one changes, the other finds changed.
Its conversation ends with a line saying where it came from. What you said before the fork can't be edited there; what you say after can.
It is for a Claude contact on its own. Codex, Gemini, OpenCode and Hermes can't copy a conversation, and with several agents in a group conversation each has a conversation of its own. Nor can a reply from before Claude compacted the conversation be forked from: the conversation says so.

How long a turn took. Point at the last reply of a turn, and the line under it says, like Worked for 12s. It is kept with the conversation: it is there when the window opens again, and in Message history.

Reply to part of a message. Select words in a message, or triple-click a paragraph, and click Reply by them. Or right-click them and choose Reply, or Copy:

The words are quoted in the message box, > in front of each line, with the caret on a line under them for your answer. A quote can be edited like anything else you type.
Select and reply again to answer several parts of a message, or of several messages, in one message: each quote goes under what you wrote so far.
A selection is quoted from one message. One that runs on into the next message offers no Reply.
What you send shows the quote set apart, over your answer.
In a group conversation, a name quoted with its @ mentions nobody. Only the names you write yourself pick who answers.

Pin a message. Right-click a message, yours or a contact's, and choose Pin message:

A line under the To: line shows the message pinned last: who said it, and how it starts. Click it to go to the message.
With several pinned, the line says which of them it shows, like 1 of 3. The next click goes on to the one pinned before it, and from the first back to the newest.
A pinned message wears a pin by its name. ✕ on the line, or Unpin message on the message, takes the pin off.
The pins are the conversation's: they are there when its window opens again, and after a restart. A new chat starts with none, and a conversation picked up again from Message history has its own back. Rewinding to a message, or editing one, drops the pins on what was said after it, with the rest of it.
Pinning is not hearing from the contact: the contact list sorted by Last active stays as it was.

Questions. When Claude asks you something with answers to pick from, a card says so in the conversation, like "Claude has a question for you.":

A question that takes one answer has a button for each. Click one, and the card goes on to the next question, if there is one.
A question that takes several says Choose as many as you like., with a box to tick beside each answer. Tick as many as fit, and untick one to take it back.
Or type your own answer under them, in place of the ones on offer: what you ticked or clicked is cleared.
Send answer sends it. Several questions come one at a time: Back and Next, or a click on one of the dots by them, go from one to another, and Send answers sends them all.
Skip answers none, and Claude goes on without them. It picks for itself and says what it picked. The card, the line above it and the history say you skipped.

Suggested replies. When Claude ends a reply by asking you something, like "Should I commit it, or would you like to check it in the app first?", a few answers come up under it once its turn is done:

Click one and it is sent, as if you had typed it. To say something else, type it as always.
The one the reply says it would pick, if it says, comes first.
None come while a message you sent as it worked waits to be read: that is your answer already.
They go once you send anything, or once the contact starts on something of its own. A window you open while they are there has them too. They are not kept in the conversation.
Claude's quickest model writes them from the end of the reply, on the account in use. Codex, Gemini, OpenCode and Hermes contacts get none, and nor does a group conversation, where a question can be for another agent.
Settings > General > Suggest replies turns them off.

The model badge under the conversation says which model a contact answers with and, once you choose a level, how hard it thinks before it does: Opus 5.5 · High. Click it for Model..., Effort and Fast mode, the same entries as the Tools menu:

Model... opens the same list as Add a Contact: search it, type any other model, or choose which models it offers with Add models.... On a model with no effort levels and no fast mode, the badge opens the list straight away.
Default leaves the model to your own settings for that service. The list says next to it which model that is, once the service or a message of yours has shown it.
An effort level goes with the model. A model that takes none has no Effort entry, and switching to a model that doesn't take the level you chose goes to that model's own.
Until you choose a level, the badge only names the model: the model uses its own level.
Gemini, OpenCode and Hermes say which models they have once you have sent a message, and they are all listed. They have no effort levels.
⚡ Fast mode turns Claude's fast mode on and off: faster answers from the same model, at a higher price. While it is on, an amber bolt follows the model on the badge.
- It is there only for a model that has fast mode, which is Opus today. On another model the contact answers at its usual speed, and fast again once it is back on one that has it.
- When something keeps fast mode from working, the bolt is faint, and pointing at the badge says why: a pause after a rate limit, usage credits that are off, a plan without it, or your organization having turned it off. Claude answers at its usual speed meanwhile.
- Turning it on or off says so in the conversation: Fast mode changed: On.
The app remembers all of them for the contact. Nothing is written to your Claude Code or Codex settings.
A contact keeps them as a guest. In a group conversation each agent has its own badges, under its name in the Agents tab.
Or let the contact decide. Tick Let Claude decide at the bottom of the effort menu, and it picks its own level for every message you send:
- First it replies with a level and a few words on why, like @Claude(high) The export touches invoices. That check is done on its lowest level, so it is quick. Then it answers on the level it picked.
- The badge shows that level, and says it was picked when you point at it. The level you chose yourself stays the contact's own: untick the entry and it is back on it.
- A level you choose while it is ticked holds until your next message. A slash command gets no check.
- What you send while it is answering waits for that answer, and then gets a check of its own.
- In a group conversation the agents pick levels for each other the same way.

While a contact works, the last line of the conversation says what it is doing right now and for how long, like "Claude is thinking 0:12":

It is there for the whole of its turn, also between its tool calls: thinking while it reads what came back and decides what to do next, writing schema.rb while it writes out a long file before the call that saves it, running npm test, typing a message.
The status bar says the same, like "Claude is thinking...", and so does the contact's line in the contact list.
It goes under the contact's to-do list, where it has one. In a group conversation each agent at work has a line of its own.

When an agent stops with unfinished to-dos, Continue with... on its checklist lets you choose another agent in the conversation. Invite one first if the agent is alone. The button sends only the chosen agent the remaining items, including which were in progress, and asks it to inspect existing changes, verify what is already complete, and keep its own checklist. The original checklist stays with its agent.

Send turns into Stop while a contact works, as long as the message box is empty:

Click Stop to stop what the contact is doing. The button is a greyed-out Send again, and the caret is back in the box.
Start typing and it is Send again, for a message that waits for the contact (below). Empty the box and it is Stop again.
Enter on an empty box does nothing, so it never stops anything by accident. Esc, which nudges, and Actions > Stop Claude (Stop everyone in a group conversation) stop it too.

A message you send while a contact works waits for it: it is greyed out, with Queued · Send now · Cancel under it, until the contact reads it. Then it moves down to where it was read, under what the contact did meanwhile, and stays there when you open the conversation again.

Claude reads it at its next step, between two tool calls, or once its turn is over. Gemini, OpenCode and Hermes read it once their turn is over. Codex reads it as you send it, so nothing waits there.
Send now under it stops what the contact is doing, a command it is running too, and the contact reads your message right away. The turn it stopped says Stopped., like one you nudged.
Messages that wait for the same turn are each marked, and Send now under any of them stops that turn.
Cancel takes it back before Claude reads it: it leaves the conversation, and its words and pictures are in the message box again, ahead of what you were writing. What Claude is doing goes on. Edit (✎) under it does the same.
If Claude has read it by then, it stays where it is: Cancel says Claude has already read that message., and Edit edits it as it would any message you sent.
Cancel goes for the same messages as Edit, above, and for every message that waits in a group conversation. Other messages that wait have Send now only.
Stop, or a nudge, stops the turn without reading anything: Claude still reads what waited once it has stopped, and Gemini, OpenCode and Hermes drop it.

The tool calls a contact makes one after another fold into one line:

It says what they came to, like "Claude ran 3 commands, read 2 files and edited a file". A call still going on is counted once it is over: the line under the newest one says what it is.
A subagent's steps are the subagent's: "A subagent is reading cart.js" while it works, with how long that step has taken, and "Claude asked 2 subagents" once it is done. Its steps are under the line, indented.
Click it for the line of each call, with its Show output or Show changes link. Under it a command reads as why it was run, where the agent said why; point at it for the command itself.
A single call is its own line, as before. A to-do list always is.
Pictures a call handed back, such as a screenshot, are under its line, and all of them are in a row under the folded line while its calls are put away. Click one to see it over the whole window, as a picture in a message opens, to zoom in on and drag about. ‹ and ›, or ← and →, go through the others in its row, with a count such as 2 of 8, and from the last back to the first. Esc closes it.
A message, a request for permission or the end of a turn starts a new line. So does another agent's call in a group conversation.
Searching in Message history or with Find in conversation opens the lines your text is in.

Tools > Show activity lines shows or hides the lines for what a contact does, like "Claude ran npm test" and a helper's own, indented under it:

Unticked, a conversation shows the messages only. Questions, plans and requests for permission still come up.
The lines are kept: tick it again and they are back, each with its Show output or Show changes link.
The status bar still says what a contact is doing while it works.
It goes for every conversation window, and the app remembers it. Message history always shows them.

Tools > Output style changes how Claude writes its replies, for that contact only:

A contact you haven't chosen a style for uses the one in your Claude Code settings.
A new style applies from your next message, and the contact keeps it when you reopen the app.
The app remembers the choice itself. Nothing is written to your Claude Code settings or your project's .claude folder.
Styles you wrote yourself are listed once you have sent a message. A project's own come from its main checkout, as its other Claude Code settings do (see The contact list).
Codex, Gemini, OpenCode and Hermes have no output styles, so their Tools menu has no such entry.
A contact keeps its style as a guest: invited into a group conversation, it answers in the same one.

Keep a window on top. The pin by the window's buttons keeps it in front of other apps' windows, as Tools > Always on top does. It stays pressed in while it does; click it again to let the window go. The contact list has one too.

Your contacts beside the conversation

A conversation window lists your contacts on its left, so one window is enough to go from one conversation to the next:

Click a contact and the window shows its conversation instead. What it was doing goes on: its agent keeps working, and its terminals and what Run started keep running.
The list is the contact list, laid out the way you left that one: by project unless you grouped it another way, sorted the same, with Waiting for you on top. The ... over it groups and sorts it another way, and the contact list follows. Every project is in it, also when the contact list is narrowed down to one or has a project hidden. Archived is at the bottom, folded until you click it. Click an archived contact to read its message history, or right-click it for Restore contact.
The row you are in is marked. A contact with something you have not seen yet is in bold, with the count on its buddy.
A pull request's tags are their pictures alone until you drag the list wider. Point at them, or at the contact, for the rest.
Another contact on a project. Point at a project and click the + at the end of its line, as in the contact list. In a git repository the new contact gets a worktree of its own, on a new branch that is named already: press Enter. Its conversation is then shown in this window.
A project that has no contact yet. Click Add project under the list for the same three ways as the contact list's Add project: a folder on your computer, a repository on GitHub, or a new one with Quick start. Then add the contact that works on it, and its conversation is shown in this window.
Right-click a contact for Open in a new window, which gives it a window of its own, View message history..., New contact in this project..., Rename..., Pin to top, Add to favorites, Archive contact and Delete contact. Pinning and favorites are the contact list's, and both lists show them. Archiving puts the contact under Archived, where it can be restored in either list. Deleting asks first, as in the contact list, and can take the contact's worktree along. Archive or delete the contact whose conversation is in this window and the window closes.
Right-click a project for the contact list's menu of a project: a new contact in it or from an issue or pull request, Project settings..., Pin project to list it before the others, here and in the contact list, Archive all contacts, Delete all contacts... and Remove project.... Hide project is left out, as this list shows every project.
A conversation is in one window at most. Click a contact whose conversation is open in another window, and that window comes to the front.
Click a toast and the conversation window you were in last goes on to that conversation the same way.

What you typed and did not send stays with its contact, with the pictures and files you added to it: they are in the message box again when you come back. So are the answers you chose to questions you have not sent yet, on the question you were on. The side pane is as you left it with each contact: the same tabs in the same order, on the same tab in each half, with the lower half folded or the pane filling the window if it was. Its terminals and what Run started ran on, and a web page opens again at its address, without the pages before it to go back to. A pane you closed stays closed. What a tab showed inside it, such as the folders open in All files or how far you had scrolled, starts over. A contact the window has not shown yet starts as its conversation does in a new window, and closing the window forgets it all. The pane keeps the width you dragged it to.

Contacts in the toolbar hides the list and shows it again. So do Tools > Show contacts beside the conversation and ⇧⌘L (Ctrl+Shift+L on Windows and Linux). The window gets narrower or wider by the list, and the conversation stays as wide as it was. Drag the bar between the two to make the list wider or narrower; double-click it to put it back. Both go for every conversation window, and the app remembers them.

Chat tabs

More than one chat can work in the same folder, each in a tab over the conversation, as tabs in a web browser do.

Open one with the + after the tabs. It lists every service: pick the one the new chat talks to. The service of the chat you are in is first, and ⇧⌘A (Ctrl+Shift+A on Linux and Windows) or File > New chat tab opens one of it straight away.
A new tab is a contact of its own, with its own conversation, agent and history, called after its service: Claude 2, Codex. Of the same service, it answers with the same model, effort level, mode and output style as the tab it was opened from. Of another, as that service does to begin with.
The tabs share the folder: no worktree is made. What one chat changes, the others find changed, as with a forked chat.
Click a tab to show its chat. What the others were doing goes on, and the window goes on to the tab you picked as it does to a contact picked from the list beside it. ⌃Tab goes to the next tab, and ⌃⇧Tab to the one before. Each tab keeps what you typed and did not send, and its own side pane, as you left it.
A tab says how its chat is doing: its buddy turns busy while the agent works and away while it waits for you, and a chat with something you have not seen yet is in bold, with the count.
✕ on a tab, or the middle button, archives its chat, as Archive contact does: you are asked first if it is working or waiting for you. Restore contact in the contact list brings it back, with its tab. The last tab has no ✕.
In the contact list the tabs are listed under the first of them, joined to it by a line, as started conversations are. Right-click one there to rename it, or open it in a window of its own: that window has the same tabs.
Deleting the first tab leaves the others together, under the next of them.

Plans

In plan mode, Claude writes a plan and waits for your answer before it changes anything. The plan opens in a pane beside the conversation, and the window grows to make room for it.

Each plan has a tab. Approve it, or choose No, keep planning and say what should change, under the plan itself.
The conversation keeps one line about it, with a View plan link that opens the plan again. The link is still there after you close and reopen the window.
File > View a plan lists every plan of the conversation and how you answered it, and opens the one you choose.
A plan you sent back gives its tab to the next one from the same agent. A plan you approved keeps its tab while the agent works.
Closing the last tab closes the pane, and the window goes back to its size.

Codex, Gemini, OpenCode and Hermes have no plans to approve, so nothing opens for them.

Changes

The Changes tab shows what a contact's folder holds that the project's main line doesn't: the commits its branch made, and every file that differs, committed or not. It is in the same pane beside the conversation, and works for every contact, whichever service it uses.

To open it, click Changes in the toolbar, choose File > View changes, press ⇧⌘G (Ctrl+Shift+G on Windows and Linux), or click the + after the pane's last tab. A second click on the toolbar's button puts the tab away. The pane opens for it even when no plan is open.

Commits lists the commits the branch made since it left the main line (origin/main, or whatever the remote's main branch is), the newest first, each with its short name, who made it and how long ago. Click one to list only the files that commit changed. All changes, above them, goes back to everything. Uncommitted changes, under it, lists only what changed since the last commit: what you staged, what you didn't, and the files git doesn't keep yet, with how many files that is. Click the Commits heading to put the list away. In a narrow pane the commits stand under the top line; in a wide one, under the files. A branch with no commits of its own shows the list as soon as it has files to commit, with All changes and Uncommitted changes holding the same files; with nothing to commit either, there is no list.
A row for every changed file, with the lines it gained and lost: changed, new, deleted and renamed files, and files git could not merge. All changes compares the folder as it is with where the branch left the main line: what was committed since, what you staged, what you didn't, and the files git doesn't keep yet. Every file of a new folder has its own row. Without commits of its own, or without a remote, the folder is compared with the last commit, which is what git status lists.
- Its icon says what the file is written in, such as Ruby, TypeScript or a Dockerfile, and pointing at it says what became of the file. The name says so in colour: green for new, amber for changed, red and struck through for deleted, blue for renamed, violet for in conflict.
Click a row to see the file's diff under it, as git diff prints it. A new file's diff is the whole file. Several can be open at once.
- The code is in the colours of its file's language, on the green of an added line and the red of a removed one. A comment or string that runs over several lines is coloured on each of them. A file with a line longer than 1,000 characters, such as a minified one, stays plain.
- Every line has its number in the file: a removed line its number in the old file, any other its number in the new one. Copying lines leaves the numbers and the + and − behind.
- In a line that changed, the words that changed are marked, and so are the words they took the place of in the removed line. Lines with too little in common to be one line changed are not marked.
- The unchanged lines git leaves out between the changes are one line, such as 33 unmodified lines, with what git says they lead into, like the function the next change is in. Click it to show them. The file is read the first time you do, as it is in the folder, or as it was in the commit you chose. Show the rest of the file, after the last change, is there when the file may go on past it. A file longer than the All files tab shows (300 KB) can't show what lies past that, and a file that changed since its diff was drawn gets its new diff instead. What you opened closes again when the file's diff changes.
Files shows the same files as a tree, folder by folder, each with its icon and the lines it gained and lost. A folder that holds nothing but another folder shares its line, as in src/renderer. Click a file to open its diff and scroll to it, and a folder to put what is in it away. In a narrow pane the files stand above the rows; drag the pane wider than about 560 pixels and they stand beside them, with the commits under them. There, drag the edge between the files and the rows to make the files wider or narrower, and the top edge of the commits to give them more or less of the column. What you drag them to is kept for every conversation window, and a double-click on an edge puts it back. Click the Files heading to put them away and give the rows all the room.
Right-click a file, in Files or on the head of its row, for what can be done with it. Add to message puts it in the message box, as Send Files does. Copy copies its Path in the repository, its Full path or its Name. Open file opens it in the app your computer opens such files with, and Show in Finder shows it in its folder (Show in File Explorer on Windows, Show in folder on Linux). A deleted file is no longer in the folder, so it can only be copied.
⋮, at the end of the top line, says how the changes are shown. What you choose there is kept for every conversation window.
- Show files shows the files, or puts them away, as their heading does. Group files by folder lists them as a tree; turned off, they are one list, each file with its folder after its name. Separate test, build, and generated files lists the tests, then lockfiles, built and minified files, generated code and a dumped database schema, each under a heading of its own after the rest, beside the rows and among them.
- Collapse all files and Expand all files close or open the diff of every file at once.
- Side by side shows the old lines on the left and the new ones on the right, each with its number in its file, a removed line beside the one that took its place. Each side's lines can be commented on. Word wrap, on at first, wraps long lines; turned off, a diff scrolls sideways and what is said under a line stays in sight. Highlight changed words marks the words that changed in a line. Hide whitespace changes leaves out the lines whose only change is white space, as git diff -w does; a file whose only changes were those says so.
- Refresh looks at the folder again.
Click a line of a diff to comment on it. To comment on several lines, drag a line's + (or its number) over the others, or Shift-click another line while you type the comment: the lines are highlighted, and the comment stands under the last of them. Send now (⌘Enter) says it in the conversation right away. Add comment (Enter) keeps it under its line instead, and the bar under the list sends every comment you kept as one message with Send all. A message names each comment's file and lines and quotes them. A kept comment can still be sent on its own, edited or deleted, and it stays with its line while the file changes around it.
What reviewers said on GitHub stands under the lines it is about, under All changes, while the branch has a pull request that is still to be merged: who wrote it, which lines, the comment and its replies. Send to a contact says the thread in the conversation, with its file, its lines, everyone's words and its link. ▲ and ▼ go to the previous and the next thread that is still to be resolved, opening its file where it has to. The arrow at the end opens the thread on GitHub. A resolved thread is one line until you click it. A thread whose line has changed since is tagged Outdated and stands above its file's diff, with the lines it was written under, and one on a file the list does not have stands above the list. The balloon at the top of the tab, and on a file's row, counts the threads still to be resolved. Reply opens a box under the thread; its Reply button, or ⌘Enter, posts what you typed on GitHub as you, and Esc puts the box away. Resolve marks the thread as resolved on GitHub, and Unresolve, on a resolved thread you opened, takes that back. If you have a review of your own on the pull request that is not submitted yet, GitHub adds the reply to it, and the reply is tagged Pending until you submit that review on GitHub. These two, and Re-run failed under Checks, are what the side pane writes to GitHub, each when you click for it, with the GitHub CLI and its sign-in; what GitHub refuses is said in the thread.
Viewed, at the end of a row, marks a file as looked at, as on GitHub: the file is put away and the top of the tab counts how many you have viewed. When a viewed file changes again, the mark comes off by itself and Viewed turns amber. The marks last as long as the conversation window is open, and each commit keeps its own.
It looks again when a turn ends, when you go to the tab and when you choose Refresh. It never polls. The files you opened stay open, each with its newest diff.
A very large diff is cut off after 2,000 lines, with a note under it. A list of more than 500 files, or of more than 100 commits, says how many more there are.
A contact working in a subfolder sees its whole repository, as its contact card counts it. The card counts a new folder once; the tab lists the files in it. The card counts only what is not committed, so the tab can list more.
A folder that is not a git repository says so in the tab. So does a folder that is gone, a missing git and one that takes longer than ten seconds, each with a Try again link.

The tab only reads the folder. It doesn't stage, commit or undo anything, and it leaves git's own files alone, so it never gets in the way of the agent's git commands.

The + lists every kind of tab the pane can open, each with its shortcut, and under them the conversation's plans. So far those are Terminal, which opens another one, Changes, and for a Claude contact Subagents and Background.

The side pane: files, changes and checks above, what runs below

The pane beside a conversation has two halves, each with tabs of its own.

On top is what there is to look at: All files, Changes, Checks, Session, a plan, a web page, the subagents, what runs in the background. The + after its tabs opens any of them.
Below is what runs in the contact's folder: Setup, Run and the terminals. It has a + of its own, and the arrow in front of its tabs folds it away, down to the tabs. Going to one of them brings it back.
A conversation that nothing was said in yet opens with all six. See The Run button for Setup and Run.

All files shows the contact's folder as a tree. Click a folder to open it, and a file to read it in a tab of its own.

The folder is only ever read. A file is shown as text, a long one up to its first 300 KB, and one that is not text says so.
What git keeps for itself in .git is left out. Everything else is there, also what git ignores.
Going back to the tab reads the folder again, and going back to a file reads the file again: your contact may have changed it.

Checks lists the checks of the pull request of the contact's branch: the failing ones first, then the ones still running. Details opens a check's page on GitHub. Under a failed one run by GitHub Actions is why, in GitHub's words: the step that failed and the errors it reported, such as a test command that ended with an error, or a job GitHub never started. Re-run failed, there while one has failed, starts the failed jobs over on GitHub with the ones that waited on them, as GitHub's own Re-run failed jobs does for each workflow run, and the list shows them running.

It asks GitHub when you open it, when you go back to it, after each turn of your contact, and when you press Refresh.
A branch without a pull request says so. It needs the gh CLI, signed in, as the pull request tags in the contact list do.

Session says where your contact works, and with what, at a glance. File > View session info opens it too.

Environment: the account it answers in, its folder and the branch there, with a Worktree tag when the folder is a worktree made for it. Click the account to switch to another, and the folder to open it.
Context: how much of its context window is in use. Click it for what is in the window, as the meter in the status bar shows it.
MCP servers: the ones that need you, or else how many work. Click it to reconnect one or sign in to it.
It asks again when you go back to it, and the branch after each turn of your contact. In a group conversation it is all the host's, whose folder it is.
What a service can't tell about is left out: a Codex contact shows its folder and branch.

Open the folder in another app

The Open button in the toolbar opens the contact's folder in your editor. It wears the icon of the app it opens the folder in, and pointing at it says which.

Its ▼ lists the apps on your computer that can open a folder: editors (Cursor, VS Code, Windsurf, Zed, Sublime Text, Xcode and the JetBrains IDEs), terminals (Terminal, iTerm, Ghostty and Warp), Finder, and GitHub. Pick one to open the folder there. The button stays on it, in every conversation window, until you pick another.
Before you pick one, it opens the first editor there is, and without one the system's file manager: Finder on Mac, File Explorer on Windows, or Files on Linux.
GitHub opens the branch's pull request, or else the branch once it is pushed, or else the repository. It is listed when the folder's origin is on GitHub, and the button never stays on it.
Copy path and Copy branch name, at the bottom, copy the folder's path and the name of the branch it is on. They are in File and in a contact's right-click menu too.
On Linux an editor is found by its command, such as cursor, code or zed, and the folder opens in your file manager. Terminals are listed on a Mac only.
On Windows, File Explorer is available. Editor discovery and opening editors through .cmd launchers still need Windows support; open the folder in your editor directly in the meantime.

Create PR

The Create PR button in the toolbar gets the work on a contact's branch into a pull request. Its ▼ has two more ways to one.

Create PR asks the contact for it, in the conversation: to commit what is not committed yet, push the branch and open the pull request with gh pr create, with a title and a description. On the project's main branch, or on a branch whose pull request is already merged, it is asked to start a new branch for the work first. You see the message as if you had typed it, and the contact asks before it runs anything, as its mode says.
Create draft PR asks for the same, as a draft.
Create PR manually opens GitHub's own page for a new pull request in your browser, for the branch the folder is on. The branch has to be pushed already. If it isn't, or the folder is on the project's main branch, the conversation says so instead.
Once the branch has a pull request the button turns into View PR #12 and opens it on GitHub. A mark on its drawing says how the checks stand: red while one fails, amber while they run, green once they have all passed. Its tooltip says it in words. GitHub is asked again after a turn that was asked for a pull request, and whenever the window comes back to the front. After it is merged or closed, the button is Create PR again.
Its ▼ then has Show checks, or Show failed checks, which opens the Checks tab beside the conversation with the failing ones first, and Auto-merge, ticked while it is on. Turned on, GitHub merges the pull request by itself once what it requires has passed, squashed if the repository allows it, otherwise with a merge commit, otherwise rebased. Nothing is merged there and then.
- Where its base branch requires no checks or reviews, GitHub has nothing to wait for, so buddylist merges it itself: at once if its checks have already passed, or it has none, and otherwise as soon as they all pass. It merges only the commit whose checks it saw pass, and waits again after a push. Checks that fail keep it waiting for the next push, as GitHub would, and a toast says when it merged, or why it could not. This is kept with the contact, so it carries on after a restart, but nothing is merged while the app is closed: the first look once it is open again catches up. Auto-merge stays ticked until then, and unticking it stops it.
- Where GitHub won't wait for other reasons, the conversation says why: the repository does not allow auto-merge, it is a draft, or it is part of a stack.
Fix conflicts appears in the "To:" line while the pull request has conflicts with its base branch, after what the line says. It asks the contact, in the conversation, to merge the latest base branch into its branch, resolve every conflict, run the tests of the files it touched, and commit and push the merge without rewriting the branch's history, then to say which files conflicted and how it resolved them. Fix conflicts in the ▼ does the same. Once GitHub sees the conflicts are gone, the button goes too.
Continue appears in the toolbar, next to Create PR, after a pull request that is merged or closed, for going on with the same contact. Start new branch in the ▼ does the same. The folder moves to a new branch, started from the project's main branch as the remote has it now. The conversation says what the branch is called, and the next thing you ask for names it. The branch it leaves is kept. See pull request tags for when it is refused.
With several agents in the conversation the message mentions the host, so only one of them opens a pull request.
Actions in the menu bar lists the same entries.

The app itself commits, pushes and opens nothing: the contact is the one that does. Start new branch is the one thing it does in the folder itself, and it only fetches the main branch and checks out a new one.

Message history

Starting a new conversation doesn't throw the old one away. It moves to the contact's message history, which keeps the 50 most recent.

To open it, right-click a contact and choose View message history, or use File > View message history... in a conversation window.

The list shows the current conversation, then the past ones, newest first. Each has its date and your first message.
The search box narrows the list to the conversations that contain your text, and marks it in the transcript. It looks through your messages, the replies and the activity lines. To look through every contact's conversations at once, use the search box of the contact list, or every contact's message history.
Continue picks the conversation up again in its conversation window: its agent goes on from where it left off, and the current conversation moves to the message history. One about another folder can only go on there, and one saved before conversations could be continued can only be read.
Save as... exports a conversation as Markdown.
Delete removes one past conversation, and Delete all removes every one. The current conversation stays.

Deleting a contact deletes its history too. Archiving a contact keeps its history: restore the contact to continue one of its conversations.

Every contact's message history

Contacts > View all message history... in the contact list, or File > View all message history... in a conversation window, lists the conversations of all your contacts in one window, archived contacts' too.

The list has them under the day each was last added to: Today, Yesterday, This week, This month and Earlier. Each row has your first message and how long ago it was last added to, then whose conversation it is, its project and the branch its folder is on now.
Search history narrows the list to the conversations that contain your text, or whose first message, contact, project or branch does.
Pick one to read it. Continue, Save as... and Delete work as in a contact's message history. Delete all is only there.

Conversations from your terminal

A Claude contact's history also has the conversations you had with Claude Code outside the app, in the contact's folder: in a terminal, in the Claude desktop app or in your editor. So what you did there before you added the contact is in the list from the start.

Each is marked Claude Code, and stands in the list by the day it started, among the app's own.
It is read where Claude Code keeps it, under ~/.claude/projects: nothing is copied. The list has the 100 newest, and the ones from the other worktrees of the same repository, as /resume does.
The search box and Save as... work on them. Delete and Delete all leave them alone: they are Claude Code's to keep, and it removes them itself after a month unless your settings say otherwise.
What you typed is shown as yours. What Claude Code wrote into the conversation for Claude, such as its reminders and what a helper reported, is left out.
A very long one shows its newest 2,000 lines.

The contact list's search and every contact's message history look through the conversations held in the app only. Codex, Gemini, OpenCode and Hermes contacts list the ones held in the app.