Changelog

The queue is now called Actions, and your whole team can see it

• "Needs you" is now "Actions" everywhere, and every member of a project can see and complete its actions, not only the owner.
• Builds report which AI model and client did the work, warn when it is missing, and show how often it is recorded for your project.
• Admin pages show a plain not-available page instead of raw text, and a UI change now needs a person's visual check before it is accepted.

Updates recover on their own and reach the server faster

• An update that failed halfway can simply be run again, even after newer changes were merged.
• Updates are sent to the server more directly and are about 15% smaller, so they arrive faster and more predictably.
• The plan to replace the JavaScript frontend with simple server-rendered pages is written up and agreed.

Releases go live sooner and recover cleanly from a slow download

• The release package starts building as soon as a checked change is merged, instead of waiting for a second round of checks.
• A slow download to the server no longer cuts off an update; it has its own time limit and one retry.
• A version is only shown as released once it is actually live, and a failed update can simply be run again.

See why a task was closed, and releases get faster

• A finished or cancelled task now shows why it was closed, including the evidence when it was closed as already built.
• Each release builds the dashboard once instead of twice, so releases reach you sooner.
• Automated checks repair a broken set of installed packages on their own instead of failing for hours.

Adding a task is faster, and planning skips work that is already built

• Checking a new task for duplicates no longer reads your whole board, so adding a task on a large board is about four times faster, with the same results.
• When you plan with chosen tasks, each one is checked against your code first, and a task that is already built is closed with its evidence instead of being scheduled again.
• If the duplicate check cannot run, you are told so instead of it being skipped silently.
• Lookups that only read data retry briefly on a server hiccup and say plainly that nothing was changed.

Invites count one seat per person, and UI work starts with the design system

• On a Pro project, an owner with a second sign-in is counted as one seat, so invites are no longer blocked by the duplicate.
• UI tasks get the full project design system when a build starts, so the builder reads it before writing code.

Actions reach the teammate they belong to

• A review or decision from a task goes to that task's creator, not to the project owner.
• A decision not raised from a task goes to the member who proposed it.

Builders verify by tests and code, not a live deploy check

• Planner handoffs stop asking for an MCP restart and a live curl before a change counts as verified.
• A live check is only needed when a task names a deploy requirement.

Hosted plans check for already-built work on the caller's side

• Tasks picked for a cycle whose notes say they are already built are checked by your own AI against your checkout, not skipped on the server.
• A task is only closed as already built when the check cites the source file that shows it.

A failed save now tells you plainly whether it may have gone through

• When the server cannot confirm a change, the error says the change may or may not have been saved, gives a request id, and asks you to check before trying again.
• Changes are never repeated automatically, so nothing is saved twice. Reads still retry briefly on their own.

Releases no longer wait for a package build or a local test rerun

• The release package is built automatically as soon as checks pass on main, so installing a release no longer waits for it.
• A release reuses the recorded full test pass for its exact code instead of running the whole suite again on a laptop.
• Only packages built by the project's own automated checks can be installed, and each one is verified by checksum first.

See who wrote each note and who proposed each decision

• Every new task note records who wrote it, and decisions record who proposed them. Board views, decision views and the task panel show the person's name.
• Notes and decisions from before this release show "author not recorded" instead of a guess.
• The install guide now says plainly that running PAPI locally over stdio is supported. The hosted connector stays the recommended place to start.
• A project owner or release manager can now publish and install a teammate's finished cycle, and is recorded as the person who released it.

Already-built tasks are checked only for the cycle being planned, and strategy reviews stay within the request size limit.

• A plan checks only the tasks picked for its cycle for work that already exists, so unrelated backlog tasks are never scanned.
• The strategy review caps its three grow-with-the-project sections, so a review fits within the tool-result limit.

Board edits can now reopen a cycle and create a missing build handoff

• Cycle status can be changed from the board: move a cycle to active or complete, or reopen a completed cycle when no other cycle is active.
• Every cycle status change is recorded, so reopening a cycle leaves a clear trail.
• A task in a cycle that has no build handoff can get one created from the sections you supply, without a separate generation step.
• Releases finish sooner: independent release checks run at the same time, and a release that only changes documentation reuses the last full test pass.

Your team's board, needs-you list and release page now load and show accurate state.

• The needs-you list separates release problems, stuck builds and handoffs waiting on sign-off.
• Exports now include decisions, conventions and cycles, and say which part failed if a read goes wrong.
• Assignments on the team page are recorded the same way as assignments made from your AI client.
• Errors name the real problem, such as a missing cycle or a project name that is not unique.

A build start refuses a task that another live session is already building, instead of only warning.

• build_execute refuses to start a task another live session holds; pass your session_id from session_announce.
• A start that cannot confirm its claim backs off rather than building the task twice.
• Product update emails now arrive in a light design with headed sections, screenshots and numbers.

PAPI now records how each tool call went, so cycle timing and failures can be measured.

• Every tool call records its size, outcome and cycle, so per-cycle numbers can be read directly.
• A failed release or cycle closure now records why it failed.

Planning and building are faster and lighter, with fewer steps before each task.

• Orient, planning and build starts send less text, so each step returns sooner.
• Reviewing several tasks takes one call, and a finished build shows how long the review queue has waited.
• Plans stay within their size limit and leave out tasks that belong to other people.
• Releases are safer: a broken main is refused, and test runs no longer collide on shared state.