Cockpit

What Cockpit is

When you work with coding agents you end up with a dozen conversations in a dozen terminal tabs. Several have finished, one is mid-task, two are waiting for you to answer something, and you cannot tell which is which without reading them. Cockpit is the screen that tells you.

It does not run your agents for you and it does not replace them. Claude Code and Codex already write every conversation to disk as it happens. Cockpit reads those files, works out what each session is about and what state it is in, and draws them as cards you can open, answer, interrupt and file. Your existing sessions appear the first time you launch it — there is nothing to import and nothing to set up.

Everything stays on your Mac. Cockpit is a local app reading local files, with no account and no server. See what leaves your Mac for the exact list.

Installing it

1. Open the .dmg you downloaded from aidash.dev.
2. Drag Cockpit into your Applications folder.
3. Double-click it.

What you need

• A Mac running macOS 13 or newer. The build is universal: Apple silicon and Intel, one download.
• Claude Code, Codex, or both — whichever you already use. Cockpit finds them itself. If neither is installed it still opens; there is simply nothing to show yet.
• Nothing else. No account, no sign-in, no key. On an Apple-silicon Mac, Cockpit fetches its own sorting model once, in the background (about 680 MB) — see Settings.

Updating later

You do not download a second time. Cockpit checks aidash.dev for a newer build, tells you when there is one, and replaces itself when you say so — see Updates & problems.

The first launch

Cockpit asks two questions, once, and never again. The first is which folders to read: it has already found the places the CLIs keep their transcripts — ~/.claude/projects and ~/.codex/sessions — and adding them through the picker is also how macOS grants it access. Cards start appearing behind the panel as soon as you accept.

That is the whole first run: there is no key to paste. A Mac with none of Claude Code, Codex or Kiro CLI installed is shown the three first, each with its mark and an Install button, and the window clears itself as soon as one is there. See Settings & keys for what each one buys.

Then it reads. A large history takes a few seconds; a very large one (a gigabyte of transcripts is not unusual) takes under a minute. You can use the board while it fills in.

If nothing appears, open Settings (the cog, far right of the top bar) and read This machine at the top. It says in plain words what is installed, what is signed in, which folders it looked at and whether it could read them — which is almost always the whole answer.

The board

The board is the home screen: one card per session, in columns by when it was last touched — today, this week, the past two weeks, last month.

Reading a card

• A red badge in the corner means that session is waiting for you — a permission request or a question. It is the same idea as a notification dot on an iPhone icon, and it is the one thing on the board worth scanning for.
• The icon, top left is the category. Click it to re-file the session from a menu.
• A faded card is done. A card with a moving line across the top has an agent working in it right now.
• The title is what the session is about, not the folder it runs in.
• The time at the foot — 4m ago, 2h ago, yesterday — is when the session last moved, on any card with room for it.

The top bar

Moving cards

Drag a card anywhere and it stays there. Drag one onto a category in the Categories view to file it. Hover a card for its own menu — Archive to put it away, or open a terminal in its directory.

Several at once: select a range of cards and drag the selection as one gesture, rather than filing them one at a time.

Attention

The point of the app, on one screen. Attention lists only the sessions that need something from you, each with what it was doing, where it got to, and a box to reply in. A round of answers that would have been a dozen terminal tabs is a dozen lines here.

• Type and send to answer without opening anything. ↵ sends.
• Snooze hides a row for a while, for the ones you will deal with later.
• Archive takes it off the board entirely.
• Refresh writes the short "where it got to" prose for rows that have none. That is the one thing here that needs a model — see keys.

Opening a session

Click a card. It opens full-screen, over the board.

What is on the screen

• Summary and Where we are at, at the top. The first is what this session is about; the second is the state it is in right now. Click the fold to open or close them.
• The conversation, in the middle, formatted to be read rather than scrolled past — headings, lists, tables and code, with what the agent did collapsed down to one line each so the actual reasoning is visible.
• The files the agent wrote or changed, as tabs. Click one to read it. Each has a timeline of its own versions: step through it with the dots, or with ← →, and see what changed between two of them. Markdown, code, CSV, images and Word .docx are rendered rather than dumped as text.
• Comments on a document. Select any passage in a file and say what should change: the comment, with the passage quoted inside it, goes back to the agent that wrote the file. This is the feature most worth knowing about — it has a section of its own.
• The model it ran on is in the line of facts under the title, and it is a button. Click it to run this session on a different model — see moving a session onto a newer model.
• The rail down the left is the session's own history in time, hours marked, so "what happened this morning" is one click rather than a scroll.
• Find in this session with ⌘F.

Hopping between two sessions

Switch, in the session's top bar, or ⌘J: a short list of the sessions you have touched today, most recent first, with the one you just left pinned at the top. Press a digit to pick a row. Going back and forth between the two things you are actually working on this morning is then the same two keystrokes in both directions, instead of closing the session, finding the other card and opening it.

Moving a session onto a newer model

A conversation is stuck on whichever model it was started with. That is not a Cockpit limitation — the model is an argument to the command that started it, so a session opened in August is still answering on an August model in September, and the only way out used to be to abandon it and start again in a terminal.

Click the model in the fact row. The menu that opens tells you two things that are easy to confuse, and then lets you change the second:

• What this conversation ran on — read out of the transcript itself. History.
• What it will run on from here — your choice, remembered per session. A session you started before this control existed has no choice recorded, and the menu says so rather than pretending the transcript's model was picked.

Pick a row, or press its digit — 1–9, as in the Switch menu; a longer list keeps the rows and drops the digits past the ninth. Another model… takes an exact id for anything the list does not have. Default clears the choice and hands the decision back to the CLI's own settings.

What happens on the click depends on whether anything is running, and the menu says which before you press it:

• A turn is in flight — it is stopped and given again, unchanged, on the model you picked. You do not retype anything.
• Nothing is running — nothing is re-sent. Your next message starts the session on the new model. Picking from a menu never makes an agent redo work it already finished.

The choice applies to turns Cockpit starts. A session you also drive from your own terminal keeps whatever model that terminal was started with, until you send from here.

Explaining a word in the conversation

An agent names a tool, a flag or an error you have never seen. Asking the session about it costs you the session: a busy agent reads your question when it finishes the turn it is in, and the answer lands in the middle of the work you were reading.

Select the words instead. A small Explain this button appears at the end of the selection; press it and the answer arrives in a card on the passage, in about ninety words.

• The session is not told. No message, no turn, nothing added to the transcript — the same one-shot model call the document Explain action uses, with the conversation around the passage as its context so a word is explained in the situation it came up in.
• It stays on the words. The passage keeps a mark, and pressing the marked text opens the answer again — tomorrow, and after another twenty turns. The answer is stored against its own quotation rather than a position in the transcript, so it is still on its sentence when the conversation has grown underneath it.
• Go deeper in a new session hands the passage to a fresh agent when ninety words is not enough. It opens the new-session sheet seeded with the passage, in the background, leaving you where you were.
• The bin deletes the answer for good. Nothing else on the session changes.

Escape closes it and puts you back on the board, in the same place you left.

Commenting on a document

You are reading something an agent wrote. Three paragraphs are wrong. The useful thing to say is not "fix the doc" — it is this sentence, and that heading, and the number in the table. Typing that into a message box means describing each passage in prose the agent then has to go and find again.

Select it instead. That is the whole feature, and it is worth the minute:

1. Open a file in the right-hand pane and select any passage — a word, a sentence, a table row. A small box opens with the passage quoted at the top.
2. Type what should change. ↵ keeps it; a newline needs ⇧↵.
3. keep and send hands it to the agent that wrote the file, right then. keep saves it for later, which is what you want while you are still reading.

For a whole line there is nothing to select: hover the left margin of the document and press the + that appears on that row.

PDFs, LaTeX and formulas

A PDF opens in the pane as pages. Its words lie over the pages, so you comment on it the same way as on anything else: select a passage, then comment, ask what it means, or hand it to an action. A .tex file opens as the document it describes — headings, lists, tables and the equations drawn — with raw for the source. Formulas written as $…$ or $$…$$ are drawn wherever markdown is shown, answers to comments included.

Reading a document and then handing over the lot

The comments collect in a list under the document, and every one of them has a mark in the margin next to the passage it is about — click a mark to jump to the comment, and the comment lights up. When you reach the bottom, send all n sends every unsent comment as one message.

That is the gesture the feature exists for: go down a document leaving eight notes the way you would on a colleague's draft, then hand the lot over once. One message means the agent plans one piece of work instead of eight interruptions, and comments on more than one file are grouped by file inside it rather than interleaved.

What the agent actually receives

Each comment arrives as the passage, quoted, followed by what you said about it. The quotation is the part that makes it actionable — an agent told "see the comment on line 40" has been told nothing, and line 40 has moved since.

I left 2 comments on `design.md`.

### Comment 1
> The anchor set is the six sizes we ship today.

This is stale — SIT has 21 now.

### Comment 2
> roughly four weeks

Say which four weeks, or drop the estimate.

Please address these in `/Users/you/notes/design.md`.

Cockpit composes that message itself, from its own record of what you wrote. Nothing in the document can put words into it.

Comments follow the text as it is rewritten

A comment is a note plus a quotation, and the two have very different lifetimes. The note is yours for ever; the quotation is a position in a file the agent is actively rewriting. So Cockpit stores the quoted passage and a little of the text on each side of it, and finds it again every time the document is opened. Insert three paragraphs above it and the comment is still on its sentence.

• The passage has moved since — found, but its surroundings changed. Normal, and not a problem.
• This passage is no longer in the file — the agent rewrote it away. The comment is still there, still says what it said, and can still be sent: an orphaned comment travels with its quotation, so the agent can see what you were looking at. Cockpit says so out loud rather than quietly re-pointing the comment at somebody else's paragraph.

A comment you have sent is marked sent, so a second pass down the document does not send it twice. delete removes one for good.

Comments that were already there

A document fetched from a service usually has comments of its own — the ones people left on it in Chorus, say. Those appear in the same margin and the same list, in a group headed In Chorus, above your own. They are outlined rather than filled in, and they have no buttons: there is nothing to send, resolve or delete, because Cockpit never stored them. Reply to one where the thread lives.

The selection menu can grow an entry for the other direction. On a Chorus document it offers Comment in Chorus next to Comment — the same box, the same gesture, but the comment goes to the document where everyone reading it will see it, rather than to the agent. Which entries appear depends on the viewer plugin drawing the pane.

Having it read to you

read aloud, in the row above the document, turns it into audio. Two things start at once and each becomes available the moment it is ready, so there is nothing to wait for in particular:

• overview — a minute and a half of spoken prose that Cockpit's model writes about what the document says and what its tables and charts actually show. Enough to know whether you need to read the thing.
• a small speaker in the right margin beside any paragraph you point at. Press it and the voice reads from there to the end; while that paragraph is being read the speaker is a stop, and the paragraph is marked. Titles are not read out — they are on the screen — so the reading goes from paragraph to paragraph.
• 1×, 1.5×, 2× just under the speaker, on the same hover, applied to the passage already being spoken as well as the next one. Your choice sticks for the rest of the sitting.

It happens in the background: a line of small text beside the controls counts the passages as they are made, and the document stays readable and commentable throughout. The voice is the one macOS already has, which is why this costs nothing and works with the network off — System Settings → Accessibility → Spoken Content has better ones to download, free, and Cockpit picks up whichever you make the default. The words are cleaned up before they are spoken, so identifiers, urls and stray markup are not read out at you. The document's own row — its title, read aloud and overview — stays pinned to the top of the pane while the text scrolls underneath.

It keeps going when you leave. Switch to another session, or back to the board, and the voice carries on; Reading … in the window's title strip says which document, takes you back to it, and has a stop button. Come back and the reading is as you left it. What was made is kept with the document — the overview and the descriptions of its tables and figures — so opening it again, even after a relaunch, is ready at once with no model call. If the document has changed since, the button says changed — refresh audio, and nothing is redone until you press it. Money in shorthand is said the way a person says it: "$14MM" is "14 million dollars".

Tables, charts, images and code are summarised, not recited. Reading a table across is listening to its shape rather than its numbers — "Week 1, Week 2, Week 3" — so each of those blocks is described instead: what is set against what, and what it shows. The whole document goes to the model for that, paragraphs included, because a table of percentages means one thing under "Error budget" and another on its own — but what comes back is an instruction per block rather than a narration. Your paragraphs, headings, lists and quotations are read from the document's own words, always, and a block the document did not need spoken at all — a page footer, a revision history — is skipped rather than announced. The descriptions arrive while the reading is already under way, and if they cannot be written the voice falls back to saying what the block is — a table of so many rows and its columns, a listing's length, a figure's caption.

A log or a script gets the overview only. Press read aloud on a build log, a shell script, a source file or a dump of data and you get the spoken summary and no paragraph controls. Ten thousand log records in a synthesised voice is not listening to anything, and what you wanted was what went wrong.

Only the overview and those descriptions involve a model, and they are the one part that leaves the Mac — see What leaves your Mac. With no model configured there is no overview, and the reading works anyway.

Answering

The box across the bottom of an open session types into the real session — the same conversation, the same transcript on disk. There is no separate Cockpit chat.

• ↵ sends. ⇧↵ makes a new line.
• Images: ⌘V anywhere in the conversation column pastes a screenshot in, or drop a file on it, or use Attach an image on the + at the left of the typing line. They are saved next to the message and the agent is told to go and read them.
• While the agent is working: what you type is queued and sent when the turn ends — it will not interrupt by accident.
• To interrupt on purpose: ⌘. anywhere in the session, or the stop button on the typing line. The agent stops what it is doing; the conversation stays open and you can carry straight on.

Taking a session over in the terminal

Continue in the terminal, on the + at the left of the typing line, opens the session in the integrated terminal — claude --resume on the same conversation, with the model, permission mode and browser use Cockpit was running it with. It is how you reach /chrome, /agents, /config and every other slash command that has a screen of its own, which the channel Cockpit drives a session over cannot show. Cockpit hangs up its own channel as the terminal opens, so the two never write one transcript, and the typing line will not send while the terminal has the session. Close the tab and Cockpit picks it back up on your next message.

Changing how a session is launched

The model chip's menu has a Launch flags section under the models: permission checks on or off, browser use on or off, and Restart with these flags, which resumes the same session id with the new switches — the way you would quit the CLI and start it again. If Cockpit is running a turn, it is stopped and given again; if nothing is running, nothing is re-sent and your next message starts it with the new flags.

MCP servers, from inside the session

MCP servers, on the + at the left of the typing line, lists every MCP server this session has, and the + turns red with a dot when one of them is down. It exists because a session Cockpit is driving has no /mcp screen to open: in a terminal that is where you go when an agent says a server stopped responding, and there is no terminal here.

• Each row says where the server came from — user (your ~/.claude.json), project (a .mcp.json in the folder), or plugin. Cockpit passes all three through untouched; it adds nothing and hides nothing.
• The list opens instantly because it is what the agent itself announced at startup. That is a roster of names, not a health report, and the menu says so: rows read not checked until you ask. check all really connects to every server and can take a minute; clicking one row checks just that one, in about a second.
• A failing server shows its actual error — a missing runtime, a bad path, a refused request — on its own line under its own row, in full, rather than the word "failed". Every failing row shows one; with three servers down you see all three reasons.
• A row that reads permission error answered and refused us: an HTTP 401, 403 or 410, or an error that names the sign-in itself — UNAUTHENTICATED, an expired session, or advice to sign in again, which some company servers deliver inside an HTTP 500. That is almost always a sign-in that has lapsed rather than access you have lost, and Reconnect all will not fix it — sign in again (with that server's own login, or your company's single sign-on) and then check the row. The distinction is worth drawing because the CLI reports both a refusal and a server whose command is missing as the same failed to connect, and the two need completely different things done about them.
• Reconnect all hangs up the channel. Your next message starts a fresh agent on the same conversation, which connects every server again. Nothing is re-sent, so pressing it never makes an agent redo a turn. There is deliberately no per-server restart: the connections belong to the agent's own process and nothing outside it can restart one.

Cockpit's own MCP servers — the ones it calls for plugins and summaries — are a separate list, in Settings → MCP.

Permissions & questions

Both CLIs stop and ask sometimes. Cockpit puts the request in the session and in Attention, and sends your answer back — so a waiting agent is visible instead of being buried in a tab you are not looking at.

Two kinds of ask

• A permission request — the agent wants to run something or write somewhere. You see exactly what it proposed, and Allow or Deny; denying lets you say why, which the agent reads.
• A question — the agent is asking you to choose between approaches. One of the options is usually marked as its recommendation. You can pick one, pick several where that makes sense, or ignore the options and type your own answer.

When you are tired of being asked

A permission request also offers two ways out, and they differ in when they take effect:

• Allow, and stop asking — this request goes through, and checks are waived for this session from its next turn. The turn running now was already started with prompts on, so it will keep asking until it ends.
• Restart without asking — drops this turn and starts the session again with checks off, so it takes effect immediately. It asks the last thing you sent again.

Both are per session and neither is remembered for the next one. What they waive is the same thing the new-session checkbox waives, with the same consequences.

Running a command

Agents suggest shell commands constantly, and copying them out of a transcript into the right directory is the small chore that makes you leave the app. So Cockpit spots them: hover a command in a session and it offers to run it. Accept, and a terminal opens in that session's own working directory with the command already typed.

Nothing runs until you click. The command is typed for you and left there; you press ↵.

How it decides what is a command

A transcript is full of code that is not a command — a log excerpt, a stack trace, a fragment of Python, a file path being named rather than run — and a run button on any of those is worse than no run button at all. So a block has to be recognised twice: Cockpit knows a few hundred command names on sight, and anything it does not recognise is put to a model, in the background, and the button appears when the answer comes back.

That second opinion is what makes the tools you actually use work. sudo jamf recon and the rest of the fleet tooling a managed Mac is driven with, an in-house build wrapper or a team CLI, whatever your team wrote last month — none of those are in a list anybody could finish writing. A quoted path with spaces in it counts as well: "/Library/Application Support/…/Microsoft AutoUpdate" is one word, not three.

Starting a session

The + button in the top bar starts a real session on disk.

1. First instruction, optional. Leave it empty to open an idle session and start talking to it on the board. Add images with ⌘V or add image.
2. Folder: the one you last started a session in. Press it to browse, or see recent for the others and a field to type a path.
3. Agent: Claude Code, Codex or Kiro CLI. As you type the instruction, the skills that fit it are offered underneath; press one to ask the agent to use it.
4. Model: a menu of the CLI's default and the models that CLI says it will take — the same discovered list the model menu uses — with anything else it accepts under Other….
5. ⌘↵, or Start.

The card appears on the board within a few seconds. What you have started is an ordinary session in the agent's own project folder — you can pick it up in your terminal later, or never open Cockpit again, and it is still there.

Browser use starts a Claude Code session with Claude in Chrome (--chrome) — what /chrome turns on in a terminal — so the agent can open pages in your Chrome, click and read them. It needs the Claude extension installed in Chrome, as it does in the terminal. Codex has nothing equivalent, so the box is not offered for it. It is on by default too, and has its own switch in Settings → New sessions.

The Messages view

Board answers "what is my work doing". Messages answers the question that comes before it: what is today, and who is waiting on me. Today's meetings run down the left; everything addressed to you — mail and chat in one timeline — runs down the right.

It reads all of that through MCP servers you already run. Cockpit holds no mailbox password, no calendar token and no OAuth client of its own: it calls a tool named calendar_view or email_inbox on a server you configured, exactly as your agents do. If you have no such server, the view says so and nothing else happens.

Setting it up — it does it itself

The first time you open the view it looks for your calendar, your mailbox and your chat among every MCP server on this Mac — the ones you set up for Claude Code, the ones plugins bring, and Cockpit's own — and starts filling in. It says what it is doing while it looks, and it changes nothing and sends nothing while it does.

Servers are recognised by what their tools do, not by what they are called: the same calendar is outlook-mcp on one machine and something else entirely on the next. A tool whose name says it lists calendar events, and that can be given a day, is a calendar; one that lists the inbox is a mailbox; one that lists channels or chats is a chat. Each tool's own input schema says what it needs — a start and an end, a date in a particular format, a limit, a folder — and Cockpit fills those in. Servers that turn out to be none of the three are stopped again; looking leaves nothing running.

Only if nothing is found does the view say so, with Look again for a server added since and a link to this page.

Settings

The gear opens the settings, for afterwards. How meetings are prepared lists every kind of meeting with an instruction already written — edit any in your own words, or put one back to its default. Where your day comes from shows which server is the calendar, the mailbox and the chat, with the others detection found offered beside them. Your address and the folder prepared sessions run in are under Advanced.

Today

• Each meeting is filed under a kind — 1:1, team sync, review, interview, customer, planning, all-hands, personal time. Rules do most of it; anything they are unsure of is judged by the on-device model. The kind is what decides which of your written instructions applies.
• Prepare starts an agent session on that meeting: it reads what is attached, finds what is waiting on you, and writes a short brief. For a recurring meeting it is handed the last brief it wrote for the same series, and asked to carry forward what is still open and look for the previous occurrence's notes.
• Open opens the entry in Outlook on the web; Join opens the video call, if the invitation named one.
• The ⋯ menu asks an agent to move or cancel it, with a note from you saying when it should move to or what the others should be told. This one needs a calendar server that can write, not only read — see below. If yours cannot, the button is unavailable and says why.
• The day is drawn as a calendar: each meeting a block as long as it lasts, overlapping ones side by side, a line at the current time. Dashed blocks are meetings you have not answered or accepted only tentatively. Press a block for its full row — Prepare, Join, the ⋯ menu. Day | List switches between this and a plain list.
• All-day entries — out-of-office banners, holidays — are folded into one line at the top, with a count. The hide button (the crossed-out eye) takes an entry off the day, every occurrence of it if it repeats; hidden ones are counted at the foot of the day and come back with Unhide.
• Sessions already about that meeting are listed under it — the briefs Cockpit started, and up to three recent sessions whose own title or first instruction is about it. Press the × beside one that is not: it is not suggested for that meeting again (for the whole series, when it recurs), and one marked not relevant to three different meetings is not suggested for any.

Everything coming in

Mail and Slack, in one list, sorted into three tabs by what each message wants from you: Action needed, Informational and Robots. Each row gets one line: for something that needs you, what to do; for the rest, what it says.

• Sorting is spent where you are looking: the newest messages that fit on the screen first, then Load more for the next screenful. A message not sorted yet is shown anyway, marked sorting…. The list re-reads itself every fifteen seconds while the view is on screen.
• Move to… puts a message in the right tab when it was sorted wrong. The model turns each correction into one general rule about that kind of message, says it, and uses it from then on; the rules are listed under How messages are sorted in the settings, where a wrong one can be removed.
• Expand shows the whole message — the full mail thread, read from your mailbox without marking it read, or the whole Slack conversation. Open in Slack opens a Slack message in the Slack app.
• Start working asks what the session should do, then starts one with your instruction and the message as its context.
• Respond asks an agent to draft a reply. You say what you want to say; it writes it, in your own style, and shows it to you before anything is sent. Sending is a separate press. If no server here can send, Respond is unavailable and says so.
• Ack takes a message off the list as useful, no reply needed. Not relevant hides it and teaches the sorting to hide things like it. The number hidden is beside the tabs; press it to see them, each saying why, and Unhide any.

When a server cannot be reached

Mail setups vary a lot, and the view expects some of them to fail. When one does, the half it feeds says what is wrong in a sentence, keeps the server's own words behind what it said, and leaves the other half working. What each message means:

Servers you have configured for Claude Code — in ~/.claude.json or in an installed plugin — are offered in Set up under Already set up for Claude Code, and adding one is a single press. A server's own PATH is honoured after your login profile runs, so the Node you chose for it is the one it gets.

Which MCP servers work

Cockpit recognises tools by name. Any server offering these will do:

Add the server under Settings → MCP servers — or, if it is already in your ~/.claude.json, import it there in one press. A server that needs a particular PATH or token can carry its own environment on that screen, which is the usual fix for a tool that runs from Claude Code but not from Cockpit.

Read-only is a perfectly good way to run this view, and it is the safer one: reading the calendar and the mailbox is all the left column and the timeline need. Writes are only ever needed for move, cancel and sending a reply — all three of which show you what is about to happen first.

Categories

Cockpit groups sessions by subject, not by folder — six directories can be one piece of work and one directory can be five. Categories are that grouping, and they are yours to change.

• Drag a card onto a category to file it there.
• Click a card's icon, anywhere in the app, to re-file it from a short menu — usually faster than dragging.
• Click a category heading to rename it, recolour it, pick a different icon, or upload your own.
• Drag a whole category to reorder it. The order is yours and it sticks.
• Sub-categories, one level inside another — which is what "Softlines → Size guide" wanted to be all along.
• Ten cards at once. Select a range and drag the selection into a category as a single gesture.

Each category has a description of what belongs in it, written in the background by your own agent CLI from the sessions you filed there by hand — and from the ones you moved out of it. It is shown under the heading, and in full when you edit the category, with rewrite now. It is written again only when what you filed changes.

New sessions are filed automatically against those descriptions, by their title and first request, and anything that fits nowhere waits under Unsorted. A category it is unsure of is offered — filed under X? keep · change — rather than asserted; how sure is sure enough is learnt from what you did with its earlier filings (Help → What Cockpit learns from you). A category you set by hand is never overwritten.

Metrics

Metrics is your work over a day, a week, a month or a year, against the same stretch before it. Pick a period at the top, or type two dates.

• What you achieved. A paragraph your own agent CLI writes from what the sessions did: documents, code, CRs, tickets, and what you sent on Slack and by email. guidance tells it how to write; rewrite writes it again.
• By hand, estimated. How long what the agents wrote would have taken you, and how much of your meeting-free time that is. How this is estimated shows the rates, which you can change.
• The numbers. Tokens, estimated cost, your sessions, your time in them, and the messages that reached you and how long they waited. Charts show tokens over the period, time per session and per category. Table shows every number.
• Week over week. Each week's work by hand and cost, by week or by month.
• All categories leaves categories out of everything, the summary included.

Process runs

A process starts a session for each of its steps, and Cockpit sends them their prompts, not you. So those sessions are not counted as yours: they are not in your sessions, your time, or the time by category, and the summary does not treat their steps as work you did.

• Each run is one line under the numbers: its status, what it achieved, how long it ran, how many sessions it used, and what it cost. If you typed into one of its sessions yourself, the line says how many times. Those messages count as yours.
• What they spent is real. It is in the tokens and the cost, and the figures say how much of it was processes. Spend by process adds it up for each process.
• What they wrote is in the by-hand estimate, marked as done partly by process runs.
• The summary reports each run as one achievement, such as "your OE task resolution process closed five of the eight tasks", credited to the process you set up.

Processes

A process is a piece of work you do again and again, written down as numbered steps: "analyse the ticket", "check the analysis", "plan the fix", and so on. Cockpit runs it for you, one session per step, and moves it along until it is done.

Writing one

• New asks for a name and a description: what it is for, and when it is done. That is all.
• + Add step adds a card at the end. Each step has a name and a description in your own words: what to do, when it is done, and where to send the work back if something is wrong ("if the confidence is too low, send it back to step 1, at most twice").
• The arrows on a card move it up or down; the cross deletes it, with Undo.
• Everything is saved as you type.

Guidance for every session

Under the description, write what every session should know: how to reach your systems ("use ada with conduit, role ReadOnly"), and what an agent may do without asking ("you may close Asana tasks in the OE program"). Every session reads it, and so does the agent that steers the run. You can change it at any time, even while runs are going: they pick up the change with their next message. It never asks you to Generate again.

Generate

When the steps are written, press Generate. An agent turns them into the sessions that will do the work, and draws them as a graph that reads top to bottom in step order: each card is one session and the steps it covers, solid arrows show what comes next, and dashed arrows show where work can be sent back (hover one to see when). A step can need more than one session, for example someone to do the work and someone to review it.

Click a session to read what it is responsible for, the first prompt it will be sent, and the follow-ups it may get later ("when the reviewer sent it back → …"). Under the graph, How the run is steered shows the instructions Cockpit follows while the run goes. Every session already has your MCP servers, so the prompts can use Asana, AWS, Chorus, Quip, SharePoint, the wiki and your code directly.

Change a step after that and the plan says Edited since it was generated, and Run now waits until you Generate again. Each Generate makes a new version, Plan v3, with a line saying what changed. Generating again keeps the same sessions and arrows unless your change needs new ones: a precision inside a step updates the prompts and says Structure kept; a step added, removed or reordered says New structure. To start over, choose Generate from scratch in the menu beside Generate.

What you wrote in Guidance for the agent running the process while runs went is meant for every run after, so Generate puts it into the steps it is about (often a Done when: line), empties the field, and says which steps changed: The guidance for the agent running the process is now in steps 2 and 5. What fits no step stays in the field. Guidance for every session is never touched.

A run

Run now asks Anything particular for this run?: leave it empty, or write a note for this run only ("pick OE-4870", "only FRA-PROD"). ⌘↩ starts it. The first session gets its first prompt, and from then on Cockpit checks the run as it goes: when a session finishes a turn, or its state changes, an agent decides what happens next. It starts the next session, sends one a follow-up ("continue", "pick up the next task", "the reviewer sent this back: …"), or waits. Each session keeps its own context the whole way through, and gets one message at a time: nothing is sent to a session that hasn't answered the last one, or that is waiting on you, and the same message is never sent twice. Sessions ask each other for changes by ending a reply with → Reviewer: what to change, and Cockpit passes the message on.

• Several runs at once. Up to twenty runs of a process can go side by side, each on its own subject: the OE process names each run after its ticket ("OE-4812 checkout timeouts"), and runs keep out of each other's way. You can edit the process and Generate again while they go; each run keeps the plan it started with, and says so.
• Waiting on a clock. A session waiting for a deploy or a time shows when it carries on, counting down: in 2 h 5 min · today 12:40 PM.
• Offline. When Cockpit can't reach the agent that steers the run, it tries again, less often the longer it fails, and waits while your Mac is offline. The run says retrying in 4 min · 3 tries · offline, and carries on by itself once it gets through.
• Pause, Resume, Stop. Pause lets working sessions finish what they are doing, then the run waits; Pause now, in its menu, interrupts them at once. Resume carries on from where the run stands, and also gets a blocked or failed run going again. Stop ends the run for good; its sessions stay, with their work.
• Warnings. When something looks wrong (a session gone quiet, work going back and forth) the run shows a warning at its top, and the runs list counts them. Only warnings that are still true stay there; every warning, and when it was resolved, is in the run's history. A warning doesn't stop the run.
• Sessions use your own Claude Code permission settings. One that needs your OK shows needs you, and the run waits for it.
• Open a run from the process's Runs, or click any row, to see the graph with where each session stands, open any session in one click, and read what happened, newest first.

Retrospectives and lessons

A run's page lists its steps' sessions, each with a Retrospective button, and Retrospective of the whole run above them. Press one at any time, while the run is still going too: an agent reads what that session was asked and did, and proposes lessons for later runs, each marked waited (it stopped for you when it could have gone on), mistake or faster (a shorter way was there), with what in the run shows it. It checks them against the lessons already kept: a repeat is dropped, and one that corrects or sharpens a kept lesson says what it replaces.

Keep or Drop each one, then Save. + Add something else takes a lesson of your own: it is made precise against what the run shows and proposed like the others, marked yours. Kept lessons are listed under Lessons on the process, where you can edit or remove them, and every session is given them with the guidance, in later runs and in runs already going. Export and Duplicate carry them too.

On the Board

A process's sessions stay off the Board and the Categories view, so they don't crowd out your own work. Instead, one line at the top says how they are doing: 2 process runs going · 5 of 12 sessions working · 1 needs you · 1 paused. Click it to see every run. In Metrics, each run counts as one achievement, not as your sessions or your time.

Sharing one

Export… saves the process's name, description, guidance, steps and lessons as a .cockpit-pipeline.json file. Import…, above the list, makes a new process from such a file; Generate it before you run it.

Viewer plugins

Cockpit shows whatever your sessions wrote, and what a session writes is not a fixed set. Markdown, code, CSV, images and Word documents are built in because every agent produces them. A Jupyter notebook, a Parquet table, a CAD file, an internal wiki page, a document that lives in some service and only has a link in the transcript — those are documents somebody wants to read here too, and none of them belong in this app.

So the document pane is extensible. A viewer plugin is somebody's code — possibly your own, quite possibly written by one of your agents — that draws one kind of document in that pane, and gets Cockpit's comments and version history while it does it.

Using one

• A plugin is a folder. Installing one is putting that folder in Cockpit's plugin folder; uninstalling one is deleting it. There is no store, no registry and no download button in the app — nothing arrives here that you did not put here.
• Sharing one is a zip. Export… beside a plugin writes it to a zip; Install from zip… takes one, and before copying anything shows what it is, what it may do — each capability in words, every site it may load pictures from — and which version it replaces. A plugin Cockpit would refuse is not installed.
• Settings → Viewer plugins lists what is installed, with what each one claims and what it is allowed to do. Open plugin folder takes you to the right directory in the Finder.
• Nothing is silently lost. A plugin that failed to load is still listed, marked Refused, with one sentence saying what is wrong with it — a missing file, a manifest that claims nothing, a host API it was not built for.
• An update never removes one. Plugins live outside the app, so upgrading Cockpit leaves yours alone, and a release of Cockpit never contains one.

Once a plugin claims a kind of document, opening one of those files draws it with the plugin. A small dropdown at the top of the pane names whichever viewer is drawing — built-in is always one of the choices, so a plugin that renders something worse than the plain renderer can always be got out of the way. The choice is remembered per file type.

What a plugin can and cannot do

It is JavaScript running in Cockpit's window, so this matters. Every plugin declares what it needs, and anything it did not declare throws rather than quietly working:

There is no shell, no file system and no HTTP. A plugin reads the document it was opened on and its own folder, and reaches a service only through an MCP server you set up yourself. Cockpit hands it the same sanitiser the built-in renderer uses and the shortest way to draw anything goes through it, so no plugin needs to hand-roll that.

None of which makes a plugin safe. It is JavaScript you chose to install, running in the window, and it can see the document you are reading. There is no sandbox here and this page will not pretend otherwise: install plugins you or your agents wrote, or ones you have read.

Writing a plugin

One JavaScript file and one JSON file, in a folder. No build step, no npm install, no framework. This is short enough to read in full — and short enough to hand to an agent, which is how most of them will be written.

~/Library/Application Support/dev.rollatgr.cockpit/plugins/
└── hello/
    ├── plugin.json
    └── index.js

plugin.json — who you are and what you claim:

{
  "id": "hello",
  "name": "Hello",
  "version": "1.0.0",
  "apiVersion": 1,
  "entry": "index.js",
  "match": { "ext": ["hello"] },
  "capabilities": ["doc"]
}

index.js — one function, which draws:

export default {
  async mount(el, ctx) {
    const text = await ctx.host.doc.text();
    ctx.setHTML(el, `<pre>${text.replace(/</g, "&lt;")}</pre>`);
    return () => {};              // optional teardown
  },
};

Drop that folder in, press Reload, open any .hello file. That is a working plugin.

The parts worth knowing before you start

• The folder name must equal id. Cockpit reports problems by folder, because the folder is the thing you can go and fix.
• match is four ways of naming the same document — ext, mime, scheme for addresses that are not files, and url for the pages a conversation links to. Any one of them is enough. url patterns are regular expressions over the whole address: anchor them, or you claim half the web and every link in every session becomes a tab.
• apiVersion is a single integer Cockpit owns. Adding things never bumps it — a plugin written against 1 keeps working against a host that has grown. It bumps only when something is removed or changes meaning, and then your plugin is refused by name, with both numbers, rather than half-working. Pin it and leave it.
• Your own version is the cache key. Bump it and Cockpit re-imports your code; Reload does the same without a bump.
• Check ctx.signal after every await. The reader has probably opened something else by then.
• await everything the pane needs, inside mount. Your promise resolving is your statement that the pane is drawn, and it is the only such statement there is. Work you fire off and finish afterwards is invisible to the test harness — and to an agent checking whether your plugin worked.

Comments, from inside a plugin

Comments and version history are the app's features, not the renderer's — they work in the built-in viewer whether any plugin is installed or not. A plugin gets at them so that a viewer which feels native is possible: select a passage in your own rendering, attach a comment, send it to the agent on the left.

const cs = await ctx.host.comments.list();           // anchored to the text as it is now
await ctx.host.comments.add({ start, end, body });  // offsets into host.doc.text()
await ctx.host.comments.submit(cs.map((c) => c.id)); // one or many, as one instruction

If what you are showing is not the bytes of the file it was opened on — you fetched it from a service and the file is a pointer — an offset would mean nothing. Pass { quote, body } instead: Cockpit anchors the quotation if it can find it, marks the comment orphaned if it cannot, and either way the quotation travels to the agent.

Two more, for a document that has comments of its own. comments.show hands them over for Cockpit to draw in its margin and its list, read-only, grouped under the name of the system they came from; ctx.actions.add puts an entry in the app's own selection menu and runs your code with the passage the reader chose.

ctx.host.comments.show("Chorus", [{ id: "1", quote: "45.8%", body: "does that include the app?" }]);

ctx.actions.add({
  id: "comment",
  label: "Comment in Chorus",
  needsText: true,                    // opens the app's own draft box
  async run({ quote, range, text }) { /* your call to your service */ },
});

Both are additions, so a plugin written before them still declares apiVersion: 1 and is untouched. show needs the comments capability and actions.add needs actions.

Read aloud, from inside a plugin

The viewer can read a document out loud — an audio overview Cockpit's own model writes, then the document itself passage by passage, with a play pip beside each one. Declare audio and say what your paragraphs are, in reading order, and your pane gets the same thing the built-in renderer has.

ctx.host.audio.parts([
  { kind: "heading", text: "Revenue by region" },
  { kind: "text", text: "The margin was 12%, which beat the plan." },
  { kind: "table", text: "A table of six regions by quarter." },
]);

Declared rather than inferred, because only you know it: a plugin's document is often not the file it was opened on, and the paragraph boundaries are yours either way. text is the passage as it reads, not as it should be said — Cockpit rewrites it for the ear and speaks it with the system voice, offline, so a plugin author never has to know how a synthesiser mispronounces a UUID. A passage better heard described than recited is one you describe, as the table row above does.

Testing one before anyone else runs it

1. In the app: Settings → Test with a file… — one document, one plugin, no session needed, with a dropdown that also offers plugins which do not claim the file, so "why does mine not pick this up" is answerable.
2. From the command line, with no app running: node scripts/plugin-test.mjs path/to/my-plugin, from the Cockpit source tree, checks the manifest exactly the way Cockpit does, imports your module and calls mount against a stub that records every call. A plugin whose document lives in a service can put the service's answers in a plugin-test.json next to the manifest and run the whole fetch-and-render path offline.
3. From an agent, over Cockpit's own MCP control server: ask it to render your plugin against a file and it answers with the text your plugin actually drew. Same harness as the first route, on purpose.
4. Against the real service, before you ship: node scripts/plugin-live.mjs path/to/my-plugin --calls. The three routes above all run your plugin against your fixtures, and the fixtures are the server — so a server that will not start, or that no longer has a tool you call, passes every one of them. This starts the configured server the way the app does and requires every tool you have a fixture for to really be there. It is read-only and refuses to send a mutating action. The release script runs it and will not build past a failure.

A plugin can also have ordinary tests of its own — export what is worth testing alongside the default export. The one shipped example does exactly that, and it is where the selection gesture is covered, because a real DOM is the only place an event can really fire.

Settings & keys

This machine

Per CLI: found or not, which version, and whether it is signed in. Reading transcripts needs only the folder, so a CLI can be read-only and still fill the board — starting a session or sending a reply is what needs the credential. Read this first when something looks wrong; it is included in a problem report automatically.

Sources

The folders Cockpit reads transcripts from. The usual ones are found for you; add another if you keep sessions somewhere unusual — and note that adding one through the picker is also how macOS grants access to it, which is why there is no way to type a path that the system has not let you choose. Removing a source only stops it being read; it deletes nothing. Cockpit never writes into a folder another tool owns.

Two settings, not a form

Cockpit reads, shows and answers your sessions with no key at all. There are exactly two entries here, and both exist for the one thing it cannot do locally: read a session and work out what it is about.

• On-device categoriser. Sorts every session into your categories and every message into the timeline's tabs — which is what the board is arranged by — with a model that runs on the Mac (Laya multilingual, Apache 2.0). Nothing it reads leaves the Mac. It downloads once in the background, loads only while there is something to sort, and learns from every recategorisation. On/off, the download, and what each part has learnt are in this panel. Apple silicon only.
• Cockpit's model, for its own short calls — the card summaries, the ask box, Explain, and a command-bar sentence the built-in grammar cannot parse. There is nothing to choose and no key to paste: it runs one claude -p (or codex) on whatever authentication your CLI already has — subscription, Bedrock, Vertex, a company gateway, or a managed install where /login is disabled outright. Those runs happen in Cockpit's own scratch directory with session persistence off, so they write no transcript and cannot appear on your board. Two controls: which model to ask for, and a button that turns the whole thing off, after which cards keep the summary Cockpit assembles locally and the ask box is unavailable.

  Cockpit asks for a small model on purpose — haiku — because its errands are a three-sentence brief and a title, forty at a time. It cannot guarantee that is what serves them: a machine-wide pin (enforceAvailableModels together with a model in ~/.claude/settings.json, which is a normal thing for a company-managed Mac to have) overrides the request, and then the calls run on whatever that file names, billed at that model's rate. From 0.1.7 the panel says so in amber after the first call, naming the model that actually answered. If you see that line and did not expect it, that file is the first place to look.

Without either, nothing breaks: sessions are still found, read, opened and answered. They are simply not summarised or filed for you. When the model finishes downloading, the sessions waiting for it are sorted straight away.

Keys

A key you paste in is written to one 0600 file in Cockpit's support directory — never into the index, never into a log, and never handed back to the window: this side of the app only ever learns whether a name has a value. You can also import from a .env file rather than paste.

New sessions and debug logs

New sessions sets what the new-session sheet starts with: skip permission checks, and browser use — both on unless you turn them off here. Debug logs keeps a record of what was slow, what failed and when the window stopped drawing: one file a day in Cockpit's own folder, the last fourteen days, never the content of a transcript or a document. Off unless you turn it on; worth turning on when something is wrong, so it can be read back afterwards instead of reproduced.

Updates, plugins, MCP

Further down: whether to check for new versions in the background (see Updates), the MCP servers Cockpit knows about, and Viewer plugins — which live outside the app, so an update never removes one and a release never contains one. There is no store and no download button on purpose: a plugin is JavaScript that runs in this window, and installing one should be the deliberate act of putting a folder somewhere. The panel opens that folder, lists what is in it, says why anything is refused, and re-reads it on Reload. A plugin built against a different host API is refused rather than run. There is a section on what plugins are and how to use one, and another on writing one.

Data on disk

The second tab, for the question "what has this thing actually got?" — every source with its file count and size, each index table with its row count, the knowledge folder, and the keys file with the names it holds and no values. Nothing on that tab is a control; it is an inventory.

Updates & problems

Updating

Cockpit is not in the App Store, so it looks for its own new versions. Two routes, and it matters which one you are on:

• By itself. One request to aidash.dev, at most once every six hours, and never while you are being asked anything. Finding one puts a notice on screen. You can turn this off in Settings → Updates.
• Because you asked. Check for updates in this panel, which is not throttled and answers now.

Either way you get the version, the date and the release notes, and Install and restart does the rest.

Reporting a problem

Say what you were doing and what happened instead — a short title and your email are optional — and press Review the report. Cockpit puts the report together on your disk and sends nothing yet. It shows you every part as it would be sent: your words, the screenshot, the recent log and the diagnostics, each with a remove button and a way to look inside. Send report files it with Cockpit's bug tracker and gives you its number, to quote if you write to support@aidash.dev. If you would rather send it yourself, email it instead opens a pre-filled email with the zip to attach.

Suggest a feature, the other tab, works the same way for an idea: say what you would like and what it would save you, review it, and send it. An idea goes with the app version only — no log, no diagnostics — unless you put them back on the review screen.

A report carries:

• What you typed, and the version you are running.
• The doctor check, and counts — how many sessions, how many roots. No titles.
• The last few hundred log lines, with paths shortened and anything resembling a key, a token or an email address replaced.
• A picture of the Cockpit window — only if you leave that box ticked.

It never carries what you or an agent wrote in a conversation. Do look before you send; that is why every part is shown. While the screenshot is taken the Help panel steps aside, so the picture is of the app, not of the form.

Keyboard

What leaves your Mac

Cockpit reads transcripts of everything you have asked an agent, in folders named after your projects and often your employer. So this list is short on purpose, and it is the whole list:

There is no account and nothing to sign in to, and nothing above happens without you doing the thing that causes it.

Usage counts

From 0.1.6 Cockpit also counts how it is used, so the next version is built on something other than a guess. It is one checkbox in Settings → Usage counts, on until you turn it off, and this is the entire list of what it sends:

• the app was launched — with how many days since you installed it, and how many sessions are indexed
• a session was opened
• a turn was sent to an agent, and whether it carried an image
• a session was started, and whether it was started in the background
• a document was opened, and whether it was md, docx, chorus, pdf, an image, text or binary
• the selection menu was raised, and which of its three actions was taken
• a passage was explained, and whether Claude or Codex answered
• a comment was written; comments were handed to the agent, and how many
• a panel was opened, and which one; the board was rearranged, and which way; a search was run; the command bar was used
• MCP servers were checked; a viewer plugin ran; an update was checked for; an update was installed

Every one of those is a count or a word from a list written out in the source. There is no parameter that could hold a title, a project, a category, a path, a link, a prompt or a line of a transcript, which is why none of those can be sent by mistake: the app has nowhere to put them. The identifier is a random number made on your machine the first time it sends anything — not your name, your login, your hostname or anything derived from your Mac, and two installs are two unrelated numbers. Dev builds send nothing.

Turning the checkbox off stops all of it: nothing is collected, nothing is queued and nothing is kept for later. It also forgets the random identifier, so the number your earlier counts were filed under is gone — switch it back on and a new one is made, which makes the two spells as unrelated as two separate installs. The switch is in Settings → Usage counts; COCKPIT_NO_TELEMETRY=1 does the same without opening the app. The enforcement lives in src-tauri/src/telemetry.rs if you would rather read it than take our word.

What it writes

Its own index, logs, key file and attachments, all under ~/Library/Application Support/dev.rollatgr.cockpit. Cockpit never writes into a folder another tool owns, so your transcripts are only ever read. Starting a session is the one exception, and it is the CLI itself that writes the transcript, in its own place, exactly as if you had typed the command.

If something is wrong

Release notes

Every published build, newest first. The same notes appear in the app: Help → Check for updates shows them before you install.

Every build, still downloadable

An installer is kept for every version ever published and none is withdrawn, so you can go back to one — or check what you already have. Each is a universal build, signed and notarised. Verify a download against the checksum beside it: shasum -a 256 Cockpit_<version>_universal.dmg.

The current version is the one the Download button on aidash.dev gives you, and the one an installed Cockpit offers under Help → Check for updates. An older installer does not stop the updater: whatever you install will offer to move to the newest build.

0.1.23 — 29 October 2026

• A wiki of what your sessions learn. The book in the header opens one wiki shared by every session, with the skills they built, arranged like your board and opening on a map of every topic.
• A coach on Metrics, outcomes and outputs, and how long each process's runs take.
• Explain teaches: it picks a picture for the question, and diagrams go in steps.
• Work that was cut off is picked up again after a restart, an update or a shutdown.
• Far less CPU, GPU and battery: the board stops drawing when hidden, and the on-device model uses three cores and sleeps while it waits.
• Slack links open in Slack, and a page that stops on a sign-in offers your browser.
• Fixed. Signing in from Cockpit; Messages stuck on "reading your mail and chat again"; a message already answered said it was not picked up; Slack messages settled later still asked you; a crash on a bullet character.

0.1.22 — 22 October 2026

• Processes. A new tab: a job you do again and again, written as numbered steps that sessions work through until it is done. Generate turns the steps into sessions and their prompts; runs go side by side, up to twenty, each on its own subject.
• Guidance and decisions. Guidance for every session, separate guidance for the agent running the process, and a decision card when a run needs you.
• Reference a session in a prompt with /session.
• Word documents show their pictures and formulas.
• Schedule shows two weeks and your calendar; Metrics keeps week over week.
• Company settings, not company code: sign-in and company specifics come from ~/.cockpit/sign-in.json and ~/.cockpit/company.json.
• Fixed. A Slack reaction from you now counts as an answer; notifications stay until you act on them; comments in Word documents with tables anchor in the right place.

0.1.21 — 17 October 2026

• A tidier header. Session ▾ (New, Fork, Merge with…, Archive), Switch, Schedule ▾ (Remind, Snooze) and Stats; click the name to change the category; the counts are in Stats.
• Prepare asks first. Say how you want the meeting prepared; the session starts when you send it.
• Fixed. Slack conversations you had already answered still asking you to act.

0.1.20 — 16 October 2026

Merge with… in two steps: choose which session carries on, its model, and what it should do with both. The one that carries on is told what the other was asked and found.

0.1.19 — 16 October 2026

Agents keep working while Cockpit is closed, without a session ever splitting in two.

• Agents carry on when Cockpit quits. On reopening, a session still at work simply shows as working; a message you send it waits until that work is done.
• Delete from the Schedule. On a reminder's card and in its edit sheet, with Undo.
• Fixed. "Nothing left to do" while helper agents still worked; recycled sessions starting outside their project.

0.1.18 — 15 October 2026

A tighter Needs You screen with Ack, your whole schedule in one window, sub-agents grouped under the session that started them, and a comment mode for documents.

• Needs You and Ack. Each card carries Open, Snooze, Ack and Archive; Ack takes a session off Needs You until it moves again.
• Schedule. The calendar icon on the board shows your week as a timetable, with day, month and year views.
• Sessions. Fork, Ignore, Merge with…, and sub-agents shown under their parent. Drafts are kept.
• Documents. Comment mode (⌘⇧M), pinned documents, Mermaid diagrams, ⌘-click to the browser.
• Fixed. A background scan that could take minutes, sessions closed while background work ran, scheduled messages lost while the Mac was off.

0.1.17 — 13 October 2026

Sign-in that fits how your company does it, a dashboard that says how long the work would have taken by hand, explanations that read the whole document, and a board that copes with thousands of sessions.

• Sign-in. The first time, Cockpit lists the ways this Mac signs in (Midway with your security key, then with a one-time code, on an Amazon laptop) and remembers the one that worked. Settings shows how long Midway has left, and a session warns an hour before.
• Dashboard. Copy the summary, tell it how to write, leave categories out, see the few results that stand out in bold, and an estimate of how long the code and documents would have taken by hand against your meeting-free time. New charts.
• Explain works the same in a conversation and a document, with follow-ups; it reads the whole document and can open the files it mentions, read-only.
• Background sessions a program started are kept in one closed group; a session asked for a handoff offers to carry on fresh; problem reports, if you want them.
• Fixed: thousands of sessions no longer stop the app; a session that stopped mid-task says so with Continue; "N agents working" while background agents run; sheets no longer drawn under a web page; long answers no longer cut off; local preview links open; new sessions are sorted while others work.

0.1.16 — 9 October 2026

A dashboard that says what you achieved, reminders and snooze, a simpler way to act on a message, and a window that can be dragged again. It also carries everything built for 0.1.15, which was never published on its own.

• Dashboard. Tokens and estimated cost, time in sessions and by category, and how fast messages were acted on, against the period before — opening on a paragraph of what you achieved in the period, which can be read aloud.
• Reminders on any date, repeating, with an optional message to send; Send later in the composer; Snooze a session off the board.
• The Cockpit view offers two actions on a message: start a new session, or send it to one. A forwarded message is marked in the transcript.
• Long sessions stay fast (from 0.1.15): a wiki and skills per session, recycling instead of compacting, child sessions, HTML rendered, Stats per session, and going back to an earlier version from Help.
• Fixed: the window can be dragged again; a Slack reply could go to the wrong thread; the performance panel flickered; a recycled session could lose files; a gap could appear on the board; cards too narrow to read.

0.1.14 — 7 October 2026

Categories that file themselves by what they are about, an inbox sorted all the time, and a much lighter footprint on the Mac.

• Category descriptions. Each category is described by your own agent CLI from the sessions you filed there by hand; new sessions are filed against those descriptions, so a big category no longer takes everything. How sure is sure enough is learnt from what you did with earlier filings.
• The Cockpit view reads and sorts mail, chat and tasks every few minutes whichever view is open, with a summary on top of each tab; the agent decides each message's tab from the whole thread. Asana and Jira tasks join the calendar, mail and chat; messages can be marked Done or In progress, and show the sessions started from them.
• Usage limits and outages in Claude Code, Codex and Kiro are said plainly, with when they lift; queued messages wait for them.
• Report a problem and Suggest a feature send from Help, after showing exactly what goes. Sonnet is the default for Cockpit's own calls; every code block has a copy button.
• Lighter on the Mac: one copy of Cockpit at a time, sessions started one after another, at most six live at once, and closing a session closes every server it started. A session that is starting, or that cannot reach its provider, says so. A Word document packaged as HTML now opens.

0.1.13 — 4 October 2026

No keys: Cockpit sorts your work with a model on your Mac and learns from you. Kiro CLI joins Claude Code and Codex, and documents gain PDFs, LaTeX and formulas.

• An on-device categoriser. Sessions, messages and meetings are sorted by an open decision model that runs on the Mac and learns from every recategorisation; a category it is unsure of is offered, not asserted. Nothing it reads leaves the Mac. The hosted categoriser and its key are gone.
• Kiro CLI sessions on the board, to start and continue like the others; a new Mac with no agent CLI is offered all three, each with an Install button.
• Skills indexed, filed under your categories and offered as you type a new session's instruction; a new session opens at once.
• PDFs in the viewer with comments, Explain and actions; .tex files read as documents; formulas drawn everywhere, answers included.
• Search results by relevance under the search box, an expression read as an expression; each card shows which agent it runs on; comments send instantly; a document keeps its place; no more "Where is use_default?".

0.1.12 — 2 October 2026

A third view, Cockpit: your day as a calendar on one side, everything addressed to you on the other — and the board, the switcher and plugins made quicker to use.

• The Cockpit view. Today's meetings drawn like a calendar, overlaps side by side, with Prepare on each; mail and chat in one live timeline, sorted into Action needed, Informational, Meetings and System, each conversation summarised with what it needs from you. It finds your calendar, mail and chat servers by what they do, opens on what you had last time, and keeps what it worked out.
• Respond, Start working, Read it all on every message, from one ⋯ menu; Move to… teaches the sorting a general rule.
• Plugins travel as a zip — Export… and Install from zip… in Settings, with what a plugin may do shown before it is installed.
• ⌘S reaches Board, Cockpit and Categories; a second ↵ on an empty box sends what is queued; the + is the toolbar's main button.
• A crowded board column scrolls instead of shrinking its cards; a search says why each card matched; every wait shows what it is waiting for; the window no longer freezes on a slow read. The board chat and the flat list are gone.

0.1.11 — 1 October 2026

Search that finds a session by anything said in it, the agent answering your comments, read aloud that keeps going across sessions, coming back to where you were, and a long list of fixes from two days of using 0.1.10.

• Search finds a session by anything said in it. Every transcript, and the text documents sessions wrote, are indexed, and the board's search box finds a session by a CR number, an alias, an error message — anything in it. Built once in the background on first launch, then kept up to date with only what each session has said since.
• The agent answers your comments. It is asked to say what it did about each one, and the answer appears under the comment, kept after the passage is rewritten. A comment remembers the version you reviewed, one press away on the timeline.
• Read aloud carries on. It keeps reading when you switch session, with a Reading … indicator in the title strip to go back to it or stop it. What it made is kept, so a document read yesterday plays at once today, and a changed one offers to refresh. The speed holds between paragraphs, and "$14MM" is said as "14 million dollars".
• Back to where you were. Switching back to a session reopens the document you had open, at the place you had scrolled to. Editing a comment happens in place.
• A simpler new-session sheet, with skip permission checks and browser use on by default — both switchable off in Settings → New sessions.
• No more freeze on switching to a long session, and debug logs in Settings for when something is wrong.
• A link can no longer take the whole app over. Pressing a link in some previews loaded the website into Cockpit's own window, with no address bar and no way back but quitting. The window now refuses to go anywhere but the app, and every link — in the conversation, a document, a plugin's pane, an Explain card — opens in the session's page pane, or in your browser with ⌘ held.
• Comments say which line they are on. Each comment sent to the agent names its line in the file as the agent will open it, and when the same words appear elsewhere, which occurrence you meant. Unsent comments show in the document's pinned bar, with a send that hands them all over in one message.
• The file panel leads with the files you would open. With a JEV key, each file a session touched is judged once — something you asked for, something you would read, the agent's working material, or machine output — and the panel shows the first two, with +N other for the rest. Search always covers everything. Without a key, nothing changes.
• Videos and recordings play. .mp4, .mov, .m4v and .webm play in the viewer, and .mp3, .m4a, .aac and .wav as audio — streamed a range at a time, so a long recording starts at once, through an address only Cockpit's own window can use.
• And: Slack and other sites that called the page pane an unsupported browser now open; links in the pane that ask for a new tab work; a Chorus document shows that it is loading; switching sessions no longer flashes the board; the session view can no longer get stuck slid out of place; and attaching, MCP servers and the terminal sit behind one + beside the typing line.

0.1.10 — 29 September 2026

Documents read aloud a paragraph at a time from a small speaker in the margin, a word in the conversation explained without interrupting the session, more of the commands an agent suggests actually runnable, browser use and a terminal takeover for every slash command, files an agent bulk-created in a folder, how long ago each card last moved, the panel leads with the document being worked on, web pages actually show, a notification you can press, every link in the session in one list, pictures are a carousel, code has line numbers, find behaves like a find bar, and a plugin's document is a document: comments on one save, and Chorus documents are read aloud and keep up with the agent.

• Read a document aloud. A read aloud button on any document the viewer can draw. Two things then happen at once, because they are ready at very different times: Cockpit's own short model call produces a spoken overview — what the document says and what its tables and charts show — while the document itself is turned into audio paragraph by paragraph in the background, so you can start at any paragraph that is done rather than waiting for the end. Not the characters in the file: a document read out verbatim turns a URL into ninety seconds of letters, so each passage is rewritten for the ear. Tables, charts, images and code listings are summarised rather than recited — "Week 1, Week 2, Week 3" is listening to a table's shape rather than its numbers, so the model is given the block and says what it shows, arriving while the reading is already under way and falling back to announcing the block if it cannot. A log, a shell script or a dump of data gets the overview and nothing else, because ten thousand records in a synthesised voice is not listening to anything. The voice is your Mac's, offline, and the download does not grow by a byte; the Siri and Enhanced voices are a free download in System Settings → Accessibility → Spoken Content and are picked up as soon as they are there. Audio is cached by content, so a paragraph is synthesised once however often it is played. One press starts it, never an open — and a viewer plugin that asks for the new audio capability has its own document read as the document. One small speaker, beside the paragraph: point at one and press it to read from there, and it becomes a stop while that paragraph is spoken, with 1×, 1.5× or 2× on the same hover. Titles are not read out, since they are on the screen. The passage being spoken is marked and scrolled to if you have wandered off, and the document's title and its overview button stay pinned to the top of the pane while the text scrolls underneath. While the overview is still being put together it says so, instead of leaving a silent gap between the two halves.
• Browser use, and the terminal for everything else. A Browser use box on the new-session sheet starts Claude Code with Claude in Chrome, which is what /chrome does in a terminal. The model menu gains Launch flags — permission checks and browser use — with a restart that keeps the session id. And a terminal button beside the composer hands the session to the integrated terminal, with the flags it was running under, for every slash command a Cockpit-driven session cannot show; Cockpit steps aside while it has it.
• Files an agent bulk-created in a folder. When the agent names a folder, the files in it that were made or changed while the session was running join the documents panel — forty frames a script wrote without naming one of them included. Every board card also says how long ago it last moved.
• Explain a word in the conversation. Select anything in the transcript and a small Explain this button appears at the end of the selection; press it and the answer arrives in a card on the passage, in about ninety words. The gesture the document pane has had since 0.1.5, on the half of the screen where the unfamiliar words actually are. Nothing about the session moves — no message, no turn, nothing added to the transcript — and the conversation around the passage is the context, with the model told plainly that what surrounds it is a record of a dialogue and not an instruction, because otherwise it reads your last message and starts doing the work instead of explaining the word. It stays on the words: the passage keeps a mark and pressing the marked text opens the answer again, filed against its own quotation rather than a position in the transcript, because a turn's number shifts when the middle of a long conversation is folded away and the passage's own words do not. Go deeper in a new session seeds the new-session sheet with the passage, in the background, when ninety words is not enough — and an answer can be deleted for good, which closing the card is not.
• More of the commands an agent suggests are actually runnable. Three faults, reported as one. The tooling a managed Mac is driven with — sudo jamf recon, msupdate, profiles, pmset, tmutil, csrutil and the rest of a "why is my laptop like this" session — was not in the vocabulary at all. A quoted path is one word: the check split on whitespace, so "/Library/Application Support/…/Microsoft AutoUpdate" began with a first word of "/Library/Application, which is not the name of anything; an argument can now read like prose without the line being taken for prose. And behind both, the second opinion was never asked about a code block — Cockpit knows a few hundred command names on sight and puts anything else to a model in the background, which is the judge that exists to recognise the names no list could finish, your team's own wrapper included, and it was only ever being asked about commands written inline in a sentence. The near misses now go to it, and a block gains its button when the answer comes back. Still conservative on purpose: a run button on a log excerpt is worse than none.
• The document you are working on comes first. Recency alone got this wrong in a way that was easy to reproduce: an agent writing a design document reaches for a throwaway script to draw a chart for it, and the strip put plot_tmp.py — written twelve seconds ago, never to be opened by anyone — in front of the document the whole turn was about. Within a sitting the order is now prose, then a word-processor document, then code, then the outputs a script produced, with links last. Only within a sitting: half an hour from the newest thing touched, after which the kind stops counting and the clock decides again, because a design document from Tuesday is not more relevant than this morning's code.
• Web pages show. The pane was blank most of the times it was opened because it was an <iframe>, and a frame is a nested browsing context — so X-Frame-Options: DENY applies to it, which is nearly every address behind a corporate sign-in, and the refusal is undetectable from outside. A page is now a native child webview: a top-level browsing context, which those headers do not apply to. No browser is bundled and the download does not grow by a byte — it is the same system engine Cockpit's own window is drawn in. back and reload on the bar, because a pane with no address bar is one in-page link away from stranding you, and browser still hands the address to your real browser. http and https only, checked again for every hop the page itself attempts, and the page gets no bridge to Cockpit.
• Every link in the session, in one list. A globe beside the tab strip on any session that mentioned an address: the whole list at once, with each address, how long ago it came up and how many times it was mentioned. Its own filter matches the whole address rather than the shortened name, and three orders — newest, name, mentions — where pressing the one already chosen reverses it. A row opens the page in the panel; the button beside it opens the address in your browser and leaves the list up.
• Pressing a notification lands on the session it was about. A reminder coming due, or another session finishing, has always posted a macOS notification; pressing it brought Cockpit forward and left you on the board to find the card again, which is most of the work the notification was meant to save. Now the press opens that session, and the window comes forward with the right card already on screen. A notification outlives the app, so one pressed an hour later about a session that has since been removed opens nothing rather than an empty card.
• Pictures are a carousel. A session that wrote eight screenshots gave you eight tabs named Screenshot 2026-09-… .png, which is a row of identical words. Pictures now get ← and → and a position — 3 of 8 — and the arrow keys do the same thing. It wraps, because a viewer that stops at the last picture makes the last picture a dead end.
• Line numbers in code, drawn by the stylesheet rather than as digits in the markup — so copying a block still gives you the code and not the numbering, and a comment still lands on the passage you selected.
• Find behaves like a find bar. 3 of 11 rather than a bare total, ↑ / ↓ to step, Return and ⇧Return in the box, ⌘G and ⌘⇧G from anywhere. Each step scrolls the conversation to that match. The panel narrows to what matches and the counts under the kind icons come down with it, and the document you have open is scrolled to its first match with the matches highlighted. The count, the arrows and the clear ✕ no longer overlap: each used to be pinned separately to the right edge — four guesses at how wide the other three were — so the arrows sat on top of the ✕ and neither could be clicked.
• A plugin's document is a document. Commenting on one failed to save, because every comment was filed under the canonical path of a file and a plugin's document need not be one — a chorus: address has no path to canonicalise. Comments, the explain action and read-aloud now key a document the same way whether it is a file or an address a plugin drew, and everything the viewer can do is reachable from a plugin: the document's text, comments in both directions, an entry in the selection menu, being told the file changed underneath it, a line on the notice bar, and declaring its own paragraphs so it can be read aloud. A fake plugin exercises all of it in the test suite, mounted in a real pane, because no plugin ships with Cockpit to notice when one of those paths quietly breaks.
• Chorus documents read aloud and refresh themselves. Read aloud did nothing useful on one: the pane was the document, but the file was a one-line pointer, so the voice read out a URL. The plugin now says what its own paragraphs are, and a Chorus design doc is read the way a markdown one is; a heading's play button reads from the first paragraph under it. Its tables, code blocks and diagrams are described rather than recited: the plugin hands the block itself over, and it is summarised the way a markdown table is, so a document that came from Chorus and one that came from disk sound alike. A pointer file an agent rewrites is followed, redrawing in place and even following it to a different document; a refresh that fails leaves the document you were reading on screen and says so.
• The open document keeps up with the agent. The pane used to show whatever the file said when you opened it, for as long as it stayed open — an agent told to fix a table rewrote the file, said it was done, and you were still reading the old text with no sign of it. A changed file is now re-read and swapped in place with an updated chip to say why the words moved, and it costs nothing to know: every poll already asks the file system whether each document exists and how big it is, so when it last changed comes off the same question and an unchanged file is not re-read at all. Nothing is swapped while you have a half-written comment over the document.
• A comment says sending while it is being sent. Handing a comment to an agent returns when the instruction reaches the CLI's input, which is not when the agent has read it: a cold agent takes twenty seconds to start and a busy one reads its input when it finishes the turn it is in. So the row says sending for as long as the call is really in flight and sent only once the agent's own state says so, a failed send goes back to offering send, and what the agent was told appears in the conversation column immediately — the conversation being where you look for an effect.
• The model menu lists the models your CLIs actually take. It offered three family names — Opus, Sonnet, Haiku — which made it the one place in Cockpit that could not answer the question you open it to ask: the chip above it says the conversation ran on claude-opus-5-5, and the menu said "Opus", which is not a version. The list is now discovered from the CLIs themselves, with the family names kept as the fallback for a CLI that says nothing, and the doctor's Re-check refreshes it. Pressing a model also does something visible straight away, instead of greying out the menu while the chip went on naming the old one.
• Stopping a Codex turn stops the session, not just the process. After pressing stop the composer still said the agent is working, held what you typed instead of sending it, and a second press answered that the turn had been started somewhere else. The process really was gone: Codex has no channel to say "stop" down, so stopping one ends the process, and a Codex that has been killed never writes the line that closes the turn — leaving the transcript saying started for the next half hour. Cockpit now keeps what only Cockpit knows, that the process which was going to finish the turn is not running; it can only close a turn, never open one, and it stops applying the moment the transcript grows again, so a session you pick back up in your own terminal is believed. The same was quietly true of Claude Code, where [Request interrupted by user] is written in your voice and was read as a fresh request the agent still owed an answer to.

0.1.9 — 28 September 2026

A session running a long command no longer looks idle, the document panel shows the last day of work rather than everything the session ever wrote, a comment opens over the passage it is about and can be reworded, and a Chorus table keeps its colours.

• A long command still looks like work. A tool call writes nothing until it returns, so a ten-minute build is a ten-minute silence in the transcript — and Cockpit read that silence as an agent that had stopped. Two and a half minutes into the longest thing it had been asked to do, the card stopped animating and the stop button went. It now takes the CLI's own word that it is mid-turn: the session stays warm, the foot of the transcript keeps naming the command — running Bash… 8m since the last entry — and the stop button stays where you can reach it. Believed for half an hour, so a CLI killed mid-call settles rather than claiming to work for a week.
• The document panel shows the last day, not the whole session. A session going for a week had written for a week, and the panel offered all of it at once. It now shows a rolling day — measured from the newest document rather than from the clock, so a session picked up after a fortnight still shows the day's work that produced its files — and says how much is behind it. N older at the end of the strip and again at the foot of the grid, or simply scroll to the end of the grid. There is no window while you are searching, the file you have open is never hidden whatever its age, and reading a file keeps it in the window without moving the window.
• A comment opens where you wrote it, and can be edited. Pressing a comment's mark in the margin used to scroll you down to the list under the document — away from the very line the comment is about. It now opens the comment over the passage, in the same card you typed it into; a second press puts it away. Several comments on one line share one mark and the card is where they are told apart. Edit is on every comment you wrote, in the card and in the list: only the text changes, so rewording is safe even on a comment the agent already has — and it says so rather than refusing. The draft box's buttons are save and send, and Escape now backs out one layer at a time instead of closing the session.
• Colours in a Chorus table. A Chorus table is usually a status board, and the markdown export carries none of that — so every one of them arrived as a plain grid. The plugin now asks Chorus for each table's formatting and paints the cells, with the text colour computed from the fill. Coloured text and highlight marks are still not shown: there is no way to read them.

0.1.8 — 28 September 2026

An address an agent mentions is a page you can look at, a message sent mid-turn tells you where it landed, ⌘S hops between sessions, and your MCP servers list their tools with a reconnect button on every row.

• A message sent while the agent is working says where it landed. It used to look like nothing had happened — the text left the box and the transcript, which is the agent's own record, had no reason to mention it yet. A note under the conversation now says added to the queue, second in line, and counts down as the agent works through what is ahead of it. Drawn once: it used to appear as a pending note and again as a real turn, which read as the message having been sent twice.
• ⌘S hops between sessions. Hold ⌘, tap S to walk the list, let ⌘ go to commit — ⌘Tab for sessions, with ⇧ to walk back up. The first row is the session you were last in, not the one a background agent touched most recently, so switching back stays one gesture. ⌘J still raises the same list as a menu that waits. Switching is much faster on a long transcript: the end of the conversation is drawn first and the rest fills in behind it. New sits beside Switch and starts a session in the category of the one you are reading.
• Your MCP servers, and one button each. The server menu under the typing line lists every server the session has and what each one offers — press a row and its tools appear, at no cost, because the session names its tools when it starts. Every row has its own reconnect, which contacts that one server and says whether it answered: a one-second answer to "did my fix take?" instead of a minute re-checking thirty others. Servers Cockpit runs and servers the session was given are one list now.
• Reminders, and a heads-up when another session finishes. Remind me takes a date and a time, then notifies you, says so on the board and highlights the card until you deal with it. And when an agent runs out of turns with an empty queue while you are reading a different session, you are told which one it was.
• Reading a long session. A jump to the latest pill when you have scrolled away from the end; a search box that filters the file list as you type; each session reopening the file you last had open, with the list ordered by what you looked at most recently. Commenting on a passage puts the box at the selection rather than at the top of the document. A session's summary is kept once it is worked out and reused afterwards, including by the chat, which could previously see only the title.
• Things that were failing quietly. Cockpit notices when the machine is off the network and says so in one place. A Chorus document that came back Refused now says what refused it — usually a lapsed sign-in. An MCP server that answers with a 401, 403 or 410 is called a permission error rather than a failure, because the fix is a login. Restarting on a different model shows restarting… where the model name goes, and the model menu is shorter: the ones you would pick, and default instead of a dated id nobody chose.
• Word tables with merged cells, and files too big to draw. A .docx table with merged cells rendered as a grid with holes in it and text in the wrong columns; spanning cells are now drawn as one cell. A large binary is no longer handed to a viewer that would read all of it — the panel says what it is and offers the Finder. And opening a session with a couple of hundred files is fast again.
• A URL opens in the panel beside the conversation. Every address a session mentions is a document now — a dev server on localhost, a page on the internet, a doc on an internal site — drawn in place instead of only when a viewer plugin claimed it. The frame is sandboxed and sends no referrer, and Open this page in your browser is always there, because a site that refuses to be framed cannot be detected from the outside. Opening a session never fetches a page: a file the session wrote wins the first view even when an address is newer.
• A screenshot you send looks like the screenshot. It used to become a 90-character path the moment the turn came back — the path is what the agent is given, since neither CLI takes image bytes on a command line, and it is the one thing you cannot use. The message keeps the thumbnails, with your own sentence above them.
• !command has a Run button. Claude Code marks a command it wants run with a leading !, which Cockpit read as part of the command — so the first word was a program no shell has, and the block arrived as prose. The bang is now recognised and stripped before the line reaches the terminal, which matters because in zsh ! is history expansion. A ! that means "not" is left alone.
• The terminal you put away comes back from the bottom of the window. A tile where the dock was, saying how many terminals are still running — not an icon in the header several hundred pixels away.
• Every file a session wrote, by folder. The all-files view groups by directory, newest first, with the session's own folder shown as ./; the cards are about a third of their old size, so a session that touched fifty or a hundred files is one screen rather than a scroll.

0.1.7 — 27 September 2026

Cockpit's own short calls had been failing silently on company-managed Macs, and it now tells you which model really answers them.

• Summaries work again on a managed install. One of the flags used to make Cockpit's own call inert also discarded your user settings file — and on a Mac routed through Bedrock or a company gateway, the credential is in that file. So every call spent about three minutes retrying and came back with an expired-token error. The flag is now a stricter one that says nothing about your settings: the same call went from 177 seconds to a 403, to 8 seconds to an answer. Nothing looked broken while it was happening, because a failed summary quietly falls back to the one Cockpit assembles locally — so if your card summaries have read a little flat, this is why.
• It says which model actually answered. Settings → Cockpit's model now reports, in the CLI's own words, when the model serving these calls is not the one asked for — the machine-wide pin case, where asking for Haiku is answered by Opus at roughly twenty times the price with nothing anywhere saying so. Shown only when the two disagree, and only after a real call: an alias resolving to a dated id of the same family is the alias doing its job, and is left in silence.
• The model it asks for is an alias again. haiku, not a dated id — see what an alias asks for. A dated pin names the right model on the day it is written and a superseded one for the rest of the install's life, while looking like the more precise of the two. Existing installs carrying one are moved to the plain family alias on launch; anything else you typed is left exactly as it is, because those are choices.
• The ⋯ button over a passage you select is visible. It was a faint glyph on a transparent chip, and the three dots of that icon are each about a tenth of its width — so what arrived on screen was a smudge. It now has an edge, a shadow and full-strength dots: still the quietest control in the app, but the weight is spent on shape rather than colour.

0.1.6 — 26 September 2026

Cockpit now counts how it is used — and this is the release where the sentence in What leaves your Mac changed, so that is said first rather than last.

• Usage counts, with the list printed. How many people use Cockpit, how often they come back, and which parts they open. One checkbox in Settings → Usage counts, on until you turn it off, with the complete list of what it sends written next to it — the same list as in What leaves your Mac.
• No content can be sent, not merely is not. Every parameter is a number or a word from a list written out in src-tauri/src/telemetry.rs. There is no parameter that could hold a title, a project, a category, a path, a link, a prompt or a line of a transcript, so a call site added later cannot leak one by accident. The payload is composed in Rust rather than in the window that handles your text.
• The identifier is a random number made on your Mac the first time anything is sent — not your name, your login, your hostname, or anything derived from the machine. Two installs are two unrelated numbers. There is still no account. Turning the checkbox off forgets it, so a later change of mind starts from a new number.
• Changing a session's model looks like it is happening. The menu closes on the press and the chip says restarting… until the relaunched agent writes, then names the new model. It used to do all of that invisibly: the menu sat open with its rows greyed out and the chip went on reporting the transcript's model, which does not change until the new agent has written a turn — so a switch that worked perfectly looked like a dead button.
• Off means off. Nothing is collected, queued or kept for later, so there is no backlog that would go out if you changed your mind. COCKPIT_NO_TELEMETRY=1 does the same without opening the app, and development builds send nothing at all.
• A broken MCP server now says what is wrong, under its own row, in both lists — the session's servers on the typing line and Cockpit's own in Settings. A refusal is labelled permission error rather than failed, because an HTTP 401, 403 or 410 means a lapsed login and not a broken server, and reconnecting cannot fix it. Cockpit's own client also reads the HTTP status before the body, so a server that refuses it no longer reports no JSON-RPC message in response — which described the parser rather than what happened.

0.1.5 — 25 September 2026

Selecting a passage now asks you what you want, and Cockpit's own thinking no longer needs an API key.

• A selection no longer opens the comment box. The commonest reason anyone selects text is to keep their place while reading, so the form used to appear uninvited. What appears now is one small mark at the end of the selection, faint enough to read past.
• The mark opens a menu with three actions. Comment is the old behaviour. Explain answers a question about the passage in the margin without telling the session anything — no message, no turn, no interruption. New session seeds the new-session sheet with the passage and starts the work in the background, leaving you on the document you were reading.
• An answer is not a comment. It arrives labelled with which CLI wrote it and stored already settled, so send all can never sweep an explanation up and hand it to the agent as an instruction. The margin counts notes and answers separately.
• The first run no longer asks for an API key. Summaries and explanations go through the claude or codex you already have, in a mode that writes no transcript — so they cost no setup and leave nothing on your board. One optional key is left in Settings, for the categoriser, and nothing waits on it.

0.1.4 — 25 September 2026

Two fixes for 0.1.3, both reported within hours of it going out.

• A Word document is no longer cut off. A .docx opened on its white page stopped about a third of the way down, with a scrollbar inside the page and empty space below — a document sliced through the middle of a table. Pages are now as tall as their content, and the document scrolls as one.
• MCP servers that would not start now start. A server whose command lives somewhere your shell adds to PATH — ~/bin, ~/.local/bin, anything set up in .zshrc — could not be found by the app, though the same server worked from a terminal. Cockpit was asking a login shell for your PATH, and a login shell does not read .zshrc. If a server was showing as failed, press check all in the server menu; no re-import and no re-login needed.
• A server that will not start says why. The error now quotes what the server itself wrote on its way out, instead of reporting only that the connection closed.

0.1.3 — 25 September 2026

A session driven from Cockpit has no /mcp screen and no --model flag to pass, so the two commonest mid-conversation repairs both ended in a terminal. Both are now inside the session.

• The session’s MCP servers, from the typing line. A plug at the left of the box lists every server, says whether it came from you, the project or a plugin, and turns red when one is down. check all connects to each; a single row can be re-checked on its own. A failing server shows its real error, and Reconnect all hangs up the channel so your next message reconnects everything — without re-sending anything.
• The model for the next turn, from the model chip. It keeps what the transcript ran on separate from what runs next, offers aliases rather than pinned versions so “the latest” keeps meaning the latest, takes a model it has never heard of, and says in advance if picking one will stop and re-run the turn in flight. While the change is happening the chip says restarting… in place of the model name, then names the model that runs from here — the transcript above it still ran on the old one, which is why the two are worded differently.
• Word documents on paper, with working links. White sheets with a visible edge, one per page break the author made, and hyperlinks that actually open — Word stores the words and the address in two different places, and only one of them was being read.
• Every document a session wrote, in one list. When there are more than the tab row can hold, the unread count opens the lot: whole names, ages, unread markers.
• A documented plugin framework, plus a pre-release check that starts the real MCP server and asserts every tool the plugin uses exists on it — the failure every offline test passes.
• Fixed: the Switch button opened nothing. Its menu was being clipped to nothing by an ancestor’s backdrop-filter, which looks exactly like a dead button.

0.1.2 — 25 September 2026

The settings panel was a configuration screen for an app with two decisions in it. It now asks those two questions and no others. Everything else is about moving between the work.

• One categoriser key, one model. Three key rows and six agent rows became two entries: the JEV key the board’s arrangement depends on, and one model for summaries, the ask box and spoken commands. Cockpit never runs two.
• Your existing Claude Code install is the default, and needs no key. The other four ways are Anthropic, OpenAI, OpenRouter and a local Ollama, and a key is asked for only where one is needed. Next to each is a link to where to get it.
• Pasting a key starts what it was blocking — the JEV key begins categorising your backlog then and there, with no restart.
• Folders can be reordered and nested one level, and a multi-card selection can be dragged into one as a single gesture. Dragging and then scrolling in the category view no longer files the card into the folder that was under the pointer.
• A Switch button, and ⌘J. Today’s sessions, most recent first, with the one you just left pinned at the top; a digit picks a row. Two keystrokes instead of four actions and a visual search.
• Choose the model when you start a session, rather than taking whatever the CLI’s default is.
• A Word table is a table. The .docx viewer read one as a column of one-line paragraphs, so a six-cell info box arrived as six stacked headings.
• A title that is only an identifier is rejected. An id is kept and given words beside it — “PR-4821 size guide fails to load”, never the number on its own.

0.1.1 — 24 September 2026

Mostly the rough edges of the first build: the two places Cockpit gave up quietly instead of saying what it needed, a permission panel that asked for things it did not have to, and a poll that re-read your largest transcript from the top every three seconds.

• Codex with no credential is explained rather than failed: a panel that says nobody has signed in, and a button that opens the real codex login in a terminal.
• A CLI you moved or reinstalled is found again. Cockpit remembered the path it first saw, so switching your Codex install off npm left the button doing nothing. The remembered path is now checked before it is used.
• “Allow, and stop asking” waives permission checks for a session from its next turn on — for the conversation you started yourself with --dangerously-skip-permissions, which Cockpit cannot know about when it resumes, so it chooses the careful mode and asks you anyway.
• “Restart without asking” abandons a turn that keeps asking and runs the same instruction again with the prompts waived. The session is resumed, not replaced — nothing is archived and no second card appears. Codex gets this button too, since it is the only thing that can be done there.
• Compaction shows progress. A session compacting its history used to show the whole prompt and look stuck; it now says “Compacting…” with a bar.
• “Working” now means working. The live row read the transcript’s timestamp, so an agent that had stopped was still described as working with a clock counting up under it. Both CLIs write the end of a turn down, and Cockpit now reads it.
• Codex sessions no longer claim to be compacting when they are not. How full the window is was estimated from the transcript’s size using a figure measured on Claude Code, and Codex writes about nine times as many bytes per token. Both CLIs count their own context, and those counts are used now.
• Viewer plugins can match a URL, not just a filename, so a link an agent wrote to a document the plugin understands opens in the viewer on the right. Installed plugins need Settings → Plugins → Reload to pick up a new manifest.
• Reading an open session is about 400× cheaper. The conversation poll re-parsed the whole transcript every three seconds — 255 ms on a 135 MB, 6,819-turn conversation — and now reads only what was appended: 0.6 ms.

0.1.0 — 24 September 2026

The first public build: the board, with a badge on the sessions waiting for an answer; attention, as one table with a reply box per row; an open session with its transcript, summary, files and timeline; replying, interrupting and answering permissions in the app; clickable commands; starting a Claude Code or Codex session from the app; categories; comments on a document sent back to the session that wrote it; a version timeline per file; viewer plugins; settings, keys and the doctor; and an incident report that gathers redacted diagnostics and sends nothing.