Changelog

520releases across 9 months

Every PAPI release, cycle by cycle. Each one pushes back against project drift.

Get started free

October 20263 releases

v0.402.130

A new hub: what needs you, the roadmap, the board and the project overview on one page

  • The hub opens with the one thing waiting on you, a quiet health strip and a roadmap row that names each horizon and stage.
  • The board is now the default view of your work, with stage columns, who is working where, and simple task cards.
  • A one-line project overview and an activity table show backlog, decisions, discoveries, docs and the latest events at a glance.
  • A new sidebar and phone tab bar keep every page one click away, and ad-hoc work now records who did it.
Full detail
  • Hub redesign: one page shell — next action, health strip with Actions, Invite, banners in one slot (spec §3 blocks 1–4)
  • Board page did not load for an external user (Lee, 2026-10-07) — reproduce and fix
  • Hub roadmap data: return every phase, the cycles each phase covered, and the version each phase shipped in
  • Redesign hub: Work block — one toolbar (Work · Board|Team · module filter · New task), kanban with people in column headers and quiet cards, team table
  • Redesign canon: light-first tokens, new stage colours and magenta action across palette.ts, globals.css, DESIGN.md, PRODUCT.md, app/CLAUDE.md, brand book
  • Needs you redesign: one list of everything waiting on a person (decisions, conflicts, reviews, blockers, non-code tasks, review due, agent messages), shown in the sidebar, the hub tile and the action bar
  • Redesign sidebar: Hub, Board, Roadmap, Strategy (Overview, Decisions, Reviews), Insights, Library, Needs you; Workspace: Projects, Settings — old URLs redirect
  • Redesign mobile nav: top tabs Hub, Board, Roadmap, Strategy, More (Insights, Library, Needs you, Projects, Settings)
  • Redesign action bar: one right-side panel for hub, board and roadmap; Actions panel mirrors Needs you (which stays as a page)
  • Redesign hub: Project overview as one inline strip (Backlog, Decisions · conventions, Discoveries, Strategy review, Release, Docs) plus the Activity table
  • Record the calling contributor as the assignee on every ad_hoc path, not only held ones, so finished ad-hoc work is no longer left without an owner

v0.402.129

A friendlier first run and a light landing page

  • Setup now walks you from connecting to your first built task, in plain language.
  • The landing page and pricing open light, with dark one click away.
  • Bugs you file land on the project board instead of a personal queue.
  • Orient no longer tells a new task it has been stalled for hundreds of cycles.
Full detail
  • Stop reporting brand-new unassigned tasks as stalled for hundreds of cycles; an unassigned task's age is unknown, not a guess.
  • Route a structured engineering bug (or other structured work type) that carries a module to the project board instead of the personal owner-action queue, even when its text contains a communication verb.
  • Add a versioned prerequisite contract for release-readiness evidence. A runtime that cannot produce valid evidence refuses with the capability and the version that provides it, instead of reporting a missing receipt.
  • Measure real database time at the hosted data-proxy dispatch and surface it as db_ms on each MCP request, summed across the request's calls. Adds the database access-path inventory report. Query-shape ranking is not included.
  • Render the landing page and pricing light-first on the new lavender palette, with dark as the explicit toggle.
  • Rewrite llms.txt as a plain-language first-run guide from connect through setup, plan and first build, including chat apps.
  • Bring the public install repository in line with the live llms.txt and refresh the community Discord welcome and rules.

v0.402.128

More reliable planning and release summaries

  • Keep saved planning details consistent across supported runtimes.
  • Build release summaries from the completed cycle without loading unrelated work.
  • Keep first-project classification consistent when requests arrive together.
Full detail
  • Finish remaining server SQL escape hatches through bounded adapter capabilities; keep conversion evidence counts-only and make first-project classification atomic.
  • Supply parser identities through a portable provider while preserving existing handoff and report exports and stored identities.
  • Move planning decisions, contracts and write payload assembly into portable shared code; retain runtime effects in the existing server.
  • Add a default-off private disposable Go dependency-operation pilot through existing authentication and canonical SQL. No production native activation is included.
  • Select closed-cycle release summaries in the database instead of transferring the full board. Production worker incident attribution and closure remain Partial.

Unknown15 releases

v0.402.127

Accurate saved notes and clearer database diagnostics

  • Keep ordinary security guidance intact when saving notes and documents.
  • Avoid creating an issue when a build explicitly reports no newly unfiled findings.
  • Verify complete decision scores, stable ordering and visible failure if a later page cannot load.
  • Give operators measured query round trips while keeping unavailable database execution time unknown.
Full detail
  • Preserve benign bearer security prose in saved notes and document bodies while masking explicit and supported credentials.
  • Interpret the explicit no-newly-unfiled verdict consistently in MCP completion and dashboard findings, retaining the original report text.
  • Verify tenant selection, stable cycle/id ordering across real database pages and failure after a successful first page.
  • Observe the existing direct-pg and dashboard query boundaries with content-free, default-off diagnostics and a bounded operator report. Rank measured round trips separately; unavailable PostgreSQL execution time remains unknown.
  • Reuse installed search repairs and bounded resource/cancellation workloads. Historical cause attribution and production incident closure remain outstanding; no additional speculative repair or closure is claimed.

v0.402.126

Complete project lists and clearer account status

  • Find every accessible project while keeping shared access separate from owned-project usage.
  • Show your verified project role and account limits without guessing when a read fails.
  • Keep feedback edits visible after a failed save and identify each submission with its full reference.
  • Use the correct private admin tools and recover from interrupted reads or invalid connection codes.
Full detail
  • Select caller-owned project catalogs and account usage in PostgreSQL before pagination; preserve exact totals and caller isolation.
  • Keep the private admin shell on supported admin routes without personal-project, billing or onboarding reads.
  • Preserve edits after failed feedback writes and show safe, actionable error references through the existing UI, API and MCP paths.
  • Show recovery for invalid CLI activation links and exclude redeemed codes before selection.
  • Move content management onto supported private admin routes and keep signup alerts on the admin deployment with distinct loading, unavailable and retry states.
  • Through — Repair export, CLI redemption, feedback disclosure, cycle validation, state recovery and CI queue defects found during implementation.
  • Bound suspended admin pages during optimized private builds and require the prepared version changelog in the existing cycle PR preflight.
  • Observe the authoritative post-deletion project catalog in the real browser regression before checking that the mounted selection has cleared.
  • Recognize the pinned platform's exact opaque error envelope for bounded safe-read recovery, including project discovery before tool execution. Share the existing retry policy, retain caller cancellation and classify recovered versus exhausted reads without replaying lifecycle writes or attributing an unknown fault to worker cancellation. Historical incident attribution remains Partial.
  • Retain qualified release improvements. Genuine cached merge-to-live timing remains Partial. The prepared v0.402.125 attempt stopped before application activation; this version includes its cycle changes and release repairs.

v0.402.124

Faster diagnostics and clearer recovery

  • Load activation metrics without waiting for optional diagnostics.
  • Keep complete diagnostic counts with a single database report.
  • Show a temporary-unavailable response when credential storage cannot be reached.
  • Reduce repeated release checks while preserving approval and source verification.
Full detail
  • Distinguish unavailable credential storage from invalid credentials; fail protected reads and writes closed with an actionable temporary-unavailable response.
  • Aggregate complete activation diagnostics in PostgreSQL, order the recent feed consistently, and load diagnostics only when requested without blocking primary metrics.
  • Verify SQL search admission across actual edge-worker replacement, including accepted work, overload and another tenant; capture bounded runtime resource evidence. Historical attribution and post-deployment incident closure remain Partial.
  • Consolidate final integrated-source inclusion proof in the existing release gate, reducing duplicate metadata reads while preserving provenance and revert checks. Actual representative and cached merge-to-live timing remain Partial.
  • Initialize search evidence in the canonical build directory and use a fixture-specific filename so clean Linux worktrees qualify without old generated directories.

v0.402.123

Safer database reads and smoother release recovery

  • Reject invalid pagination settings before a database request starts.
  • Preserve approved work when a test moves within the final release.
  • Keep operational failures visible when request logs are busy.
  • Reduce search-test setup work while retaining the full verification.
Full detail
  • Use one private tunnel address for SSH binding, readiness and the audit database client; cover native Linux and the existing WSL bridge without copying private keys.
  • Verify an additive test relocated inside the exact accepted combined PR while preserving original build records; keep missing assertions, unapproved source and product reverts blocked.
  • Reject invalid page sizes, offsets and totals before database I/O in both existing pagination helpers; preserve valid traversal and errors.
  • Replace 80 serial relevant-search fixture writes with two bulk statements and retain deterministic recency, full corpus and real transport/planner checks; measure setup separately.
  • Retain operational failures across busy log windows and classify real hard CPU/memory limits; preserve bounded private intake and delivery. Live incident acceptance remains Partial.
  • Record owning suite startup/shutdown costs alongside phase measurements and reuse existing exact-source qualification/artifact owners. Representative and cached merge-to-live timing remain Partial.
  • Serialize the two canonical-product CI fixtures and keep failed setup from deleting another fixture's project or linked incident report; exercise the failure through the real test executable.

v0.402.122

Safer imports and reliable build history

  • Import a confirmed task batch safely, including repeated and overlapping requests.
  • Keep original build evidence and recover missing files without replacing task history.
  • Keep completed work awaiting your review and recover an interrupted review checkpoint.
  • Repair failure-monitoring intake and release preparation while preserving verification.
Full detail
  • Select import duplicates in PostgreSQL and commit each confirmed batch atomically; repeated or overlapping requests cannot create duplicate identities. Preserve bounds, stale-preview refusal and exact retries through the existing project ledger. Enforce the import key's project binding.
  • Retain verified explicit build commits and changed-file manifests. Repair an original report's missing files without replacing its identity, attribution or reviews. Return permission refusals with the correct status.
  • Keep light completions awaiting human review and restore the original saved review checkpoint through supported evidence recovery.
  • Route the exact application-incident cron request to authenticated intake; verify collector delivery and durable deduplication.
  • Verify the canonical limiter file before app-only activation and refuse missing or mismatched prepared edge bytes.
  • Refresh compatible dependency fixes and verify the owning runtime paths; retain two documented upstream advisory roots without published fixes.
  • Measure canonical board search and summary SQL through actual MCP and dashboard entrypoints; retain the baseline after rejecting a slower candidate.
  • Reuse installed search admission/cancellation and preserve original timing receipts. Post-activation incident closure and representative/cached live release timing remain pending.

v0.402.121

Reliable database requests and release recovery

  • Keep backups consistent while records change and stop database work when requests end.
  • Preserve search capacity across worker replacement with clear overload responses.
  • Group private failure evidence and show incident delivery, retry and recovery status.
  • Close cycles using verified combined pull request reviews while preserving task history.
Full detail
  • Encrypt a dump and inventory from one PostgreSQL snapshot; verify restores under concurrent writes.
  • Cancel owned database work on request timeout, disconnect and shutdown, while retaining shared pools and uncertain write outcomes.
  • Record bounded unexpected failure evidence across MCP, dashboard, proxy, edge and the independent collector; reject incomplete success envelopes.
  • Group private operational incidents, retain intake receipts, bound alert delivery and expose owner retry and verification actions. Repair the monitor's log-window gap.
  • Keep search admission in PostgreSQL across worker replacement, return expected capacity responses and retain same-request retry recovery evidence. Repair; post-deployment incident closure remains pending.
  • Accept a verified later combined-PR review during cycle closure without rewriting original evidence; recover read-only operator closure and owned changelog push retries. Verify prepared edge bytes and publication identity before activation. Keep database-backed planning and build listing from switching or publishing the server checkout. The representative and cached live release timing criteria remain open.

v0.402.120

Reliable release reviews and complete cycle history

  • Recognize approval of the final combined pull request while preserving task evidence.
  • Browse every cycle report with accurate totals and clear recovery when a page fails.
  • Archive exactly the confirmed task set and load history through database selection.
  • Bound concurrent searches with clear overload responses and simplify release cache ownership.
Full detail
  • Accept a genuine first verdict on the verified final integration head while preserving original build receipts, first verdicts and same-PR source checks.
  • Select archive matches, cycle snapshots, history frames, decision trails, score context, lineage and timeline summaries in PostgreSQL; remove replaced browser selectors and preserve atomic archive confirmation. This is bounded repair, not a whole-application closure claim.
  • Page every cycle report with exact database totals, stable tied ordering and visible later-page failures with Retry.
  • Coalesce first-connect telemetry and bound search admission per caller/worker with actionable overload responses; measure captured searches over 3,913 heavy tasks through real MCP/edge entrypoints. Production incident closure still requires bounded post-deployment proof.
  • Remove redundant hosted cache saves and bound the disposable dashboard compiler lifetime between HTTP suites before serial MCP qualification. Preserve the unfinished actual activation and cached-repeat timing criteria.

v0.402.119

Database selection and release recovery

  • Search and page documents with database counts while preserving private body access.
  • Refresh phase and roadmap totals from the database when tasks change.
  • Select caller-owned scores and completed public work before transfer.
  • Recover release evidence and validate warm dependencies without changing workspace bindings.
Full detail
  • Select documents and phase pages, ordering, facets and roadmap counts in PostgreSQL; preserve deep links, body permissions and SQL refetch after task changes.
  • Aggregate admin retention and caller-owned latest scores in PostgreSQL; publish completed work from the canonical owner cycle and read the actual public schema.
  • Validate exact warm dependency trees before checking cold installation capacity; preserve the active tree on recovery refusal.
  • Verify an explicitly authorized exact-source release without adding or changing a workspace binding.
  • Read original restored build evidence through the existing release and history paths without creating new implementation or attribution evidence.
  • Retain the genuine cached merge-to-live measurement as pending source review and production activation.

v0.402.118

CRM queries and release completion

  • Search, sort and page CRM contacts with database counts and linked account details.
  • Resolve exact contact matches when adding tasks, including records beyond the current page.
  • Preserve accepted release history and use the pinned package manager throughout packaging.
  • Measure packaging and production transfer separately while retaining release verification and rollback.
Full detail
  • Select CRM contacts, counts, facets, account members, linked tasks and exact picker matches in PostgreSQL before pagination; preserve authenticated project isolation and contact writes.
  • Reuse accepted historical squash receipts for cycle closure and safely retry an owned changelog push.
  • Resolve and verify pinned npm for builds, nested scripts, packaging and artifact provenance.
  • Refuse unsupported private Podman networking before startup and clean up only owned disposable resources.
  • Restore existing shipped migration-runner evidence without rebuilding or changing the original source.
  • Record exact-artifact packaging and production-transfer durations; retain the genuine second warm-cache release measurement as pending human review and activation.
  • Keep disposable qualification requests alive through the bounded development profile without automatic memory restarts.
  • Clear completed query deadline timers; broader worker retirement and load qualification remain open.
  • Prevent unused background timers from retaining dashboard clients.

v0.402.117

Query qualification and bounded Linux builds

  • Verify database query costs against the previous release on small and mature projects.
  • Preserve unknown outcomes after truncated dependency write responses.
  • Recover historical source evidence from a fresh operator checkout.
  • Use bounded swap and private test ports on shared builders while retaining host RAM headroom.
Full detail
  • Qualify dependency writes against a mature project and a truncated committed-write response without replay.
  • Compare project-scoped action-chain joins at limits 1, 6 and 100.
  • Retain filtered history, pagination and projection evidence against the previous release.
  • Compare prompt counter costs on small and mature projects.
  • Fetch the immutable reviewed PR head before historical source comparison in a fresh operator checkout.
  • Verify that a missing edge compiler stops qualification before expensive compilation.
  • Fit disposable migration CPU allocation to daemon capacity, retain bounded diagnostics and clean up owned resources.
  • Bound artifact coordinator memory and allow a 3 GiB RAM / 1 GiB swap compiler profile within the same 4 GiB total and 2 GiB host RAM reserve; genuine cached merge-to-live timing remains pending.
  • Bind disposable qualification API/database ports to loopback and verify the owned network profile before testing.

v0.402.116

Database-owned queries and release recovery

  • Validate dependencies atomically and page filtered history in PostgreSQL.
  • Read scoped action chains and prompt counters without board hydration.
  • Avoid oversized browser cache entries and read public accuracy at runtime.
  • Recover historical release bookkeeping from immutable installation proof.
Full detail
  • Validate and save dependency edges atomically within a bounded affected graph in PostgreSQL.
  • Apply typed build/review filters, projections and stable pagination in PostgreSQL.
  • Resolve action-chain task titles/statuses with one project-scoped join.
  • Read prompt counters with one caller-scoped counts operation.
  • Preserve normal private caching and avoid oversized browser cache entries.
  • Read public planning accuracy at runtime with honest unavailable data.
  • Reconcile a previously installed historical version against its original immutable proof without reopening its cycle.
  • Verify persistent CI cache write access and retain final health failures; real cached-repeat activation evidence remains pending.

v0.402.115

Reviewed integration and leaner qualification

  • Accept reviewed integrated source while preserving original task verdicts.
  • Remove duplicate checks and unused setup while retaining distinct coverage.
  • Group unchanged browser state and synchronize races without sleeps.
Full detail
  • Preserve original task verdicts and accept explicitly reviewed final integrated PR source through the existing release command.
  • Remove four proven duplicate checks while retaining each distinct contract.
  • Separate unused filesystem fixtures, restore review-test isolation and avoid unnecessary module reloads.
  • Keep named browser assertions while avoiding six repeated unchanged-state page loads.
  • Synchronize confirmation races explicitly and check the real timer against a controlled clock.
  • Retain the existing release timing path; real representative and cached-repeat installation measurements remain pending human review and activation.
  • Changelog

v0.402.114

Reliable setup and exact planning writes

  • Check capacity before dependency installation and verify complete test cleanup.
  • Save exactly the previewed handoffs and protect task ownership during cycle changes.
  • Report verified startup identity and recommend only newer stable versions.
  • Clear production dependency advisories and record the remaining development mitigation.
Full detail
  • **** Preview only the handoffs that will actually be saved, retain existing handoffs, and reject stale evidence before any plan write.
  • **** Check dependency, cache and staging capacity before installation; preserve partial-install diagnostics and enforce exclusive ownership.
  • **** Use supported Podman teardown and verify that every owned disposable resource is removed.
  • **** Bound the unpatched development lint advisory through the actual configuration, preserving honest audit reporting.
  • **** Update the affected address-library chain to ip-address 10.7.3; the production dependency audit reports zero advisories.
  • **** Recommend only newer stable MCP versions, preventing downgrade prompts.
  • **** Report verified project identity at startup without changing workspace bindings or showing false setup guidance.
  • **** Honour explicit Podman selection on every supported platform and validate the existing local API connection.
  • **** Save structured planning handoffs as JSON objects rather than double-encoded strings.
  • **** Recheck task ownership inside append transactions and assign unclaimed appended work to its cycle owner.
  • **** Bind native cycle rosters as UUID arrays, preserving membership and unchanged retries.
  • **** Record bounded browser exception locations and surface preference JavaScript failures before hydration timeouts. The original isolated syntax event's cause remains unconfirmed.
  • **** Remove the false warning that a missing default project ID makes every dashboard query unscoped; retain request-level project guards and genuine configuration errors.
  • **** Count build completion progress through the database's caller-owned cycle summary, excluding another member's same-numbered cycle.
  • **** Show report notes, preview links and screenshots without falsely claiming non-UI work changed a dashboard page.
  • **** Run the hosted server-version guard after its changed-file classifier so the existing conditional actually receives its input.
  • **** Stage dependency-failure qualification on supported build storage and preserve child diagnostics when preflight prevents installation.
  • **** Apply caller, cycle and selection filters before board-summary aggregates, matching the full view and counting inactive statuses only when requested.

v0.402.113

Include approved live qualification corrections

  • Verify approved installation corrections alongside earlier completed work.
  • Preserve unfinished live checks and require explicit source and file coverage.
Full detail
  • ** / ** Include explicitly reported paths from validated, approved Partial builds in the canonical historical implementation proof. Preserve the existing merged-source checks, pending live criteria and open cycle.
  • Combine path coverage only for the same exact reviewed source head; missing coverage or invalid approval remains a release blocker.

v0.402.112

Preserve publication proof through MCP

  • Deliver canonical release evidence to the installer through the supported MCP result contract.
  • Include the bounded Linux build and live qualification improvements.
Full detail
  • ** / ** Return publication proof and qualification metadata through the canonical MCP structured result contract, so the workspace installer receives the same validation evidence without parsing display text.
  • Includes the bounded Linux build and open-cycle qualification corrections prepared in v0.402.111.