Long Claude Code work, run as phases.

Phase Console plans the work, hands each phase to a fresh session, and keeps a board that reads what is actually done — from disk, never from memory.

Read the docs

Phase graph — checkout-rewrite5/5done

1doneSchema + migrations
2donePricing service
3donePayment adapter
4doneCart API
5doneRefund worker

How a plan runs

Four moves. The fourth is what makes the other three worth trusting.

The plandone
Every phase declares what must finish before it can start. The graph is the plan — there is no cursor to keep.
A fresh sessiondone
Each phase gets its own session, sized to the model's window, so it never thins out mid-thought.
The handoffdone
A phase ends by writing the baton: state now, files changed, decisions, and the exact next commands.
The boarddone
Recomputed from the plan and the handoff files on disk, every time you look.

Every key, every model, one pool

Since 8.0, Pro spends API keys as well as Claude logins — Anthropic, DeepSeek, OpenAI through the console’s own bridge, and any Anthropic-compatible endpoint — from one pool, under a policy you set for the console, a plan, a phase, a run or the supervisor. Every account has caps and a ledger of what it spent. And the Queue shows every phase of every plan in the order it will start, and checks a move before it is made.

Settings ▸ Accounts in the demo: every account with its kind, its provider and its standing in the pool, and the Pool card with the console’s policy. — Settings ▸ Accounts in the demo, once the pool has spilled to an API key.

Insights ▸ Accounts in the demo: what each account spent over the window, by provider and model, and how much room each cap has left. — Insights ▸ Accounts in the demo: the ledger, read by account.

The Queue in the demo: every phase of every plan in the order it will start, each with its place, the account it would spend and why it sits there. — The Queue in the demo, after a move the check let through.

API-key accounts, Pro: Add a key for Anthropic, DeepSeek, OpenAI or any Anthropic-compatible endpoint, on Settings ▸ Accounts or with phase-console accounts. A key is never echoed and never reaches the browser — you see its last four — and a smoke runs one bounded session on it and says what it cost. Every run then names who pays: the account, its provider and the model.
OpenAI, through the console’s own bridge, Pro: An OpenAI key does not speak the language Claude Code speaks, so the console runs its sessions through a bridge of its own on 127.0.0.1. The key stays with the bridge, each session gets a token of its own, and every request it carries is a row in the ledger like any other spend.
Live model lists, Pro: The console reads each provider’s own list of models, with its context window, its output limit and its price, and one picker offers them wherever a model is chosen: the launch form, a run’s settings and a phase’s own override.
One pool, one policy, Pro: A policy says which account each new session spends: subscriptions first (the default), API keys first, take turns, by weight, or pinned to one. Set it for the console, a plan, a phase, a run or the supervisor; the launch form shows where each open phase would start, and a change takes effect at the next phase.
Spills, said in one sentence, Pro: When no account of the kind the policy prefers has room, the pool spills to the other kind — at a run’s start, at a phase boundary or on a wall mid-session — and the journal says why in one sentence.
Caps on what each account spends, Pro: Each account has a priority, a weight, the models and plans it may serve, and caps per day, week and month and on sessions at once, and the pick obeys them. A reached cap halts the run with three ways forward — raise the cap, switch account, or hold the run — said in the same words on the halt card, the bell and the lock screen.
A ledger for every account, Pro: What every session spent is recorded by account, provider, plan, phase, run and model. Insights ▸ Accounts reads it over any window, with its filters in the address and a CSV to download, and Fleet ▸ Accounts reads every console’s on the machine.
The Queue’s forecast, Pro: Every phase of every open plan in the order the console will start them, each with its place, when it should start, how long it runs, the account it would spend and why it sits there — worked out by the same rules the runner starts phases by.
A move checked before it is made, Pro: Ask whether an order can hold and the console answers yes, yes with what else moves, or no with its rule and the nearest order that would hold. A no is refused; anything else is kept as an order that survives a restart, even across plans, until you revert it.
The Queue page, Pro: Under Runs, every phase in the order it will start, as one list, as lanes or by plan. Lift a phase and every place it could take is marked: holds, holds with others moving, or cannot hold. A sheet says what the move does before you apply it, and an applied move waits a few seconds with Undo.
Fleet ▸ Queue, Pro: Every console’s forecast on one list, the longest wait first, and Board first sends a move to the console that owns the phase, whose own check decides it.

The rest of what 8.0 adds8

The supervisor speaks the Queue, Pro: Ask the supervisor why a phase has not started and it answers from the forecast’s own rules. It moves a phase only when the check says the move holds, and a remedy that reorders the queue is checked again when it is pressed.
Your turn, a page you work from, Free: Your turn is the eighth destination and every plan’s fourth view, with tabs for what is open, what is finished, what the AI handled and everything; four views — list, board, cards and timeline — with its groupings and sorts kept in the address. Every status word explains itself, and the bell’s drawer previews five items, each with Put back.
Phase graphs you can work with, Free: The plan’s map gains filter chips, a trace, colours, layers, layouts, a hover card and an SVG or PNG export, each kept in its address; two new readings, Schedule and Burn-up; zoom and quick ranges on the timeline; and a lock map on Sessions ▸ Locks.
Tables and cards that say more, Free: An outlined status badge, a plan’s track drawn to scale with its legend, Sessions rows that say what each runs on — its account, model, spend and context — a summary strip, the halt card on the Runs home, and the 6.x Departures palette back as a choice in Settings ▸ Appearance.
Any MCP server, signed in on the page, Free: Search the open catalog of MCP servers, add any server by hand, fill in a value it asks for, and sign in told step by step — on the page, or with phase-console mcp.
Waive a verification line, Free: A verification line now tells a line cut off by its clock, and one that never ran, from a red one, and you can waive one red line for one phase. It is listed under Waived by the operator, so nothing passes in silence.
The console’s own git, hardened, Free: The console’s git ignores the system’s configuration and runs no hooks, and a push is read by its clause: a trunk only where the plan names it, with its phases. Two new halts name a tree whose git configuration a session changed, or whose stale lock file blocks it.
A load guard that reads the real CPU, Free: New work is held on how busy the machine’s CPU really is over 30 seconds, counting every console’s work. A heavy verification line waits for a seat in one machine-wide budget, and a session’s orphaned test runners are cleaned up when it ends.

Your turn, told step by step

Since 7.1 every item on Your turn is a card you can act on without reading anything else. It is an approval, a task, a decision or a heads-up. It says NOW, or NOT YET and when, gives numbered steps and every clock on one grid, and says where your press goes and who checks it.

Your turn in the demo: a card with its type, whether it is due now, its timing grid, its numbered steps and where a press goes. — A card on Your turn in the demo, told step by step.

The card, step by step, Free: Every item is one card. Its head says NOW, or NOT YET and when; its timing grid puts every clock on one page clock, from when it became yours to its deadline; then come why only you, the numbered steps and how it will be checked. A command to run is one block to copy, and a command with a placeholder is a template to fill in.
Four types, one form each, Free: An item is an approval, a task, a decision or a heads-up, and each has its own buttons: Approve or Deny, with a permission approved at a scope; for a task, one press that asks the console to check it; the options and Send my decision, with nothing chosen for you; or Got it. A gate, a plan approval and a permission say what was asked, who asked, and what follows a yes or a no.
Where your press goes, Free: Every card says where a press goes — to the phase, the run, the gate or the console — and who decides it is finished. A press that ends an item waits a few seconds with Undo, a check in progress can be taken back, and Hand it back gives an item back to its phase, asks its session a question, or says you cannot.
The page, in six groups, Free: Your turn sorts items into Approve, Do now, Decide, Being checked, Coming up, and what was settled, under a strip that counts what is to do, what is being checked and what passed today, with the next deadline. Its filters, grouping, order and view live in the address, so a narrowed view is a link, and each plan the items name has one line saying where it stands.
Run requests, Free: What only the whole run can do — run again in a checkout of its own, move to another account, raise a phase’s budget, stop or hold — is one approval per run and act, however many phases asked. Approve takes the act on the run and the phases carry on; Deny tells them no.
Items that close themselves, Free: When a new run of a plan takes the place of a stopped one, the old run’s own items close by themselves, and so do those whose phase has finished or whose errand is gone, each with a line saying why. A sign-in, a secret or an errand at the machine moves to the new run instead.
The supervisor takes a run’s requests, Pro: A run request goes to the supervisor first. It holds a run or relaunches it isolated by itself, suggests a move to another account, and brings a budget raise or a stop to you, because one spends money and the other ends work. Its reversible remedies no longer wait on a person, and any card can be handed to its chat.

The rest of what 7.1 adds2

The same words everywhere, Free: One composer writes every word of every item, so the card, the bell, the Runs home and a push to your phone say the same thing, and a push’s lock screen offers the buttons of its type. No internal reference reaches a person.
Guides born in the plan, Free: A plan’s human step can name a guide file, and the plan’s errands table gives a row’s steps to the item that names it; a row no step names is a heads-up. Where nothing was written, the console gives steps in the situation’s own words.

Every page quiet, every fact in reach

Since 7.0 the console is seven places in three bands, and each place is one calm column, one line per thing. A line opens where it stands or in the panel beside the page, and Everything shows every column and fact a page holds. Every place is checked in a real browser on a phone, on a tablet and right to left.

The Runs home in the demo, with a run open in the panel. — The Runs home in the demo, with a run in the panel.

Seven places in three bands, Free: Runs, Plans and Sessions hold the work, Repo, Insights and Logs the record of it, and Settings the console itself: the same seven in Free and Pro, down a rail on a desk and along a tab bar on a phone.
The panel, Free: Any record opens in the panel beside the page, with its overview, the actions you may take on it, its history and its raw form. On a desk the panel stays open from page to page, on a phone it rises as a sheet, and any line can also open where it stands.
Everything, Free: One switch at the end of a page’s toolbar shows every column, fact and folded section instead of the essentials. In Settings it lists every key the server describes, with its value, its default, where the value came from and a reset, and, for a key only the command line or the machine sets, the line that sets it.
Every option has a door, Free: Every route, event, setting and operator verb the server has is listed with the page where you reach it, or the reason no page should offer it, and a test holds the list to the server in both directions. The palette and the panel’s actions offer every verb that fits, and one this console may not press names the flag it needs.
Any screen, either direction, Free: Every place is checked in a real browser at a phone’s width and a tablet’s, by thumb, and mirrored right to left, with each line of text finding its own direction; motion stops when your system asks for less.
The Supervisor, in the panel, Pro: The Supervisor is the panel’s second mode, beside any page and one keystroke away (⌘. on a Mac): every conversation in one picker, the model and effort that answer you under its title, and the policy it acts by beside the machine’s own switch. On a phone it is a page of its own.
Fleet, behind the switcher, Pro: The switcher at the top of the rail lists every console on the machine, worst first, with how many things are yours in each, and opens Fleet: eight sections, each with its own address, for what is yours across the machine, the consoles, their queues, accounts and locks, the supervisor, its health, and how a phone reaches it.

The rest of what 7.0 adds8

The Runs home, Free: The console opens on one sentence that says where things stand, then Your turn, then every run grouped by where it is, from moving to settled today, each on one line with exactly one action; a halted run’s action comes from its halt. All runs shows them as one table.
Plans, and a plan on one page, Free: The library shows each plan on one line, as a list or as cards, with closed plans and documents folded away. A plan opens on its glance over three views: its phases with the route map, its run — where the time went, what it cost, the ways forward — and its source.
Sessions, on one grid, Free: Every lane, terminal and Claude session is on one grid; one opens at full height with its terminal, and the locks sit beside them, each with who holds it.
Repo, in six sections, Free: Repo shows what the work did to your repositories in six sections, each with its own address: history, branches, working trees, changes, how each run’s work reached the trunk, and the Issues desk. Any record opens in the panel.
Insights, by the server’s arithmetic, Free: Insights answers how long is left, what it costs, what a session may spend, how this week went, how fast the work moves and who was asked, each by the server’s own arithmetic.
Logs, from the live tail to the bundle, Free: Logs puts every log the console writes on one time axis with its live tail, beside a run’s journal, what became of each announcement, the doctor’s checks, stray consoles and who reached this console, and packs all of it into one redacted bundle.
A quiet room, Free: A status is a small dot and a word, never a coloured chip behind text, and what has settled wears a hollow dot. The page keeps to one type face at four sizes in one cool room, light or dark, with rows set apart by space, and a long path or command wraps at its own spaces before it breaks a word.
As many tabs as you like, Free: One tab holds the console’s live stream and shares it with the others, so a second tab no longer breaks the first, and lists read a slim summary, fetching a whole run only when you open it.

Your turn, on one page

Since 6.2, every act only a person can do is an item on one page: a sign-in, a secret, a payment, a permission the AI lacks, a decision. Each says why it is yours, how to do it and how the console will check it, and the check passes it or sends it back with exactly what to redo.

Your turn in the demo: the sign-in a run needs, with why only you can do it, what it unblocks, and a guide whose command can be copied. — Your turn in the demo, while a run stops for a sign-in.

Your turn, Free: Every act only a person can do is one item on one page, sorted into what to approve, do now or decide, what is being checked, what comes up next and what is settled, each with why it is yours, a guide to follow and what it unblocks.
The check, Free: When you say you have acted, the console proves it with a probe or a checking session, and passes the act or sends it back with exactly what to redo. No session can pass its own item, or ask you for what it could do itself.
Grants with a scope and an end, Free: A permission the AI lacks reaches you as an item, and your grant reaches exactly as far as you choose — this call, this phase, this plan, this repository or always — applied by the server, recorded and revocable, beside a never list no grant lowers.
The owner key, Free: A passkey lets a console tell your press from any other door’s. Once one is enrolled, a risky press from a script, a phone or a session becomes a request you confirm.
Your turn, with the supervisor, Pro: The supervisor raises what it cannot fix as items with a guide, explains them in its chat and answers none of them; the fleet supervisor lists every console’s items as one; and a flag a run lacks is granted through the console’s own unit.

Everything else 6.2 adds1

What the AI handled, and your answer’s way back, Free: The page keeps itself current and lists what the AI did instead of asking you. A decision you make goes back to the session that waits on it, and into the plan’s decisions.

Every issue, filed and planned

Since 6.1 the Issues desk reads every issue a repository has: what kind it is, how severe, and which plan will fix it. With Pro, a run files the problems it meets outside its phase, and the supervisor turns the issues you pick into a plan.

The Issues desk in the demo: a bug a run has just filed, marked high severity and needing a plan, among the repository’s other issues. — The Issues desk in the demo, the moment a run files what it found.

The Issues desk, Free: It reads a repository’s whole issue list and shows each issue’s category, severity and place in a plan, with every column sortable and filterable.
A run files what it finds, Pro: A problem a session meets outside its phase is filed on the repository it belongs to, with its type, severity and labels; anything over a limit is held for you, never dropped.
From issues to a plan, Pro: Pick issues on the desk and the supervisor writes a plan that fixes them, checks it before installing it, and starts the run after one confirmation.
The supervisor’s model, in view, Pro: The chat says which model and effort answer you, lets you switch them for the next message, and records the pair on every turn.

Everything else 6.1 adds2

Waits beyond the checkout, Free: A phase can wait for a job on another machine, keep a date as a backstop beside what it watches, and spend more waits when its plan allows.
Your acts, when they come due, Free: A command only you can run, or a click path only you can follow, sits under Coming up until its trigger lands, then tells you once and clears when its proof arrives.

Every run, in one look

Since 6.0 the console opens on every run in one look, the most urgent first: the Tower then, the Runs home since 7.0. What waits on a person reads Needs you, and amber marks nothing else.

The Runs home in the demo: a run stopped on its Claude account waits on its line, with the one press that recovers it. — The Runs home in the demo, the moment a run stops on its account.

Every run in one look, Free: Every run sits in one group, most urgent first, on one line with one clock that says what it measured and the one action that fits where the run stands.
One card for every stop, Free: A run that stops says why in one plain sentence, sorted into one of nine families, with the console’s recommended recovery on the first button.
Statuses that say what they mean, Free: Every status carries a word and an icon as well as a colour, amber marks only what a person must do, and a board the console cannot read says unknown instead of zero.
A run starts from one screen, Free: Pick a preset or open one of nine rows where it stands; the form shows the run’s route, anything that would hold it up with its own fix, and the turns it will ask of you, and the plan file can ask for a permission mode and a git strategy.
Budgets you can raise, Free: A phase close to its dollar budget says so on the run page before it stops, and one press gives it more.
Locks you can see, Free: Sessions ▸ Locks lists every claim the console can see: who holds it, on which branch and checkout, until when, and what it holds up.
A person’s turn, Free: A sign-in, a device code or an approval only you can give becomes a step with its own card, a way to prove it happened, and a push to your phone.
Your phone as the control surface, Free: Every page works at phone width, and Your turn lists what is yours to answer, so a sign-in, an approval or a recovery can come from your phone.
The Supervisor, Pro: It watches every live run, offers or presses the remedy as your policy allows, and answers in a chat beside the work why a run stopped and what it would do next.

Everything else 6.0 adds8

The lock ledger, Pro: Every lock claim is kept as history, so you can read back who held which repository, and when.
The queue, with its reasons, Free: The queue shows every phase in the order it will start and why it sits there, and you can pin a phase next, keep a lane for it, or have a lane handed over.
One table of verbs, a reason on every press, Free: Every operator action is one verb, pressed from the page or by a trigger you store, and a press can carry a note that says why.
Waits that watch the right thing, Free: A phase can wait for a sibling phase to finish or for its own failing checks to pass, and a check cut off by its clock is retried rather than counted against it.
Account forecasts, Free: Each account shows how fast it is burning and when it will reach its limit, and an account with credits can carry a run past its plan limit.
The week in numbers, Free: phase-console report measures any stretch of time: how long each run sat stopped and who started it again, the stops today’s rules would not make, and what it all cost.
Tables, charts and a map that scale, Free: Every table can filter, group and keep its view, the run chart has a live time axis with a cost strip, and the route map stays readable at seventy phases.
A guide to every page, Free: The built-in guide explains every page and overlay, in English and in Persian.

Many plans, one repository

Since 5.1 several plans can work the same repository at once without sharing a working tree, and everything happening to the repository is in plain view.

A plan’s run view in the demo: the run at work on phase 4, the banner offering to raise its nearly spent budget, and its lane. — A plan’s run view in the demo, mid-run.

A checkout of its own for every run, Free: Several plans can work one repository at once: each run gets its own checkout, forked from the trunk at a pinned commit and locked with a reason, so no two runs share a working tree.
Each phase lands the way your plan says, Pro: When a phase settles, the console brings its work home as the plan asks, into the run branch, as a pull request or onto the trunk, and pushes nothing until you allow publishing.
The repository map, Pro: One map per repository shows every plan, run, checkout and landing touching it, with a radar for conflicts and a forecast beside them.
Sessions that talk to each other, Pro: A session can message another phase, live or not yet started, every lane of its run, or you, and learn what became of the message.
Issues from sessions, Pro: A session files what it trips over as a draft for you to approve, and from the Issues desk you can have one issue fixed on a branch of its own or a problem written up.
One trace for a whole run, Free: One trace id follows a run from the request that started it to every git command it ran, nothing on disk grows without a bound, and a run exports as one redacted file.
The run as one picture, Pro: Logs ▸ Timeline puts the run, its phases, sessions, warnings and slow git commands on one axis and exports it as a trace Chrome can open, and Logs ▸ Git lists every git command the run made.
Reach from your phone, Pro: Pair a phone with an eight-character code and reach every console through an HTTPS door on your own machine, with no Tailscale in between.

Everything else 5.1 adds4

Notes for a phase that has not started, Free: A finished phase can leave a note for a later one, which starts with it in its first prompt and says what it did with each.
Every question asked at the start, Free: Before a run starts, the launch form lists each check a phase would stop on and what each phase will run as, so no approval stops it halfway.
Spend you can see, and that cannot run away, Free: Context and spend are counted per call and shown live, a session stuck in a loop of status checks is refused, and an account close to its limit takes on no new lanes.
Restart onto the latest version, Pro: Every restart updates the console first and can wait for live sessions to finish, and one update moves the console and its plugin together.

What it will not guess

Nothing remembers your progress: The board is derived from the dependency table and the handoff files, so out-of-order and resumed work stay correct.
Phases fan out: Finishing one phase can release several. Those touching different repositories go at the same time; those sharing one are serialized by a lock.
A phase that stops short is classified: The console reads why it stopped and climbs a bounded ladder of remedies, within caps in attempts and in dollars. Exhausted, it leaves you one errand.

How you buy it

Free is the whole console for one repository, and it stays free. Pro is one licence key.

One key: It arrives by email and on your account page. Activate it in Settings ▸ License, or with one command.
Up to 3 machines: The key is active on 3 machines at a time. Deactivate one from your account page to move the key.
A year of updates: Every release until your licence ends. After that, the builds you already have stay Pro.

Pro, installed your way, Pro: Pro is the prebuilt phase-console-pro package, installed with npm, Homebrew or one command, and unlocked by your licence key in Settings ▸ License or with one command.

With npm
```
npm install -g phase-console-pro
```

With Homebrew

brew install zsarir/tap/phase-console-pro

With the installer

curl -fsSL https://phase-console-site.vercel.app/install.sh | bash -s -- --key PCP-XXXX-XXXX-XXXX-XXXX

See the price and every step

Settings ▸ License in the demo: the licence active, its masked key and this machine’s activation. — Settings ▸ License in the demo.

Start with Free

Free installs from the public repository as a Claude Code plugin: two commands inside Claude Code, then one in a terminal.

In Claude Code, add the catalog

/plugin marketplace add phased-execution-public/phase-console

Install the plugin

/plugin install phased-execution@phased-execution-public

In a terminal, start the console and pick your plan
```
phase-console
```

macOS, Linux and WSL2, with Node 22.18 or newer. The first start names the one build its page needs.