v2.0.1

v2.0.1 — Diagrams that read cleanly, and the canvas brings back what you removed

Fixes for the canvas that arrived in 2.0.0: arrows in auto-arranged diagrams no longer cross through boxes, anything you removed from the canvas can be brought back, switching folders keeps you where you were, and the corner only speaks up when an agent changes something you can't see.

---

📐 Diagrams: arrows follow the layout

• Auto-arranged diagrams read cleanly. Arrows now follow the route the layout computes, with their bends and room for their labels, instead of cutting through boxes. That covers the editor, PNG, SVG, PDF and draw.io exports.
• Moving a box re-routes only its own arrows. The others keep their route.
• Loops no longer flip the flow. A cycle like "needs a tool? → no → back" keeps the steps in the order they were written.

🧩 Bring things back to the canvas

Removing a diagram, document or presentation from the canvas never deleted its file, but there was no way to put it back. Now you can:

• Drag it from the file explorer and drop it on the canvas. The canvas highlights while you drag something it accepts, and the node lands where you drop it. If it's already on that page, the view jumps to it instead of duplicating it. For a presentation, drag its .slides folder or any file inside it.
• Or use Add → Project file… to pick it with the file chooser.

🧭 Smaller changes

• Switching folders keeps your place. Picking a folder in the workspaces panel takes you back to whatever you were last looking at there (an agent, a file or a browser) instead of its first agent.
• A quieter corner. The bottom-right corner no longer lists every busy agent out of sight (terminal agents showed up as busy whenever their screen redrew). In canvas mode, it now shows up only when an agent changes a document, diagram, presentation or note you can't see (on another page, another workspace or with the canvas hidden), and goes away a few seconds after the last change. A click takes you there. Pending permissions keep their own notice.

v2.0.0

v2.0.0 — The canvas: agents, browsers, diagrams, documents and presentations on one board

A workspace can now be shown as a canvas. Agent terminals, browsers, notes, diagrams, documents and presentations are nodes you move around, split into pages. You make diagrams, documents and slides there with your agents, and watch each change appear as they work. Everything you can do on the canvas, an agent can do too, through new MCP tools.

---

🧩 The canvas

• Tabs or canvas, per workspace. The new button in the title bar switches the workspace between its tabs and a canvas.
• Pages that start empty. Each page is its own board: add the agents you want to see there, a browser, a note, a diagram, a document or a presentation. Nothing loads by itself.
• Only what you look at runs. Only the page on screen is live, and an agent that isn't running starts only when its node comes into view. Opening the canvas doesn't launch every agent of the workspace.
• Terminals and browsers keep running. Moving, zooming or switching between tabs and canvas never restarts a terminal or reloads a page. At 100% zoom you use them right on the canvas; zoomed out, a click brings them back to 100%.
• Arrange, fit, move between pages. Lay out a page as a grid in one click, fit everything on screen, move a node to another page. New agent tabs join the page you're on.
• Your agents' colors. Each node carries the color of its agent, and whatever an agent touches is outlined in its color, with its name, for a few seconds.

📐 Diagrams

• Flowcharts and architecture diagrams, saved as files of the project (docs/diagrams/*.diagram.json) and versioned with your code.
• Shapes for both: step, decision, start/end, input/output, database, cloud, person, document, text, and groups that hold other nodes (a VPC, a service, a layer).
• Edit them directly. Drag from a shape's edge to connect it, double-click to write, then pick colors, arrowheads and line style. Undo, copy and paste work as usual.
• Automatic layout, left to right or top to bottom, groups included.
• Export to PNG, SVG, PDF or draw.io, to keep editing in diagrams.net. The export looks exactly like what you see.

📄 Documents

• Markdown documents of the project, on a canvas page or in a tab, that update live while an agent writes them. When it adds a section at the end, the view follows it.
• Read, edit, or both side by side on the canvas. What you type saves itself. If an agent changed the file while you were typing, you choose which version stays.
• PDF export on A4 with real, selectable text, headings, lists, code, quotes, tables and images, including your diagrams. Also from any Markdown tab.

🎞️ Presentations

• One HTML file per slide in a folder of the project, with a shared theme and the size you choose: 16:9, 4:3, A4 portrait or landscape, or a custom size. Each presentation also includes an index.html that plays it in any browser.
• Build them without HTML. Add a slide from a layout (title, bullets, two columns, image, quote, section), then click any text on the slide and type. Also bold, italic, headings, lists, images, duplicate, delete, drag to reorder, five themes and the sizes. HTML stays available for the rest.
• Only the current slide and its neighbors load, so long presentations stay fast.
• Present full screen with the arrow keys, and export one PDF with a page per slide.

🤖 Agents can do all of it

New MCP tools, approved automatically except the one that launches a new agent:

• Canvas: canvas_read, canvas_pages, canvas_add, canvas_update, canvas_arrange, canvas_view, and canvas_spawn (asks for approval).
• Diagrams: diagram_create, diagram_read, diagram_edit and diagram_export. Agents can place everything with automatic layout instead of coordinates.
• Documents: doc_create, doc_write (one section at a time) and doc_export. asset_capture saves a diagram or what the agent's browser shows to docs/assets/ and returns the Markdown image to insert.
• Presentations: slides_create, slide_write, slides_read, slides_edit, slides_goto and slides_export. The view follows each slide while the agent writes it.

👀 Agents working out of sight

A stack of cards in the bottom-right corner shows the agents still working that you can't see: fleet tasks, and agent tabs that are busy in another tab, another canvas page or another workspace. Each card has the agent's logo, what it's doing, and whether it's waiting for your permission. It folds into a bubble of logos, and a click takes you to that agent.

🧭 Smaller changes

• Weekly usage in the status bar. Each account's ring now has two arcs: the 5-hour session outside and the week inside, each turning amber and red on its own.
• A Markdown tab can export to PDF, and a .diagram.json or a presentation's deck.json opens as a diagram or a presentation, with a switch to see the file.

v1.9.3

v1.9.3 — A usage panel for every agent, Codex quota, and lighter restored tabs

The status bar now shows how much of each account's quota is used, and one click opens a panel with every account. Codex accounts report their quota too, Claude's quota loads on Windows, restored tabs no longer launch every agent at once, and closing a window stops its terminals. Plus a new palette and four new languages.

---

📊 Agent usage panel

• Each account chip in the status bar has a ring with how much of its 5-hour window is used. It turns amber at 70% and red at 90%.
• Clicking a chip opens Agent usage with every account: a ring around the agent's icon, its plan, and segmented bars for the session (5 h), the week and each model's week, with when each window resets and when it was last checked.
• Opening the app doesn't launch anything. It shows what was saved; with the panel open, expired data refreshes, and again every 5 minutes. Claude accounts are checked one at a time.
• Errors say what happened: expired session, not logged in, folder trust prompt, timeout, agent not installed… An expired or missing login shows Log in again, which opens the login terminal right there (also for the system account), and any error offers Retry.

🧮 Codex quota

• Codex accounts report their quota by asking codex app-server. It uses no quota and Control Code never reads the credentials.
• Windows are named by their length, so the free plan's 30-day window shows as Monthly. A blocked account says it hit the plan limit until the window resets, and purchased credits count as overage.
• The fleet uses it too: it skips a Codex account whose window is full until it resets.

🩹 Claude quota fixes

• Windows: usage never loaded, because Claude Code asked again whether to trust the probe folder. It's now recorded the way Claude Code writes it.
• The trust question is detected even when the TUI draws it with cursor moves, instead of waiting until the timeout.
• An expired or missing login is reported right away instead of ending in "the panel didn't show up in time".
• No leftover processes: the probe stops its whole process group, including the MCP servers claude started.
• Faster: transcripts are read incrementally, only what grew since the last check, instead of re-reading a week of history every time.

🪶 Lighter on memory

• Restored tabs wait until you look at them. When the app opens, each restored tab starts its agent the first time it's shown (or when you paste or drop something into it), instead of every tab resuming its agent at once. A tab that hasn't woken up keeps its saved scrollback.
• Closing a window stops its terminals. Its agents used to keep running unseen, and reopening the workspace started a second process on the same session. A tab moved to another window keeps running, and so do background subprocesses.

🖼️ Window drawing on Linux

• GPU compositing is always on, and its setting is gone. With it off, on Wayland the window could show up in pieces with the desktop visible behind it. If text looks blurry on your machine, you can still set WEBKIT_DISABLE_COMPOSITING_MODE=1.
• The window no longer ends up shifted sideways with a transparent gap after focusing an input or dragging a selection.

🎨 New palette

Neutral graphite grays and a muted steel-blue accent for selection, focus and links. The terminal, the editor, buttons and dialogs all follow the same palette; the terminal's ANSI colors stay as they were.

🌍 Four new languages

Português, Français, Deutsch and Italiano, under Settings → Language.

🧭 Smaller changes

• The new-agent wizard shows each agent as a card with its brand-colored icon and "Vendor · CLI", marks the selected one, and is now titled New agent.
• Dependency updates: Tauri 2.12.4 and its plugins, CodeMirror, React 19.3.1 and others.

v1.9.2

v1.9.2 — Edits that show what changed, and a chat that doesn't freeze the window

Claude Code's graphical interface now shows file edits like the terminal does: only the lines that changed are colored, with line numbers and syntax highlighting. Writing long answers no longer freezes the window, and the workspace picker moves to the side panel.

---

✏️ File edits show only what changed

Edits used to paint every line of the old text red and every line of the new text green, and rewriting an existing file showed it entirely as added (#23).

• Applied edits use the diff Claude Code made against the real file, with surrounding context and the file's line numbers.
• Before an edit runs (for example, while it waits for your permission), it's compared line by line; a whole-file write is compared against the file as it is on disk.
• The header says what happened, like the terminal: Created src/a.ts +19 −0, Updated src/store.ts +2 −1, with the path relative to the tab's folder.
• Code is syntax-highlighted with the same grammars as the editor. Unchanged lines stay neutral, and long stretches collapse into N unchanged lines.
• The fleet's permission cards and the permission notification show only the changed lines too.

🔌 MCP tool calls

Calls to an MCP server show the server as a label, the tool's readable name and its main argument (the URL, the text…) instead of mcp__server__tool. Parameters are listed as fields instead of raw JSON, JSON results are formatted, and long results fold.

⚡ The chat no longer freezes the window

• Claude's output reaches the window in batches every 50 ms, with consecutive text pieces already joined, instead of one event per line.
• Only the message that is growing is redrawn, and the conversation renders at low priority, so typing, clicking and switching tabs stay responsive while the agent writes.
• Sending, stopping and checking a turn no longer run on the app's main thread.

🧭 Smaller changes

• The mode is now called Graphical. The top-right button switches between Graphical and Console.
• The workspace picker moves to the side panel's header. With the panel collapsed, it sits in the rail above the +, as a button with the workspace's initial.

v1.9.1

v1.9.1 — Claude Code without the terminal, a new top bar, and your repo in the cloud

Claude Code tabs can now drop the TUI and run as a chat drawn by the app, on the same conversation. The window gets a new top bar with a workspace picker, live tab status and notifications. Sessions has a detail panel, and you can create a GitHub, GitLab or Gitea repository for a folder without leaving the app.

---

💬 HTML mode for Claude Code

The HTML mode button in the top-right corner of a Claude Code tab turns it into a chat, and Console takes it back to the terminal with --resume. Whatever is running is stopped first, so two processes never write the same session.

• The whole conversation, history included: markdown, reasoning, every tool as a card with its output, edits as diffs, the todo list as a checklist, subagents nested under their task, compactions and the cost of each turn.
• Permissions inline, next to the tool that asks, with remember for this folder: the same rules as the fleet.
• Questions from Claude (AskUserQuestion) show their options and a field for another answer.
• The / commands as components: model, effort, permission mode (ask, accept edits, plan, don't ask), compact and new conversation, plus a / menu with the agent's skills and commands. /btw asks a side question on a copy of the conversation without adding to it. Commands that only exist in the TUI say so.
• The model picker shows versions (Opus 5.5, Sonnet 5.5…): the newest of each family, from the installed CLI's catalog and from what your recent sessions actually ran.
• It keeps what you were using. Switching from the console picks up the session's model and effort, and switching back relaunches the TUI with them.
• Enter sends, Shift+Enter breaks the line. What you send while it works is queued; Stop (or Esc) ends the turn. Paste images, attach files as @mentions; dropped files, browser elements and git items land in the input.
• While it works you see how long the turn has been running and how many tokens it has used.

Each message is one claude -p --resume turn with stream-json, no hidden protocol.

🧭 New top bar and workspaces

• Workspace picker in the top bar: your saved workspaces and their folders, save, new workspace, new window and add folder.
• Tabs show what the agent is doing: waiting for your permission, working (with how long), or finished while you weren't looking.
• A notification bell collects agents that finished or are waiting for you.
• The left panel is now Folders; + Add folder opens the setup wizard in a dialog, and Home is that same wizard on the page.
• Several windows per workspace, and a workspace can open in this window or another one.
• New workspace creates the new window before closing the old ones, and a second click while the first is still going is ignored (the app used to close).
• Fleet, Subprocesses, Pull requests, Marketplace and Skills open as full-window dialogs. In a narrow window only one side panel stays open.

📜 Sessions

• A detail panel for the selected session: reopen (with or without options), where it ran, the account, the current state of its skills, the prelaunch commands and the tabs that were open beside it. Export and remove live there now.
• The list groups by date or by project, and filters by agent with counts.
• Opening Sessions no longer freezes the window while another part of the app is saving.

☁️ Create the repository in the cloud

From Changes, a folder that isn't a repository yet, or a repository without a remote, can get one on GitHub, GitLab or Gitea with one of your accounts: pick the owner (you or an organization), name, description and visibility.

• A new project is initialized with a first commit; an existing repository just gets the remote.
• The new repository becomes origin and the branch is pushed.
• The dialog shows each step, closes when it's done and confirms with a notification. If the repository was created but the push failed, it says so instead of offering to create it again.

v1.9.0

v1.9.0 — Subprocesses, tabs that sleep, and a file tree that keeps up

Agents now run their dev servers, watchers and builds through Control Code, where you can see them, read their logs and stop them. Tabs you aren't looking at stop using resources. The file tree updates by itself and no longer freezes the window. Codex and Gemini get Control Code's tools too, and touch emulation in the browser finally works on Linux.

---

⚙️ Subprocesses

A new Subprocesses section in the left rail lists the long-running commands agents started: dev servers, watchers, builds.

You see	What it means
Owner	The agent that started it, in its tab's color, a fleet task, or you
CPU and memory	Its whole process tree, refreshed while the section is open
Live terminal	Its output, and you can type into it
State	Running, stopped, or exited with its code

• Stop sends Ctrl-C first and kills the whole tree if it doesn't go. Force quit kills right away. Restart runs it again with the same command.
• Start one yourself with New.
• By default the section shows the current workspace's subprocesses; Show all groups every workspace's.
• The rail button and the status bar show how many are running.

For agents: new process_* tools in Control Code's MCP, and ccode proc in the CLI.

• process_start runs a command and can wait until its output says it's ready.
• process_output returns only what's new since the agent last read, the last lines, a grep, or just the errors with context. An agent can tell how the server is doing without filling its context.
• Reading logs runs without asking; starting, typing into and stopping a subprocess asks you first.

Subprocesses end when the app closes, like terminals.

🔋 Tabs you aren't looking at stop consuming

• A hidden terminal stops drawing. It still reads its output and answers the agent, so nothing stalls; it repaints when you come back.
• After 10 minutes hidden, a terminal hibernates. Its terminal is freed from memory, the agent keeps working, and coming back rebuilds it with everything it printed. Change the time, or turn it off, in Settings → Terminal.
• A hidden browser tab stops painting and polling. The page keeps its state and doesn't reload.
• Terminal output reaches the window in fewer, larger batches. Accents, emoji and box-drawing characters no longer break when they land on a chunk boundary.
• The autosave only copies terminals that printed something new, and skips the database when nothing changed.
• Changes checks git less often while the window is in the background.

🗂️ File tree

• It updates by itself. A file an agent creates, deletes or renames shows up almost immediately. A git add or a commit updates the marks.
• It no longer freezes the window. Reading folders, git status and file operations run off the main thread, and reading the repo takes 2 git processes instead of 5.
• Coming back from Search or Changes leaves the tree as it was.
• Large folders scroll smoothly: only the visible rows are drawn.
• No more "no repo" flashes. While an agent was working, a workspace kept flipping between its branch and "no repo" for a moment. Refreshing a repo now keeps what it knew until the new answer arrives, and a slow git is no longer read as "not a repository".

📑 Tabs

• Files open in a preview tab, like VS Code. A single click in the tree, a search result, Changes or a commit opens it in an italic tab that the next file replaces in place. Double-click, or edit the file, to keep it open. Your tab bar no longer fills up with everything you glanced at.
• The mouse wheel scrolls the tab bar sideways, no Shift needed.
• The workspaces panel no longer says every tab has been open for "20712d".

🔌 Codex and Gemini get Control Code's tools

Codex and Gemini CLI tabs now receive Control Code's MCP: the project browser, subprocesses, your git account, the fleet and asking you a question. Each receives it in its own format, and your own configuration is left untouched. Kimi Code can't receive an MCP server per launch, so it keeps using the CLI.

🧩 Skills

• Install a loose .md file. create-invoice.md becomes the skill create-invoice, in its own folder; nothing next to the file is copied.
• Install a folder whose markdown isn't called SKILL.md. The folder names the skill, and its support files come with it.
• Local repositories recognise both forms.
• The Control Code skill now documents every MCP tool and every ccode command. It is linked automatically in every agent so they know how to use the app. Delete it from Skills if you don't want it.

🌐 Touch emulation

Touch mode in the browser did nothing on Linux: WebKitGTK rejects the standard way of creating a touch, so no touch event ever reached the page.

• Touches are now built the way each engine accepts them, both yours and the agents'.
• Dragging with the mouse scrolls the page or the container under it, like a finger, unless the page handles the gesture itself.
• While it's on, the cursor is a circle and dragging doesn't select text.

🔧 Fixes

• Background fleet tasks are killed when the app closes. On Linux and macOS they kept running.
• On macOS, closing a tab finishes off processes that ignore the polite signal.
• Process groups no longer collide on Linux, so every tab's processes stay contained.

v1.8.8

v1.8.8 — Copy from the terminal, PowerShell on Windows, and terminals that come back where you left them

You can copy and paste in the terminal again. On Windows, the plain terminal opens PowerShell. When you reopen the app, a terminal comes back in the folder you left it in, and agents resume their conversation instead of starting over. Files can be dropped onto an agent to ask about them. Running several Control Code windows at once no longer breaks your git account or the database.

---

📋 Copy and paste in the terminal

Action	Windows / Linux	macOS
Copy	Ctrl+C with text selected, Ctrl+Shift+C, Ctrl+Insert	⌘C
Paste	Ctrl+Shift+V, Shift+Insert	⌘V

• Ctrl+C with nothing selected still interrupts the running program, as always.
• Ctrl+V is left to the TUI, since Claude Code uses it to paste images.
• Right-click the terminal for Copy, Paste, Select all and Clear.
• Selecting text over a TUI that captures the mouse (Claude Code, OpenCode): hold Shift while dragging. On macOS, ⌥ works too.

Since 1.8.5 there was no way to copy from the terminal at all. That's fixed.

🪟 PowerShell on Windows

On Windows, the plain terminal used to run bash, which is WSL's launcher: it opened WSL if installed and failed otherwise. Now:

• It opens PowerShell 7 (pwsh) if installed, or Windows PowerShell otherwise.
• This applies to terminals you already had saved too.
• PowerShell saves your command history as you go, so it survives a restart.

🔁 Reopening the app

The plain terminal:

• It comes back in the folder you last cd'd into, not the workspace folder. On Windows, PowerShell reports its folder at every prompt. Linux and macOS ask the system.
• What was on screen before is shown again, under a "Session restored" line, so it's clear where the new shell starts.

Agents resume their conversation instead of starting over. Several bugs caused fresh sessions:

• Claude Code sometimes recorded a subagent's transcript (agent-…) as the session, and --resume couldn't find it.
• Custom TUIs started before Control Code knew how to resume them.
• If an agent got no message in its first ~26 minutes, Control Code stopped looking for its session. It now keeps looking, and makes a last attempt when the app closes.
• On Windows, Codex, Gemini, OpenCode and Kimi didn't recognize the same folder written differently (case, slashes, \\?\).

Running processes still end when the app closes, as in VS Code.

📎 Drop files onto an agent

Drag files or folders onto an agent's terminal, either from your file manager or from the file tree. The terminal is highlighted while you're over it.

• The agent gets a mention in its input, without sending it, so you can type your question: @src/app.ts, or @../lib/x.rs for files outside its folder.
• A plain terminal gets the quoted paths, like any shell.

🪟🪟 Several Control Code windows at once

• "Session expired" on your git account. GitHub replaces the refresh token each time it renews access. One instance renewing left the others holding a dead token. Now an instance checks the system keychain before renewing, and uses the token another instance already renewed.
• "Database is locked". Two instances writing at the same time made one fail. Now writes wait their turn, and two instances starting at once (for example, the one restarting after an update) no longer run the same migration twice.

v1.8.7

v1.8.7 — Opening a file works again

1.8.6 broke the file editor. Opening any file replaced the whole window with an error: "Unrecognized extension value in extension set… multiple instances of @codemirror/state are loaded". This release fixes it. If you're on 1.8.6, update now.

---

🩹 What happened

1.8.6 updated the editor's core packages (CodeMirror's state and view), but the rest of CodeMirror kept its own older copies. The editor, the diff view and the syntax highlighting are all built from pieces of CodeMirror, and those pieces only work together when they come from the same copy. With two copies in the app, the editor refused to start.

The same duplication affected more than the crash:

• Syntax highlighting (@lezer/highlight): code could appear without colors.
• Editor commands (@codemirror/commands) and editor styles (style-mod) were duplicated too.

✅ The fix

• Every CodeMirror package now shares a single copy of each of these libraries, pinned in package.json.
• A new test builds the editor with exactly the extensions the app uses. Against 1.8.6's dependencies it fails with the same error you saw; with this release it passes. If this ever happens again, the build catches it before a release.

Everything else from 1.8.6 is unchanged: every TUI in the fleet, the model search, the browser's CORS fix, and sending files to an agent.

v1.8.6

v1.8.6 — Every TUI runs in the fleet, your API stops rejecting the browser, and files go straight to an agent

The fleet is no longer Claude Code only: OpenCode, Codex, Gemini CLI and Kimi Code can run tasks too, and models are picked with a search across every TUI. The built-in browser stops triggering CORS preflights your backend never asked for. A file or folder can be handed to an agent from the file tree.

---

🚀 The fleet runs every TUI

Until now, only Claude Code could run a fleet task. Now all of them can:

TUI	Runs with	Without supervision it can
Claude Code	claude -p (as before)	Asks the fleet console before editing or running commands
OpenCode	opencode run --format json	Edit files; commands are rejected, since nobody is there to approve them
Codex	codex exec --json	Edit and run commands inside the task's folder, in Codex's workspace-write sandbox (no network)
Gemini CLI	gemini -o stream-json	Edit files; the shell is rejected
Kimi Code	kimi --prompt	Everything: Kimi's non-interactive mode only runs with automatic approval

• Tasks look the same whatever TUI runs them. Each TUI names its tools differently (write_file, run_shell_command, write…), and every one is shown as Claude Code would show it: Write(src/app.ts), Bash(cargo test).
• The run's rules and the result's format go in front of the request for the TUIs that don't take a separate system prompt. Codex, like Claude Code, enforces the result's JSON Schema itself.
• The result and the tokens are collected while the task runs, for the TUIs that don't emit a final event.
• Reopening a task as a tab resumes the right session. For TUIs that choose their own session id (OpenCode, Codex), the app stores the one they report.
• Codex, Gemini and Kimi run with the TUI's default model, since Control Code doesn't know their model lists yet.

OpenCode was checked against real runs of its CLI. Codex, Gemini and Kimi were built from their documentation and source, and haven't been run end to end yet. Tell us if one misbehaves.

🔎 Pick models with a search

With several TUIs installed there are dozens of models (OpenCode alone lists fifty). In Settings → Fleet routing, each tier's + Add opens a search across every TUI's models, grouped by TUI:

• Type any words in any order, such as sonnet, opencode sonnet or pickle. Each word can match the TUI, the model name or its id, ignoring case and accents.
• Each row shows the price per million tokens when it's known, and a local tag for models running on your machine.
• Models already in the tier aren't offered again. Arrow keys move through the list, Enter adds, and Escape closes.

New task → Fixed model uses the same search. Picking a row sets the TUI and the model at once.

🌐 The browser stops tripping your CORS

With its cache disabled, the webview engine adds Cache-Control: no-cache and Pragma: no-cache to requests on its own. The proxy counted them as headers the page had set. So it sent a preflight declaring them, and a backend with strict CORS rejected it, which failed every authenticated request to your API.

A real browser adds those headers in its network layer, after the CORS check, so they never trigger a preflight. Now the embedded browser behaves the same:

• The page tells the proxy which headers it actually set, for fetch and XHR alike, and only those count for CORS.
• The engine's own headers still reach your server, just like in Chrome.
• A Cache-Control your page sets on purpose still has to be allowed by your server's preflight.

If you allowed Cache-Control and Pragma in your backend's CORS just for Control Code, you can remove them.

📁 Send a file to an agent

Right-click a file or folder in the tree → Send to an agent…:

• A list of the project's agents opens, each with a dot in its color. While the list is open, each agent's tab turns its color, so you can tell which is which.
• Picking one types @path (relative to that agent's folder) into its input without sending it, and focuses its tab so you can write the question.
• Paths with spaces are quoted, and files outside the agent's folder use the absolute path.

✨ Smaller things

• Buttons and form fields now come from Control Code's UI library, for consistent focus rings, hover and disabled states across the app. In-place editors (renaming a tab or a file, the URL bar, compact search boxes) stay as they were.
• Everything clickable that stayed native shows a pointer cursor.
• Updated dependencies: Tauri 2.12, CodeMirror, and the UI library.

v1.8.5

v1.8.5 — A real file explorer, issues you can hand to an agent, and branches you can publish

The file tree finally does what a file tree does: right-click to create, rename, copy, paste and delete, and drag files between folders. A pull request or issue can go straight to an agent with its whole thread as context, and its screenshots now show up. A branch created from a remote one can be published, and every agent tab tells you which account it runs on.

---

📁 The file tree, like VS Code's

Right-click a file or folder:

• New file and New folder;
• Reveal in file manager;
• Cut, Copy and Paste;
• Copy path and Copy relative path;
• Rename and Delete.

Right-clicking the empty space offers the same on the project root, and the tree's header has New file, New folder and a ⋯ menu.

• Renaming and creating happen in place, on the row itself. Renaming selects the name without its extension, and a new file opens as a tab.
• Delete asks first and moves the item to the system trash, so you can restore it. This works on Windows, macOS and Linux.
• Nothing is overwritten. Pasting onto a name that's taken creates name copy, name copy 2… Moving or renaming onto an existing name fails instead of replacing it.
• Drag files and folders from one folder to another. Hold Ctrl (Alt on macOS) to copy instead of move. Hovering over a closed folder while dragging opens it.
• Shortcuts: F2, Delete, Ctrl+C / X / V, and Shift+Alt+C to copy the path.
• Open tabs follow their files. Moving or renaming a file keeps its tab, unsaved changes included. Deleting it closes the tab, unless it has unsaved changes.

🤖 Send a pull request or issue to an agent

A pull request or issue has a new Send to an agent button:

• An agent already open in that repository: the message is typed into its terminal, and you're taken to its tab.
• A new agent: the usual wizard opens. The message is sent once the agent's TUI has finished starting. For a pull request whose branch is already open in a worktree, the agent opens there.

The message carries the whole item: title, link, state, labels, branches, description and comments. It also says what to do: resolve the issue, or get the pull request ready to merge. It asks the agent not to push, comment or open pull requests unless you ask.

🖼️ Images in pull requests, issues and releases

A screenshot dragged into a GitHub issue is written as an HTML <img> tag. The app doesn't render raw HTML, so you saw the tag as text. Now those images are shown. They are downloaded by the app with your git account's token, so attachments from private repositories work too. The token is only ever sent to your forge's own hosts.

🗂️ Duplicate a tab

Right-click an agent tab:

• Duplicate opens another tab with the same agent, account, pre-launch commands and skills.
• Duplicate with another agent… opens the wizard with that tab's skills already ticked. Only the ones the new agent supports are kept.

The duplicate starts a new conversation. To continue the same one, use Sessions.

🌿 Publishing a branch

A branch created from a remote one (git switch -c feature origin/main) ends up tracking origin/main. Git then refuses to push it, because the names don't match, and Source Control treated it as already published. There was no way to get it up.

• A branch now counts as published only when it tracks a remote branch with the same name. Otherwise, pushing publishes it under its own name and makes that its upstream. This uses your git account's token, and agents' git_push goes the same way.
• With nothing to commit, the big button stops saying Commit and says Publish branch or Push N commits, as in VS Code.

✨ Smaller things

• Each agent tab shows its account in small text under the title. With several accounts of the same TUI open, it's what tells two tabs apart.
• The account popover shows only the plan's quota. The token counts and the window estimated from the first message were usage, not quota, and read as if they were.
• No more browser menu on right-click (Back, Reload, Inspect). It remains in text fields, where it offers cut, copy and paste.
• Diffs look like VS Code's: a changed line has a transparent green or red background, and what changed inside it is slightly stronger, instead of a line under the code.
• The start page loses the Home button, which only picked your home folder.