Changelog

Board reads are faster on large projects, and the idea tool stops repeating the same project rules.

• Loading the completed tasks on a large board is several times faster, with the same results.
• Reconciling the board reads the completed tasks once instead of twice.
• Slow database requests can now be traced to the part of PAPI that issued them.
• The idea tool shows the full project rules once per session and titles after that, and still flags any idea that conflicts with a rule.

Planning sends less text: the branch and drift rules load only when they apply.

• The branch-coherence rule loads only when the board spans more than one module.
• The priority drift check names its three signals once, without repeating the recalibration text.

Planning and orient send less text per call, and the planner keeps standing release rules in conventions.

• The plan board is capped at 12 KB, and the planner skips the audit-classification rule unless a task needs it.
• The carry-forward says only what changed this cycle; standing release rules live in conventions and are sent once.

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.

Board and planning replies are smaller, and editing a task's handoff no longer means regenerating it.

• The task board shows fewer columns by default; ask for the full table when you need it.
• Editing one acceptance criterion or handoff section no longer regenerates the whole handoff.
• The planner leaves out other members' tasks, and its reply is smaller.
• Orient and the build start reply are smaller, with the same warnings.

A new project starts on a light setup, and reviewing several tasks takes one step.

• A new project starts with fewer steps and turns on more as it grows; any setting you chose stays as you set it.
• Orient shows how long tasks have waited for review.
• One review call can record verdicts for several tasks; each still needs your own verdict.
• Optional warn-only guards can be installed for your AI client, and nothing turns on without asking.

Structured output from a planner or handoff generator is accepted with or without a code fence, and the prompts now say which form to use.

• Handoff and plan apply accept the structured output whether or not it is wrapped in a json code fence, so a bare JSON block no longer fails with a generic parse error.
• The handoffs-only and handoff generator prompts name the json code fence explicitly, so callers send the expected envelope.

A cycle whose finished work was squash-merged, or later replaced by other work, can now be closed with a verified, recorded correction instead of hand-edited records.

• Closing a cycle accepts a correction naming the commit that actually landed each piece of work, and checks it against your repository before it counts.
• Work that a later change replaced can be closed as superseded, naming the change that replaced it.
• Every correction is recorded on the task with who made it, when, and why, and finishing a build without its commit or files now warns you straight away.

A large board now loads in a handful of pages instead of dozens, so board reconciliation returns inside its time budget on a mature project.

• The board reader asks for pages of 1000 rows instead of 100, so a 4,700-task board takes about five calls rather than about forty-seven.
• Selection, ordering and filters are unchanged, and the same candidates come back in the same order.
• Measured on the PapiUI board, a 1000-row page takes 752 ms against 587 ms for 100 rows.

board_reconcile prepare on a mature board no longer pays for full-row reads it never uses, and a refused board read no longer surfaces as an orient failure.

• The cycle-integrity check and the code-ahead mismatch check now share one compact board snapshot instead of making two separate full-row reads of every task on the board.
• The Done cross-check reads only id and title, and the active read is compact, so notes, handoffs and build reports never ship to checks that do not use them.
• The reconciliation report is unchanged, with the same candidates in the same order, and no truncation, cap or deadline change.

board_reconcile prepare stops reading full rows for its Done-task cross-check on a mature board, and a refused board read no longer surfaces as an orient failure.

• The Done-task cross-check now reads only id and title instead of every full row, cutting the heavy-column reads in reconcile prepare on a 4,600-task board.
• The reconciliation report is byte-identical on the real board, same candidates and same order, with no truncation, cap or deadline change.
• A board page refused for lack of a search slot is retried inside the call, covering the first page, windowed pages and the sequential fallback, and the health summary no longer runs its two reads at once, so orient survives transient contention on a large board.

A release can no longer ship a version whose tag never reached the remote, and the edge deployment has one named owner.

• Recording a release version now checks the remote for its tag, so a version claimed without one is refused instead of silently recorded.
• Ownership of the data-proxy edge deployment is settled in writing against the code: promote.sh decides when, scripts/deploy-edge.sh does the work, and nothing else deploys it.

Large boards load faster, and slow database reads and failed build-report writes now say where the time went.

• Reading a large board for orient and idea no longer waits on one page at a time, so both respond sooner on a project with thousands of tasks.
• A slow reader or a failed build-report write now records which stage it was in and how long it took, so a one-off failure can be diagnosed afterwards.

The server no longer changes your database when it starts, and says exactly what to run when the schema is missing.

• Starting the server only checks the schema; it never creates or alters tables, so a start can no longer deadlock beside live writes.
• A missing or outdated schema stops the server with the command that fixes it, and a new init command sets up an empty self-hosted database.

Review becomes a step with its own brief, and OAuth sign-in survives a lost response.

• Every task in review now has a brief to review against, and release lists any task that never got one.
• Refreshing a sign-in is atomic and tolerates a retry after a lost response, so fewer forced re-connects.
• Recorded build tokens show on the task and in the AI usage report; the admin view counts multi-builder projects per week.
• A version-collision check now guards pull requests and release tags.

Plans show open dependencies, bugs land on the board, and the design system reaches every AI client.

• See a task's unfinished prerequisites before choosing a cycle, in the plan and its preview.
• A bug, research or spike item filed with an explicit type lands on the project board, not a personal queue.
• The project's design system is delivered to plan, build, review and orient, and shown on Strategy > Design.

Builds now record when they started, which tool built them and how many tokens they used.

• A build's start time and the tool that made each call now survive a server restart, so duration, tool-call counts and the tool name are no longer lost.
• Starting a build lists the details to send when completing it, and a completed build says exactly which were left out and how to add them.
• Plan, review and release calls can carry the tokens used since the previous stage, and each response says how to collect them.
• The new usage-reporter skill reads token counts from your AI client's own local transcript, numbers only, and reports Not recorded when it cannot.

Plans respect who owns a task, and an oversized plan context is described honestly.

• Check task ownership when a plan is previewed, so work that belongs to another member is not assigned.
• Say how large the plan context really is when it is over budget, and name its largest parts.