Extension Details

Air Traffic Control (ATC) runs and coordinates coding agents from Nova. Give a task to Claude Code, Codex, Cursor, Antigravity, OpenCode, Pi, JetBrains Junie, or Grok. Each task is a flight, and every flight gets its own Git worktree, so several agents can work at the same time without touching your checkout. You follow each one in a live transcript, review its diff, and merge or discard the result.

Beyond running agents side by side, ATC can:

• Prepare every new worktree with your setup command (npm ci) and untracked files such as .env, and start flights from another branch or from your uncommitted changes.
• Steer an agent mid-turn with new instructions, reuse recent prompts, and fix failing tests in your checkout with one command.
• Fan out one prompt over several files, or over the TODO(atc) comments in your code, one flight each, and merge them all at once.
• Raise a traffic alert when open flights would conflict with each other or with your checkout.
• Fly a Flight Plan in legs, one after another in the same agent session, and have a flight wait until others are merged.
• Comment on a flight's diff right in the diff, and send the comments back to the agent like a pull-request review.
• Race several agents on one prompt, or several sessions of one agent (best of N), compare their results in a table, let another agent judge them, and merge the winner.
• Undo a flight's last turn from automatic per-turn checkpoints.
• Approve a Plan-mode flight's plan to have the same agent session build it.
• Start a flight from a GitHub issue, and have its pull request close the issue.
• Hand off a flight to a different agent, either for a read-only second opinion on its diff or to continue in the same worktree.
• Follow up in the same agent session, because every agent's own session is resumed.
• Queue flights, with a holding pattern once a set number are in the air.
• Track tokens and cost per turn and per flight, cap a turn's time or cost, and send a notification when a flight lands.
• Verify a flight with your project's test command, hand failures back to the agent, or let ATC do that until the tests pass.
• Fall back to another agent when a flight fails outright, hold flights at a daily budget, and search every flight's transcript.
• Take or revert single files, sync a flight with your checkout, or push it and open a pull request.
• Get an automatic second opinion from another agent whenever a flight lands.

Requirements

• Nova 11 or newer, and Git.
• At least one agent CLI, installed and signed in:

Agent	Executable	Install / sign in
Claude Code	claude	claude then /login
Codex	codex	codex login
Cursor	cursor-agent	cursor-agent login
Antigravity	agy	sign in to Antigravity
OpenCode	opencode	opencode auth login
Pi	pi	pi, then /login
JetBrains Junie	junie	Junie CLI, authenticated (e.g. --auth in Extra Arguments)
Grok	grok	Grok Build CLI (~/.grok/bin), signed in or with XAI_API_KEY

ATC finds executables on your login shell's PATH, plus ~/.local/bin, /opt/homebrew/bin, ~/.bun/bin, ~/.grok/bin, npm's global bin, and a few other common locations. Set an explicit path in settings if yours lives elsewhere.

Getting Started

1. Open the Air Traffic Control sidebar. Hangar lists each agent with its version, or "Not installed".
2. Click + in Flights (or double-click an agent in the Hangar) to open the Flight Plan.
3. Write your prompt below the front matter and press ⌘⇧↩ (Editor → Take Off).

The transcript opens and fills in as the agent works. When the flight lands, expand it in the sidebar to see the changed files, then right-click it to Merge…, Discard…, Follow Up…, or Hand Off….

The Flight Plan

---
agent: claude
mode: edit
model:
isolation: worktree
race:
---
Add input validation to the signup form and cover it with tests.

Field	Values
agent	claude, codex, cursor, antigravity, opencode, pi, junie, grok
mode	plan, ask, edit, auto (see below)
model	Passed to the agent's model flag. Leave blank for the agent's Default Model setting, or the agent's own default.
isolation	worktree (default) or in-place
race	More agents, comma-separated. Each one flies the same prompt in its own worktree. claude×3 (or claude*3) means three Claude Code sessions in all (see Best of N).
fanOut	Files or globs, comma-separated. One flight per item, each in its own worktree (see Fan Out).
base	A branch, tag, or commit to start the worktree from, instead of your checkout's HEAD (see Where a Flight Starts).
carry	uncommitted: start the worktree from your checkout's uncommitted changes, untracked files included.
after	Flight ids, comma-separated. The flight waits until they're merged, then takes off from the new HEAD (see Flights That Wait).
followUp	A flight id. Sends the prompt as the next turn of that flight.
issue	A GitHub issue number. The branch is named after it and the pull request closes it. Filled in by Fly GitHub Issue….
title	Optional. Defaults to the prompt's first line.

A line --- leg --- in the prompt splits it into legs (see Multi-leg Flight Plans).

After take-off the Flight Plan keeps its settings and clears the prompt (and base, carry, after, fanOut, followUp, issue, and title, which are for one flight). Fly Selection… (Editor menu) and Insert Prompt Template… pre-fill it with the selected code and its file and line references. Quick Flight… asks for a one-line prompt and uses your defaults. Recent Prompts… lists the prompts you've written in this project, newest first, follow-ups and legs included, and opens the one you pick in the Flight Plan with its flight's agent, mode, and model.

Fly GitHub Issue… (Extensions menu, or the issue button in Flights) lists the repository's open issues with the GitHub CLI and fills the Flight Plan with the chosen issue's title, link, description, and latest comments. The issue's text comes from whoever wrote it, so read it before you take off, especially in Full Auto. The flight is titled #N <issue title>, its branch is atc/issue-N-…, and Push & Open Pull Request… adds Closes #N to the pull request.

Your own templates are Markdown files in the templates folder (Open Templates Folder creates it with an example). The file name is the template's name, the front matter takes the Flight Plan's agent, mode, model, isolation, and race, and {selection} in the body becomes the selected code. A template with a built-in's name replaces it.

Modes

Agents run headless, so they can't stop and ask for permission mid-run. The mode decides up front what each agent may do:

Mode	Claude Code	Codex	Cursor	Antigravity	OpenCode	Pi	Junie / Grok
Plan	--permission-mode plan	read-only sandbox + plan instruction	--mode plan	--mode plan	--agent plan	read-only tools + plan instruction	Grok: --permission-mode plan; Junie: not available
Ask	--permission-mode default (no prompts → no edits)	read-only sandbox	--mode ask	--mode plan	--agent plan	read-only tools	Grok: --permission-mode default (no prompts → no edits); Junie: not available
Edit	--permission-mode acceptEdits	workspace-write sandbox	default	--mode accept-edits	default	all tools	Grok: --permission-mode acceptEdits
Full Auto	--dangerously-skip-permissions	--dangerously-bypass-approvals-and-sandbox	--force	--dangerously-skip-permissions	--auto	all tools	Grok: --always-approve

Approving a plan

When a flight lands in Plan mode, right-click it (or use the landing notification) and choose Approve Plan…. Pick Edit or Full Auto, and optionally describe changes to the plan. ATC switches the flight to that mode and resumes the same agent session with "Your plan is approved. Implement it now", so the agent builds the plan it just wrote.

Full Auto lets the agent run any command without asking. Use it in worktrees you're willing to throw away. Pi has no permission system, so in Edit and Full Auto modes it can always run commands. Junie has no documented read-only switch, so ATC refuses Plan and Ask for Junie, including Junie as a Second Opinion reviewer, rather than relying on prompt wording. Change Mode… switches mode for the next turn of a flight.

Worktrees, Review, and Merge

A worktree flight runs on a new branch, atc/<slug>, created from your current HEAD. Its worktree lives in ATC's storage folder (Show Storage Folder), not in your project. Uncommitted changes in your checkout aren't copied into it. If the project folder is a subfolder of the repository, the agent starts in the same subfolder of the worktree.

• Changes under a flight compare the worktree against the commit it started from. Untracked files are included, and the worktree's staging area isn't touched. Double-click a file to see its diff, use Open File to open the worktree copy, or click All Changes for the full patch.
• Merge… commits everything in the worktree, then runs git merge --squash into your checkout. Merge & Commit commits the result. Merge as Staged Changes leaves it staged for you to commit. Merge Keeping Turns makes one commit per agent turn instead (see below). Merging also removes the worktree and its branch. If Git refuses because local changes would be overwritten, you see Git's message and nothing is changed.
• Discard… stops the flight, deletes its worktree, and deletes the branch, unless you choose Discard but Keep Branch.

ATC never runs your repository's Git hooks for the commits, merges, pushes, worktrees and ref updates it makes. The hooks folder is shared with every flight's worktree, so an agent could have planted one there. Merge & Commit doesn't run pre-commit, for example. To have your hooks check a merge, choose Merge as Staged Changes and commit yourself.

The worktrees share your repository's Git config too, and Git config can name programs that Git runs: filters and merge drivers (which .gitattributes picks), credential helpers, core.sshCommand, signing programs, includes of other config files, and remotes on this Mac (a local remote's hooks run when ATC pushes to it; https, ssh and git@host: remotes don't count). ATC can't turn those off, because filters like git-crypt and Git LFS are needed for correct commits. So the first time ATC sees a repository it remembers those settings, from the repository's own config (.git/config and anything it includes). Afterwards it won't run Git or gh there while the repository's config has a new one. It names the setting instead. If you added it yourself, choose Trust Git Config…. It trusts exactly the settings it lists; if you didn't, an agent did: remove it with git config --unset. Settings in your global ~/.gitconfig and the system config are always trusted, and ATC's own diffs never run external diff programs or textconv.

Worktree Setup

A new worktree has your tracked files and nothing else: no node_modules, no .env. Set Worktree Setup… stores, for this project:

• a command to run in every new flight worktree before the agent starts, such as npm ci or bundle install. It runs in the flight's folder through your login shell (15-minute limit), with ATC_FLIGHT_ID and ATC_CHECKOUT (your project folder) in its environment;
• files to copy from your checkout, comma-separated paths or globs relative to the repository, such as .env, config/*.local.json. Only untracked files are copied, ignored ones included, up to 2,000. Tracked files are already in the worktree.

Like the verify command, it's kept in ATC's storage on this Mac, never in the project's .nova settings. The transcript shows ✓ Setup with what was copied, and the sidebar shows Holding · worktree setup while it runs. If the command fails, the flight fails without starting the agent, and the transcript has the output; fix the setup and Re-fly…. Hand-offs share their parent's worktree, so they don't run setup again, and in-place flights never do. Files the command creates count as the flight's changes unless Git ignores them, so keep its output (node_modules, build folders) in .gitignore. Files the new worktree tracks (from base:, say) aren't overwritten, and nothing is copied through a tracked symlink; the transcript lists what was skipped.

Where a Flight Starts

A worktree normally starts from your checkout's HEAD. Two Flight Plan fields change that, one at a time:

• base: <branch, tag, or commit> starts the worktree there, for example base: release/2.1 or base: origin/main. The flight's changes are compared against it, and Push & Open Pull Request… targets that branch when base names one (origin/x targets x). Merging squashes the flight's branch into your checkout, so if the base has commits your HEAD doesn't, they come along too. A waiting flight resolves its base when it takes off.
• carry: uncommitted starts the worktree from your uncommitted changes, staged or not, untracked files included, so the agent sees exactly what you see. ATC snapshots them as a commit made in its own index, so your staging area and files aren't touched. Because those changes are still in your working tree, such a flight merges only as Merge as Unstaged Changes: just the agent's own changes are applied on top of yours. It can't be synced, merged keeping turns, or pushed (pushing would publish your uncommitted work). Re-fly… carries your changes as they are then. A flight that waits (after:) can't carry.

Both imply isolation: worktree, and a race or fan-out starts every flight from the same commit.

Per file, from a changed file's context menu:

• Take This File applies just that file's change to your checkout, unstaged. If your copy of the file differs from the flight's starting commit, Git refuses and nothing changes. Binary files can't be taken this way; use Open File.
• Revert in Worktree… undoes the agent's change to that file in the flight's worktree (an added file is deleted, a renamed one restored).

Checkpoints and Undo

Before every Edit or Full Auto turn in a worktree, ATC records the worktree as a checkpoint: a commit kept under refs/atc/… in your repository, made in a separate index, so the worktree's branch, staging area, and files aren't touched. Plan and Ask turns aren't checkpointed, and neither are in-place flights.

• Undo Last Turn… puts the worktree back to how it was before the flight's last editing turn. Run it again to undo the turn before that. The agent's session still remembers the undone turn, so the next follow-up starts with a note that it was undone. When flights share a worktree, only the most recent turn in it can be undone.
• Show Turn Changes… shows what one turn changed, from its checkpoint to the next turn's (or to the worktree now).
• Sync with Checkout clears the checkpoints, because undoing past a sync would drop the merged HEAD. Merging or discarding the flight deletes its checkpoint refs.

Review Comments

Every diff ATC opens (Show All Changes, a file's diff, Show Turn Changes…) can take review comments. Write them in the diff on lines starting with >>, below the line they're about:

+function save(user) {
>> validate the email before saving
+  db.put(user);

Then choose Editor → Send Review Comments. ATC sends them to the flight's agent as one follow-up, each with its file, line number, and code (src/user.js:12). A comment above a file's first hunk is about the whole file, and one above the first file is general. Several >> lines in a row are one comment. In Plan or Ask mode, ATC asks whether to switch the flight to Edit first.

Merge Keeping Turns

Merge Keeping Turns turns the flight into one commit per editing turn, built from its checkpoints, so git log shows what each turn did: Claude Code: Add input validation, then Codex: Fix the failing test after a hand-off, and so on. Each commit names its flight and turn. Turns that changed nothing, or were undone, get no commit, and work from before a sync, or from before the first checkpoint, becomes an "earlier changes" commit. If your checkout's HEAD is still where the flight started, the commits are fast-forwarded onto it. Otherwise they come in through a merge commit. On a conflict the merge is aborted and nothing changes. Flights without checkpoints (in place, or before ATC 1.2) are merged as a single commit.

Sync with Checkout merges your checkout's current HEAD into the flight's branch, so a flight started before main moved on merges cleanly, and its changes are compared against the new HEAD from then on. ATC commits the worktree first. If the merge conflicts you can Abort Sync, or Let the agent Resolve: the conflict markers stay and the agent gets a follow-up listing the conflicted files.

Push & Open Pull Request… commits the worktree, runs git push -u origin atc/<slug>, then gh pr create against your checkout's current branch, with the agent's summary as the body. You confirm first. Without the GitHub CLI (or for a non-GitHub remote) the branch is still pushed and ATC tells you why no PR was opened. Pushing again updates the same PR. The flight stays open, so you can still merge, or Discard but Keep Branch once the PR is up.

Open Worktree In… opens a flight's folder in Terminal (or the app in Terminal App), Finder, or a new Nova window.

An in-place flight runs in your project folder. Its changes are in your working tree and you review them with your usual Git tools. ATC still lists them, compared against the commit the flight started from, but can't merge or discard them.

Verify

Set Verify Command… stores a shell command for this project, such as npm test or make check. It's kept in ATC's storage on this Mac, not in the project's .nova settings, so a cloned project can't choose it. Verify runs it in the flight's folder through your login shell (15-minute limit), appends the result and the last 40 lines of output to the transcript, and shows ✓ verified or ✗ verify in the sidebar. When it fails you can Ask the agent to Fix, which sends the output as a follow-up.

Fix Failing Tests… runs the verify command in your checkout instead. If it fails, the Flight Plan opens with the command's output and a request to fix it, ready for you to read and take off, in a worktree that carries your uncommitted changes when you have any (carry: uncommitted), so the agent starts from the code that failed.

With Verify After Landing on, ATC runs it whenever a flight lands with changes in Edit or Full Auto mode. A sharer still flying in the same worktree has to land first.

Fix until green. With Automatic Fix Attempts also set (1–5), a failed verify after landing goes straight back to the agent as a follow-up, and ATC verifies again when it lands, until the command passes or the attempts run out. The transcript then says ATC gave up. A follow-up of your own starts the count over, and second opinions wait until the flight passes or ATC gives up.

Races

Set race: in the Flight Plan, or use New Race…. Each racer gets its own worktree and uses its own default model. When they land, Compare Race… does three things:

• writes a report with each agent's status, files, +/−, tokens, cost, and time, plus their final messages;
• opens each racer's diff;
• asks you to pick a winner.

The winner is merged, and ATC offers to discard the others.

Best of N

A race doesn't need different agents. race: claude×3 (with agent: claude), or listing the same agent more than once, flies several independent sessions of one agent, up to 8 racers in all. Listing the flight's own agent once is the flight itself, as before: agent: claude with race: claude, codex is a two-way race. Sessions of one agent keep the Flight Plan's model; a race of different agents uses each one's default. The report, the winner list, and the judge number them Claude Code #1, #2, and so on.

Race Judge. At the end of the winner list, ⚖︎ Ask an Agent to Judge… sends the task, each racer's summary, and its diff (60,000 characters in total) to an agent you choose. The judge runs in Ask mode in your project folder, compares correctness, completeness, tests, and fit, and names a winner. When it lands, Compare Race puts the judge's pick first, marks it ⚖︎ pick in the report, and adds the judge's reasoning. With Automatic Race Judge set, ATC asks that agent as soon as every racer has landed, if at least two changed something. Junie can't judge, because it can't be held to read-only.

Fan Out

New Fan-Out… (or fanOut: in the Flight Plan) flies the same prompt once per item, each in its own worktree, with {item} in the prompt replaced by the item:

---
agent: claude
mode: edit
fanOut: src/models/*.js, src/api.js
---
Add unit tests for {item}, following the existing tests' style.

Items with *, ? or [ are Git pathspecs, expanded to the tracked files they match in the project. Anything else is used as written, so items don't have to be files. A prompt without {item} gets Target: <item> appended. A fan-out can have up to 20 flights, which queue under Maximum Flights in the Air, and can't also race. Each flight is titled <prompt> — <item>.

Merge Fan-Out… merges every flight of the group that landed with changes, one after another, each committed or all left staged. It stops at the first flight Git refuses and tells you which one, and you can merge the rest yourself.

Fly TODOs

Write TODO(atc) comments where you want an agent to work:

// TODO(atc): validate the email before saving

Fly TODOs… finds them in the project's tracked files (git grep) and lists them. Choose All … TODOs to fill the Flight Plan with a fan-out, one flight per comment (fanOut: src/user.js:12, …), or choose one TODO for a single flight. Each agent is asked to do what its comment says and remove the comment. Up to 20 TODOs fan out at once, and paths with commas or glob characters can only be flown one at a time. The comments come from the repository, so read them before you take off, especially in Full Auto.

Multi-leg Flight Plans

Split a Flight Plan into legs with lines that read --- leg ---:

---
agent: claude
mode: edit
---
Add a `slugify` helper to src/text.js.
--- leg ---
Use it in every place that builds URLs by hand.
--- leg ---
Write tests for the helper and its callers.

The first leg takes off as usual. When it lands, the next leg goes to the same agent session as a follow-up, and so on. With Verify After Landing on, each leg has to pass first, and with Automatic Fix Attempts the agent fixes a failing leg before it gets the next one. The transcript marks each turn Leg 2 of 3, and the sidebar shows the current leg. If a leg fails or is stopped, or Verify still fails, the remaining legs are dropped and listed in the transcript so you can send them yourself. An automatic second opinion or race judge waits for the last leg. Races and fan-outs fly every leg for each flight ({item} works in every leg), and Re-fly… flies all the legs again.

Flights That Wait

after: in the Flight Plan, or Fly After… on a flight, makes a flight that waits for others:

---
agent: codex
after: k3x9a2b
---
Now add the settings screen for the API you just built.

The flight shows as Waiting · after “…” is merged and has no worktree yet. Once every flight it names is merged (or, for in-place flights, has landed), it takes off by itself, with a worktree made from your checkout's HEAD as it is then, so it builds on their work. If one of them is discarded or removed, it keeps waiting and says why. Fly Now releases it at once, and Stop cancels it (you can still Re-fly… it). Waiting flights stay waiting when you quit Nova.

Traffic Alert

Flights in separate worktrees can still collide when they merge. Whenever a worktree flight lands with changes, ATC checks every open worktree flight, with up to 12 at a time. It snapshots each worktree, uncommitted work included, without changing it. Then git merge-tree (Git 2.38 or newer) works out whether each flight would merge cleanly into your checkout's HEAD and into each of the others.

• A flight that would conflict shows ⚠ conflicts in the sidebar. Its tooltip names the files and the other flight, or your checkout, and so does a ⚠ Traffic note in its transcript and the landing notification.
• While flights fly, any that touch the same files show ⚠ overlaps N. That can still merge cleanly. It's a hint, not a conflict.
• After a merge your HEAD has moved, so ATC checks the remaining flights again.
• Check Traffic (Extensions menu, the warning sign in Flights, or a flight's context menu) checks now and opens a report.

To clear a conflict with your checkout, use Sync with Checkout on the flight and let the agent resolve it. For two flights that conflict with each other, merge one, then sync the other.

Hand Off

Hand Off… passes a flight to any agent, including another session of the same one:

• Second Opinion sends the original task, the agent's summary, and the full diff (up to 60,000 characters) to the reviewer in Ask mode, in the same worktree. Add an optional focus such as "check error handling".
• Continue has the new agent pick up in the same worktree, with the task, the summary so far, and the changed files, plus your instructions for what to do next.

Flights that share a worktree fly one at a time. Merging or discarding any of them acts on the whole worktree.

Automatic Second Opinion picks an agent that reviews every flight once, the first time it lands with changes in Edit or Full Auto mode, exactly like a manual Second Opinion. Reviews, race flights, and flights already reviewed aren't reviewed again. Junie can't be a reviewer because it can't be held to read-only.

Re-fly, Rename, and the Flight Log

• Re-fly… flies a finished flight's original prompt again, with the same agent or another one, in a new worktree (or in place, if the original was). Hand-offs can't be re-flown; re-fly the flight they came from.
• Rename… changes a flight's title. Its branch keeps its name.
• Flight Log writes a report of every flight in the list: per agent, how many landed, failed, were stopped, merged or discarded, plus turns, tokens, cost and time, and the 20 most recent flights. Removed flights aren't counted.

Fallback Agent

Set Fallback Agent and a flight whose first turn fails (the agent crashed, isn't signed in, hit a usage limit, or isn't installed) is flown again, once, with that agent, using the same prompt and mode. The failed flight's transcript names the new flight. If the failed flight changed nothing, its worktree is discarded. Races, hand-offs, judges, and fallback flights don't fall back, and an agent that can't enforce the flight's mode (Junie in Plan or Ask) isn't used.

Daily Budget

Daily Budget caps what agents spend per day, across all your projects, in USD. ATC adds up the cost agents report as they work, in a file in its global storage. Once today's spend reaches the budget, new turns wait as Holding · daily budget until midnight, or until you raise or clear the budget. A turn that goes over it is stopped, and the transcript says why. The Flight Log shows today's spend. Only agents that report cost count toward it.

Search Flights

Search Flights… (Extensions menu, or the magnifying glass in Flights) finds text in every flight's transcript, title, prompts, and last reply, and opens the chosen transcript at the first match.

Steer

Steer… (a flying flight's context menu, or the Extensions menu) stops the agent's current turn and sends your new instructions at once, in the same session, so the agent knows what it was doing and where you want it to go instead. The transcript marks the turn ↪ Steered. A multi-leg flight keeps its remaining legs, which fly after the steered turn. If the agent hadn't reported a session yet, ATC restates the original task along with your instructions.

Follow-ups and Sessions

Follow Up… (or followUp: in the Flight Plan) resumes the agent's own session: Claude --resume, Codex exec resume, Cursor --resume, Antigravity --conversation, OpenCode -s, Pi --session-id, Junie --session-id, Grok -r. If an agent never reported a session id, its last reply is quoted into the follow-up instead.

Flights and transcripts persist per project. Agents don't survive quitting Nova, so flights that were running when Nova quit show as Stopped, and you can follow up on them.

Settings

Extensions → Extension Library → Air Traffic Control → Settings

• Default Agent, Default Mode, and Isolation set the Flight Plan defaults. Default Agent and Isolation can be overridden per project, but Default Mode can't, so a project can never preselect Full Auto.
• Maximum Flights in the Air (default 4). Later flights wait as Holding.
• Notify When Flights Land, and Open Transcript on Take Off.
• Verify After Landing, Automatic Fix Attempts, Automatic Second Opinion, Automatic Race Judge, Fallback Agent, Maximum Turn Duration (minutes), Maximum Turn Cost (USD), and Daily Budget (USD), where 0 means no limit. A turn over a limit is stopped, the transcript says which limit, and you can still follow up. Only agents that report cost can be held to a cost limit, and cost often arrives at the end of a turn.
• Terminal App for Open Worktree In…, and Templates Folder for your own templates.
• For each agent: Show in Hangar, Executable, Extra Arguments, and Default Model. Extra arguments are inserted before the prompt on every run, e.g. --add-dir or --effort. The default model is used whenever a flight's model is blank: new flights, racers, hand-offs, judges, and fallbacks, so you can make a cheap model the default for reviews, say.

Under Project → Project Settings → Air Traffic Control, Standing Instructions (which come from the project, like its CLAUDE.md, so read them in a project you didn't write) are appended to the first prompt of every flight in that project. Agents also read their own instruction files, such as CLAUDE.md and AGENTS.md.

Executable paths, extra arguments, default models, the default mode, the review, judge, fallback, fix, limit and budget settings, and the templates folder are global-only on purpose, and the verify and setup commands live in ATC's storage. Project settings live in the repository's .nova folder, and a cloned project shouldn't be able to choose what ATC runs.

Commands

Extensions menu: New Flight…, Quick Flight…, Fly GitHub Issue…, New Race…, New Fan-Out…, Fly TODOs…, Fix Failing Tests…, Recent Prompts…, Fly After…, Follow Up…, Steer…, Approve Plan…, Hand Off…, Re-fly…, Rename Flight…, Compare Race…, Show Changes…, Show Turn Changes…, Undo Last Turn…, Verify Flight…, Sync with Checkout…, Merge Flight…, Merge Fan-Out…, Check Traffic, Push & Open Pull Request…, Discard Flight…, Open Worktree In…, Stop All Flights, Clear Finished Flights, Search Flights…, Flight Log, Refresh Agents, Set Verify Command…, Set Worktree Setup…, Trust Git Config…, Open Templates Folder, Show Storage Folder.

Editor menu: Take Off (⌘⇧↩), Fly Selection…, Insert Prompt Template…, Send Review Comments.

Sidebar context menus: Open Transcript, Fly Now, Steer…, Show All Changes, Show Turn Changes…, Undo Last Turn…, Follow Up…, Approve Plan…, Follow Up in Composer, Change Mode…, Hand Off…, Re-fly…, Fly After…, Compare Race…, Verify, Check Traffic, Sync with Checkout, Merge…, Merge Fan-Out…, Discard…, Push & Open Pull Request…, Open Worktree In…, Refresh Changes, Rename…, Stop, Remove from List; for files, Open File, Show Diff, Take This File, and Revert in Worktree…; for agents, New Flight and Agent Info (which shows the exact command ATC runs).

Troubleshooting

• "isn't installed or isn't on PATH": set the agent's Executable in settings, then click Refresh in the Hangar.
• The flight fails right away: the transcript shows the agent's own error, such as Codex 401 Unauthorized, Pi "No API key found", or Cursor's usage limit. Sign in to that agent in Terminal and try again.
• Merge fails: commit or stash the overlapping local changes in your checkout, then merge again. The flight's branch is untouched until a merge succeeds. If main has moved on and the flight conflicts with it, Sync with Checkout first.
• Push works but no pull request opens, or Fly GitHub Issue… fails: install the GitHub CLI and run gh auth login. The message shows what gh reported.
• A flight stays Waiting: it waits for the flights in its after: to be merged. Its tooltip names them. Merge them, or use Fly Now.
• "Air Traffic Control won't run Git here": the repository's Git config gained a setting that runs a program (named in the message) after ATC first saw the repository, such as a remote that's a folder on this Mac. If you added it, choose Trust Git Config…. Otherwise remove it with git config --unset <name>.
• No traffic alerts: they need Git 2.38 or newer (git --version), and only worktree flights with changes are checked.
• A flight stays Holding: it waits for Maximum Flights in the Air, for a sharer in the same worktree, or (shown as daily budget) for tomorrow or a higher Daily Budget.
• A flight fails before the agent starts, with "✗ Setup failed": the Worktree Setup command failed in its new worktree. The transcript shows its output. Change it with Set Worktree Setup…, then Re-fly….
• "Git couldn't apply the flight's changes to your working tree" when merging a flight that carried your uncommitted changes: you changed the same lines since it took off. Use Take This File for the rest, or copy from Open File.
• Undo Last Turn says there's no checkpoint: the flight was synced since that turn, or the turn flew before ATC 1.2.
• Nova's Extension Console logs the exact command line of every turn.

Support

If ATC saves you time, you can support its development:

• Liberapay
• Ko-fi
• IssueHunt

Version 1.5.1

• Security: Worktree Setup no longer copies a file onto a path the new worktree tracks, or through a tracked symlink on the way to it. A worktree started from base: has that ref's files, and a symlink there could have led the copy out of the worktree. The transcript lists skipped files.
• Fixed: a flight that started from your uncommitted changes couldn't be merged when the agent changed a binary file.
• Fixed: a Steer or Follow Up sent while the turn was wrapping up, and queued behind other flights, could still get a "landed" notification, a review, or a judge for the stopped turn.
• Fixed: Fix Failing Tests left its "Running…" notification up when the command couldn't run.

Version 1.5

• Worktree Setup: Set Worktree Setup… stores a command (such as npm ci) that runs in every new flight worktree before the agent starts, and untracked files (such as .env) to copy in from your checkout. It's kept on this Mac, not in the project. A failing setup fails the flight before the agent runs, with the output in the transcript.
• Where a flight starts: base: in the Flight Plan starts the worktree from another branch, tag, or commit, and its pull request targets that branch. carry: uncommitted starts it from your uncommitted changes, untracked files included, without touching your staging area, and merges just the agent's changes on top of yours, unstaged.
• Best of N: race: claude×3 (or the same agent listed more than once) races several sessions of one agent, numbered #1, #2… in the report, the winner list, and for the judge. Sessions of one agent keep the Flight Plan's model. Races have up to 8 racers.
• Default Model per agent, used whenever a flight's model is blank, including racers, hand-offs, judges, and fallbacks.
• Steer… stops a flying turn and sends new instructions in the same session right away. A multi-leg flight keeps its remaining legs.
• Recent Prompts… reopens a prompt you wrote before (follow-ups and legs included) in the Flight Plan.
• Fix Failing Tests… runs the verify command in your checkout and, if it fails, opens a Flight Plan with the output, carrying your uncommitted changes when there are any.
• Fixed: discarding a flight while ATC was checking traffic made that check fail for every other flight.

Version 1.4.2

• Security: the Git config check from 1.4.1 covers more settings: remotes on this Mac (their hooks run when ATC pushes), included config files, every gpg setting, diff drivers, editors and pagers, submodule update commands and trailer commands. Remotes at https, ssh and git@host: URLs don't need trusting.
• Security: Trust Git Config… trusts exactly the settings it showed, and names each repository. ATC refuses to run Git where it can't find the repository to check, or when its record of trusted config is damaged, instead of trusting again. Each repository has one record however its path is spelled (symlinks, subfolders), and records from 1.4.1 carry over. The dialog shows each setting whole, with anything outside plain ASCII escaped so a value can't fake extra lines, and trusts only the settings it shows (20 at a time).

Version 1.4.1

• Security: every flight's worktree shares your repository's Git config, and Git config can name programs that Git runs: filters, merge drivers, credential helpers, core.sshCommand and signing programs. An agent could add one for ATC to run outside the agent's sandbox. ATC now remembers those settings the first time it sees a repository, and won't run Git or gh there while the repository's own config has new ones. It names them instead. Trust Git Config… accepts the ones you added. Your global and system Git config are always trusted, so Git LFS and git-crypt keep working.
• Security: ATC's diffs no longer run external diff programs or textconv drivers.

Version 1.4

• Traffic Alert: when a worktree flight lands, ATC checks every open flight against your checkout's HEAD and against the others with git merge-tree, uncommitted work included, without touching any worktree. Conflicting flights show ⚠ conflicts in the sidebar, the landing notification and transcript say with what, and flights changing the same files show ⚠ overlaps while they fly. After a merge, the rest are checked again. Check Traffic writes a report.
• Multi-leg Flight Plans: split a Flight Plan's prompt with --- leg --- lines. Each leg is sent as a follow-up in the same agent session once the one before lands (and passes Verify, when that's on). A failed or stopped leg, or a failing verify, drops the rest and lists them in the transcript.
• Flight Dependencies: after: in the Flight Plan, or Fly After…, holds a flight as Waiting until the flights it names are merged. Its worktree is then made from the new HEAD. Fly Now releases it early. Waiting flights survive restarting Nova.
• Fly TODOs… finds TODO(atc) comments in the project's tracked files and fans out one flight per comment, or flies one.
• Security: no Git command ATC runs, in a worktree or in your checkout, runs repository hooks any more. That covers merges, commits, pushes, new worktrees and ref updates. An agent could have planted hooks in the hooks folder your checkout shares with its worktree. To have your own hooks run on a merge, use Merge as Staged Changes and commit yourself.

Version 1.3

• Review Comments: write comments in any flight diff on lines starting with >>, then Send Review Comments (Editor menu). The agent gets them as one follow-up, with file, line, and code for each.
• Fix Until Green: with Automatic Fix Attempts, a failed Verify After Landing goes back to the agent, and the flight is verified again, up to 5 times.
• Fan Out: fanOut: in the Flight Plan, or New Fan-Out…, flies one prompt per file, glob match, or item, each in its own worktree, with {item} replaced. Merge Fan-Out… merges the whole group.
• Fallback Agent: a flight whose first turn fails is flown again, once, with another agent.
• Merge Keeping Turns: merge a flight as one commit per agent turn, rebuilt from its checkpoints, instead of a single squash.
• Daily Budget: a cap on total agent spend per day, across projects. Flights hold when it's reached, and the Flight Log shows today's spend.
• Search Flights… finds text in every flight's transcript, title, and prompts, and opens the match.
• Grok: tested against Grok Build 1.0. Edit mode now passes --permission-mode acceptEdits, so Grok can edit files headless, and Plan and Ask use Grok's own read-only permission modes. A dedicated parser for its streaming JSON shows replies, tools, and changed files, and counts tokens once. ATC also looks for grok in ~/.grok/bin.
• Junie: tested against Junie 26.10. Its result now records tokens and cost across every model it used, and a run that reports errors fails with Junie's message, even when Junie exits successfully.

Version 1.2

• Checkpoints: ATC snapshots a worktree before every Edit or Full Auto turn. Undo Last Turn… rolls the worktree back to before the turn, and the agent is told on the next follow-up. Show Turn Changes… shows one turn's own diff.
• Approve Plan…: when a Plan-mode flight lands, approve it (from the sidebar or the landing notification) to resume the same session in Edit or Full Auto mode and build the plan, optionally with your changes to it.
• Fly GitHub Issue… picks an open issue with gh and fills the Flight Plan with its text and comments. The flight's branch is named after the issue, and its pull request closes it.
• Race Judge: Compare Race can ask an agent to compare the racers' diffs read-only and recommend a winner. Its pick is listed first, and its reasoning is in the race report. Automatic Race Judge does this whenever a race lands.
• Fixed: flights in the air are listed first in the sidebar again (they were sorted last).

Version 1.1

• Take This File and Revert in Worktree… for single changed files.
• Sync with Checkout merges your current HEAD into a flight's branch. On conflicts, abort or let the agent resolve them.
• Verify: a per-project test command, stored outside the project, that runs on demand or after every landing (Verify After Landing), with the result in the transcript and sidebar and Ask the agent to Fix on failure.
• Push & Open Pull Request… pushes the flight's branch and opens a PR with gh.
• Re-fly… a flight's prompt with the same or another agent, and Rename… flights.
• Maximum Turn Duration and Maximum Turn Cost stop runaway turns and say why.
• Flight Log: flights, outcomes, tokens, cost and time per agent.
• Open Worktree In… Terminal, Finder, or a new Nova window.
• Custom prompt templates from a folder (Open Templates Folder).
• Automatic Second Opinion from a chosen agent when a flight lands with changes.

Version 1.0

Initial release.

• Flights for Claude Code, Codex, Cursor, Antigravity, OpenCode, Pi, JetBrains Junie, and Grok through each agent's headless JSON mode, with Plan, Ask, Edit, and Full Auto modes.
• Each flight gets its own Git worktree and atc/… branch by default, or runs in place.
• Live Markdown transcripts with tool calls, failures, tokens, cost, and duration.
• Changes, per-file and full diffs, squash merge (staged or committed), and discard.
• Follow-ups resume each agent's own session.
• Races: one prompt to several agents, then a comparison report and merging the winner.
• Hand off: a read-only second opinion on a diff, or continuing in the same worktree with another agent.
• Flight Plan composer, Fly Selection, prompt templates, and Quick Flight.
• Project settings can't choose executables, extra arguments, or the default mode. Plan and Ask are refused for agents that can't enforce read-only (Junie).
• Queue with a configurable number of flights in the air, landing notifications, and flights that persist per project.

Copyright (c) 2026 Swipht Group. All rights reserved.

This extension is proprietary and confidential. No license is granted to use,
copy, modify, merge, publish, distribute, sublicense, or sell the Swipht Group
Air Traffic Control (ATC) extension except to the copyright holder.

Claude Code, Codex, Cursor, Antigravity, OpenCode, Pi, JetBrains Junie, and Grok
are the products and trademarks of their respective owners. This extension runs
their separately installed command-line tools and includes none of their code.