FeatureParity
HomeDocsPricingHow it worksSign inStart free

Docs · fp CLI

fp changelog

What changed in each release of the fp CLI, newest first. Run fp update to install the latest; updating fp covers what to refresh afterwards.

0.0.38 (2026-11-18)

  • A requirement an open proposal demoted has one name in every command: awaiting review (Fizzy #2043). fp show prints Status: awaiting review (modification proposed) and says it is still enforced. fp list shows it with that status among the active requirements and leaves it out of --status draft. fp coverage names it under the drafts table, and fp coverage --all gives its row the same status. Before, fp show said draft, fp list said "No requirements found (active)" and then named it in a footnote, fp coverage said only "No draft requirements", and fp matrix marked it with ✎. In --json the stored status is unchanged; fp list --json and fp show --json carry under_review, and fp coverage --json adds awaiting_review.
  • A never-approved draft with a proposal against it is no longer described as "still enforced by the gate" by fp list. It reads draft (modification proposed).
  • fp matrix --csv writes <slug> (awaiting review) for such a row. It wrote <slug> (under review); a script that matched that suffix needs the new one.
  • The fp list --gaps footer prints the ✎ once. It printed it twice.
  • Server side, shipped with this release: surfaces come back in the showroom's order (placed surfaces first, then alphabetically by name), so fp matrix and fp coverage columns and fp surfaces all agree. They used to follow the order of an unsorted database read. Requirement listings carry under_review, decided by the same rule as the gate.

0.0.37 (2026-11-17)

  • The changelog is published at https://featureparity.dev/changelog (Fizzy #2044). Every release in this file is on that page, newest first, and the site's llms.txt lists it. /docs/changelog leads there too. Before, both addresses were a 404 and no public page said what changed.
  • fp update names the changelog (Fizzy #2044). After it installs a newer fp, and with --check when one exists, it prints What changed: https://featureparity.dev/changelog; --json carries it as changelog_url.
  • The gem lists the changelog as its changelog_uri again, now that it points at a public page (Fizzy #2044). The old link went to the private repository and was removed in 0.0.33.
  • The CLI reference's "Updating fp" section and the docs' "Update the CLI" section link to the changelog.

0.0.36 (2026-11-17)

  • fp surfaces add <key> --from <source> carries over draft requirements as well as active ones (Fizzy #2040). On a project an agent had just onboarded, where every requirement is still a draft, it said "No requirements on 'api' to draft" and created the surface anyway. It now proposes the new surface through the same endpoint as fp surfaces batch-draft, parents before their children, and names anything the server skipped.
  • fp surfaces add --from checks everything before it creates the surface (Fizzy #2040). An unknown source surface, a key that is already taken, or no requirement to carry over each exit 1 with nothing created. Before, an empty result left an empty surface behind.
  • fp surfaces add --from --evaluate on a project without AI access says so once, exits 1, and creates nothing (Fizzy #2040). Before, it created the surface, printed the paid-plan message once per requirement, and exited 0. The evaluation now runs before the surface is created. The help text no longer names the model behind it.
  • fp report and fp run read --repo from the checkout's git origin remote when it isn't given (Fizzy #2040). fp run settles the repo before it starts the test command, so a checkout with no origin remote and no --repo is refused in a second. Before, the whole suite ran and then the report failed with "--repo is required".
  • fp mark warns when no requirement has the slug (Fizzy #2040). In a checkout whose .featureparity.yml names the project, with a key configured, a slug that matches no requirement gets a warning on stderr that the marker binds nothing yet. The marker is still written, because marking before fp propose is fine. With no key or no network, fp says nothing.
  • fp list --gaps on a project with no approved requirement says there is nothing to measure yet and points to fp list --status draft --gaps and fp coverage, and an empty fp matrix points to fp coverage (Fizzy #2040). Before, "No gaps found" read as "nothing left to test" on a project full of untested drafts.
  • fp doctor shows the project named in .featureparity.yml instead of suggesting a slug from the directory name (Fizzy #2040).
  • The skill has an "Add a platform" section, and the CLI reference says fp update exists from fp 0.0.34 (it said 0.0.35).
  • Server side, shipped with this release: proposing a new required surface no longer marks a requirement's existing tests suspect, and the gate doesn't ask for tests on the new surface until a human approves it. Before, fp surfaces add tablet --from web turned every passing, failing and stub cell on the affected requirements suspect and added a missing violation per requirement.

0.0.35 (2026-11-16)

  • fp matrix and fp coverage show every surface by default (Fizzy #2008). The surface pinned in .featureparity.yml no longer narrows them; pass --surface to narrow. fp check still gates the pinned surface.
  • fp surfaces add <key> --from <source> creates a surface and drafts requirements from an existing surface (Fizzy #2009). When you add a new platform (like Android when you already have web), --from web finds every active requirement that names web, proposes adding the new surface to each, and returns a gap list. The drafts await human review — an agent can't approve its own surface additions — and the gap list tells the agent which requirements need test coverage on the new surface. This is the "add a platform" workflow: create the surface, see what applies, write the tests.
  • fp surfaces add <key> --from <source> --evaluate runs each candidate requirement through Jev to determine if it applies to the new platform (Fizzy #2009). Instead of mass-drafting everything, --evaluate asks the AI "Does this web requirement apply to android?" for each requirement, returning applicability verdicts with reasoning. The agent sees which requirements apply (✅), which don't (❌), and why — then makes the final call on what to draft. Nothing is drafted automatically; the evaluation data lets an agent filter the 10% that are platform-specific (browser resize, web-only APIs) from the 90% that transfer to any client. Requires a Pro plan or a project whose owner has AI access.
  • fp surfaces batch-draft <key> --slugs slug1,slug2 or --slugs-file applying.json drafts multiple requirements for a surface in one request (Fizzy #2009). This is the second half of the agent workflow: run fp surfaces add android --from web --evaluate -f json > /tmp/eval.json, filter the JSON to requirements where applies: true, and send the slugs to batch-draft. The endpoint skips requirements that already include the surface, have a pending change, or are archived, and reports what it drafted, skipped, and failed. The --slugs-file accepts the --evaluate output format (array of objects with slug) or a plain array of strings.

0.0.34 (2026-11-13)

  • fp update installs the newest fp (Fizzy #1993). It reads the latest version from the API's public version endpoint, so it needs no key, and installs the gem under the Ruby that is running fp. fp update --check only says whether a newer one exists. Afterwards it names fp skill install and fp init --force, which refresh a repo's agent skill and its AGENTS.md section. Before, there was no update command and gem update featureparity was mentioned once, in the changed-test upgrade notes.
  • fp says when a newer version is published (Fizzy #1993). fp doctor shows the newest version and, when the installed one is behind, the command that installs it. At most once a day, any other command that finds a newer version prints one line on stderr after its own output. The line never appears with --json, when CI is set, or with FP_NO_UPDATE_CHECK=1. The lookup is one unauthenticated request with a 2-second limit, and a failed one is silent.
  • The CLI reference has an "Updating fp" section.

0.0.33 (2026-11-13)

  • fp mark allows for the markers it added itself (Fizzy #1991). Marking three tests in three calls, top to bottom, with line numbers from one read of the file, put the second and third markers above the wrong lines, because each insert pushes the lines below it down. fp now remembers the marker lines it inserted into a file for 30 minutes. While nothing else has edited that file, a line number that no longer points at a test is also read as it was numbered before those markers went in, and when exactly one reading lands on a test, that test is marked and fp says the line moved. If the number could mean two tests, fp names both as <file>::<test name> and writes nothing. A number that points at a test as the file stands is used as given.
  • fp init and fp init --detect recognise pytest from the test files alone (Fizzy #1991). A repo with tests/test_*.py and no pyproject.toml, requirements.txt or pytest.ini got "No test runner recognised" and the Ruby marker example. Files named test_*.py or *_test.py in the root, tests/ or test/ that define a def test_ or import pytest now count.
  • The AGENTS.md section from fp init gives the report shortcut for the repo's detected runner (Fizzy #1991): a pytest repo reads fp run ... -- pytest and the pytest JUnit command instead of a note about RSpec's JSON report. The onboarding text no longer says fp doctor checks "the repo's Ruby".
  • fp skill install installs the agent skill that ships inside the gem (Fizzy #1984). The docs sent agents to npx skills add stowzilla/feature_parity --skill fp, which 404s because that repository is private. It copies skills/fp into .claude/skills/fp (Claude Code) and .agents/skills/fp (Codex, Cursor, Gemini CLI and the other agents that read the shared location) in the working directory; --agent claude|agents picks one, --dir another repo, --global your home directory, --path any skills directory. It needs no network or key, and re-running after a gem upgrade refreshes the copy. It won't replace a directory named fp that isn't the fp skill without --force. fp skill path prints where the bundled skill lives.
  • The gem no longer lists source_code_uri and changelog_uri, which pointed at the private repository and 404'd (Fizzy #1984). It lists the docs at featureparity.dev/docs instead.
  • fp mark takes a test by name, <file>::<test name>, and several targets in one call (Fizzy #1987). An agent that read a file once and marked three of its tests by line number put the later markers on the wrong lines, because each insert pushes the lines below it down. A name is found in the file as it is when the command runs (a pytest id like file.py::TestClass::test_x[case] works too); a name that isn't there, or that two tests share, is refused with the file's test names. Line numbers given in one call all refer to the file before that call, every target is checked before anything is written, and --json answers several targets with { "marks": [...] }.
  • fp whoami says who the key acts as (Fizzy #1989): an Acting as line names the agent key and the person who owns it, from a new GET /whoami. If the API can't be reached or the key is bad, the line says so and the local config still prints.

0.0.32 (2026-11-13)

  • A base API URL that ends in /api works (Fizzy #1980). The site hands people https://api.featureparity.dev/api (and the same with a preview environment's host), and fp then asked for /api/api/projects. fp now drops trailing slashes and one trailing /api segment wherever the URL comes from (--api-url, FP_API_URL, a profile or the global setting), so fp whoami shows the host and every command reaches the right path. Any other path is left alone.
  • fp tutorial no longer asks for an API key (Fizzy #1980). It writes the sample repo and makes no API calls, but a first-time user with no key yet was stopped before it started.
  • fp --help and fp -h print the help, like fp help, instead of "Unknown command: --help" (Fizzy #1980).
  • fp help --json (and fp --json help) prints a machine-readable index in the usual envelope: the fp version and every command with its summary and usage (Fizzy #1980). Before, it printed the prose page. Without --json the output is unchanged.
  • fp init --force says "refreshed FeatureParity section" when it replaced an existing section in AGENTS.md, and keeps "appended" for a section it really added (Fizzy #1980). Before, both were reported as appended.
  • fp show prints a requirement's source type and context in the Source Trail when it has them but no URL (Fizzy #1980). Before, it said "no sources recorded" for a requirement whose JSON carried both.
  • The AGENTS.md section from fp init leads its marker example with the language of the repo's detected test runner (Fizzy #1980): def test_... under a # fp:slug comment for pytest, it(...) under // fp:slug for jest, vitest and Playwright. Any other repo still gets the Ruby/RSpec example. A pytest repo was shown RSpec first.
  • Help examples, the skill and its CLI reference use the project slug acme instead of the company's own (Fizzy #1980).
  • fp mark's help and the skill's CLI reference now say that each insert shifts the lines below it by one, so a file's tests should be marked from the bottom up (or line numbers re-read between marks), and that the It binds to: line is the check (Fizzy #1980).

0.0.31 (2026-11-11)

  • fp propose-change <slug> --tags a,b proposes new tags for an existing requirement (Fizzy #1960). Before, tags could only be set by fp propose when a requirement was created, so a missing tag meant retiring the requirement and proposing the same promise again. The proposal replaces the whole list in the order given (--tags "" clears it) and is reviewed like any other field. Order counts: units,rules → rules,units is a change, and rejecting or withdrawing puts back the original tags in their original order. fp history and the web Change History show the tag diff.

0.0.30 (2026-11-05)

  • fp ci-report --local records a suite's real results without CI (Fizzy #1837). A team out of CI minutes, or with no pipeline yet, runs the suite on a laptop and reports it the way CI would, with --local in place of --ci-url. The verdict is recorded against HEAD, so --local refuses a working tree with uncommitted tracked changes, and the receipt shows the commit with no "View Run" link. Everything else is the same ingest, including --pr for a branch. It's for a person standing in for CI; agents still report with fp report.

0.0.29 (2026-11-02)

  • The skill and the AGENTS.md section fp init writes now explain optional visual evidence (Fizzy #1786). A UI test's recorded screenshots and videos can be attached with fp report --junit ... --attach-media (Playwright) or fp attach <slug> <file> --surface <surface> --example-title "<test name>". Agents are told this is optional, needs permission from the person they work for because the files are stored in FeatureParity, and must never capture someone's own screen. Only what an automated test drove can be attached. references/cli.md now documents fp attach and fp attachments.
  • fp propose --dry-run validates and lints a requirement without writing it (Fizzy #1786). It checks for a title that names the work instead of the promise, commentary openings, filler, a missing why or acceptance, no Example:, several sentences of rule, and a number nobody may have decided. It also checks the catalog for a slug that's taken or a parent that's missing. Notes are advice; catalog problems exit 1. A normal fp propose prints the same notes on stderr and still creates the draft.
  • fp propose --file reqs.yml proposes a batch from YAML or JSON. Every entry is checked first (unknown fields, category, source type, duplicate or existing slugs, parents), and if anything is wrong nothing is created. Parents named within the file are created before their children, and the result is one table. Flags and a defaults: block apply to every entry. Before, a 23-draft onboarding was 23 hand-quoted fp propose calls.
  • fp mark <slug> <file>:<line> inserts the marker above the test in the file's own comment syntax and indentation, then names the test it binds to. Running it twice is harmless, and it needs no API key.
  • --source-ref path:line (repeatable) on fp propose and fp propose-change records the places in the repository a requirement was read from. They are stored on the requirement, shown in its source trail on the web and in fp show, and accepted as source_refs in a --file entry.
  • fp doctor checks whether fp will work here, with no API key (Fizzy #1786). It shows the Ruby running fp, the gem's version and path, and whether the directory pins a different Ruby in .ruby-version, .tool-versions or mise.toml. When it does, doctor prints the fix: install the gem under the pinned Ruby, or put the running Ruby's bin directory first on PATH. A repo pinned to Ruby 3.4.12 with fp installed only under 3.4.9 failed with mise ERROR No version is set for shim: fp and worked from /tmp. The shim fails before fp starts, so the skill and the generated AGENTS.md section now describe that case for the agent that hits it. Doctor also shows the API environment (warning off production), whether a key is set, which .featureparity.yml applies, which fp wrote the AGENTS.md section, and a summary of the repo.
  • fp init --detect suggests a project slug, surfaces and test commands without writing anything (--json too). It reads the Gemfile, package.json, Podfile and Xcode projects, Android manifests, Python manifests, Rails routes and config/database.yml, and docker-compose, in the root and one directory down. For each test runner (rspec, minitest, jest, vitest, playwright, pytest, xctest, gradle) it gives the command that writes a report fp reads and the dependency to add, or says none is needed. It says whether the tests need a database server and whether there's a .devcontainer, and prints the rubric for surfaces: somewhere a user interacts with the product, so an internal API with no separate client isn't one. A plain fp init prints the detected test command and the database note at the end, and when the tests need a database the generated workflow's report recipe gets a TODO and a commented-out service. Init now also says outright that committing the workflow before the FP_API_KEY secret exists is fine, because the gate skips with an explanation.
  • fp report --junit, fp ci-report and fp check --junit accept RSpec's own --format json report, recognised by its content, so an RSpec suite can report without rspec_junit_formatter in the Gemfile. Passed examples are present, pending ones are stubs, and failed ones are failing for CI.
  • fp run [report flags] -- <test command> runs rspec, pytest, vitest or playwright with a report formatter fp adds itself, then reports exactly as fp report --junit would. If the tests failed, it reports first and then exits with the test command's status. Any other runner gets an error naming the supported ones and pointing at fp report --junit. Global flags after -- now belong to the command after it, so fp run -- pytest -p no:cacheprovider keeps its -p.
  • pytest's JUnit lines (junit_family=xunit1, the only family that records a test's file) count from 0, and fp now reads them that way. Before, a test directly under its fp: marker bound to the marker above that one.
  • The AGENTS.md section fp init writes opens with the fp version that wrote it, adds an Onboarding a repo first-run path (create the project, pick surfaces by the rubric, propose drafts, mark tests, report, fp coverage, fp question) and a Troubleshooting list, and points first-run agents at the onboarding path instead of the per-task loop. Its modeling, requirement-writing, onboarding and troubleshooting text now comes from the bundled skill's SKILL.md, the one source, between fp-shared comments. The two copies had drifted, and an agent with both read the same guidance twice. The skill says so at the top. fp init --force refreshes an existing section.
  • fp report --junit accounts for every bound test (Fizzy #1786). The summary opens with N bound test(s) → M receipt(s), and when several tests feed one receipt (the server keeps one per requirement, surface and test type) it lists each of them, with its line and whether it was skipped, under that receipt. Before, three tests proving one requirement printed as one line and the other two looked dropped. --json carries each receipt's tests and the run's tests_bound.
  • fp projects create, fp propose, fp propose-change and fp report print a one-line warning on stderr before writing when the resolved API isn't production, naming the environment, URL and profile. A leftover FP_PROFILE or FP_API_URL used to put a new project on a dev environment with nothing to say so. The command still runs, and --json output is unchanged.
  • fp question <slug> "<question>" attaches an open question for a human to the draft it concerns, and fp questions <slug> lists them with their answers (--open for only the unanswered ones). An agent proposing a batch of drafts used to hand its questions back in the chat, cut off from the drafts, and the person reviewing a draft never saw them. Now Quick Review shows a draft's open questions on its card, where the reviewer answers or dismisses each one, and fp show lists the open ones. Agents can ask but not answer. Draft and active requirements take questions (Fizzy #1786).
  • --source-type repo_scan records that an agent derived a requirement from reading the code, for fp propose, fp propose-change and fp comment. ai_chat was the nearest fit, and it misstated where the promise came from.
  • fp coverage shows which draft requirements have evidence on which surfaces, and ends with the drafts that have none (Fizzy #1786). The gate measures only active requirements, so on a freshly onboarded project, where everything is still a draft, fp check said "Nothing to enforce yet" and fp list --gaps said "No gaps found", and the agent that marked the tests had no way to confirm its work. --all adds the measured rows, --surface narrows it, --json carries drafts and untested. fp list --status draft --gaps now lists drafts lacking evidence instead of ignoring the draft filter, and fp check --include-drafts prints the same table after the verdict. Drafts are reported, never gated: none of this changes an exit code.

0.0.28 (2026-11-02)

  • fp spot-check [<slug>] spot-checks your evidence, like a random drug test (Fizzy #1787). It picks an active requirement with evidence at random (--seed repeats a pick, --surface narrows it), prints the acceptance next to the source of every fp:<slug> test in the checkout, and gives the agent a four-step brief: list what the acceptance promises, match each clause to an assertion, break the product code to confirm a test fails, then revert. --json gives an agent on a schedule the same thing. Instead of one at random you can name several (fp spot-check a b), pick --count N at random, check --all of them, or start from a test with --test <file>[:<line>] (repeatable): every marked test in that file, or just the one spanning that line, along with the requirements they're bound to. --prompt prints the spot check as instructions to hand an agent (fp spot-check --count 3 --prompt | claude -p), ending with what to report for each requirement: a verdict, the unasserted clauses, the probe made, and a clean git status. --jev asks Jev, before the agent starts, whether each requirement's tests appear to cover its acceptance, how likely each test is to check the promise, and which gap is likeliest (an unasserted clause, an assertion that can't fail, a test of a mock...). It's a hint for where to aim the probe, not a verdict. Jev is for paid plans: a person on Pro or Lifetime, or a project whose owner is, which is what lets an agent use it. Without one the spot check says so and carries on. It's read-only. A test that stays green under the probe goes to a human, and the command never rewrites a test or requirement.
  • fp tutorial writes Hexhaven, a pocket-sized sample repository for the web app's Tutorial (Fizzy #1446). Its tests run on Ruby alone, two rules are already bound by fp: markers, and the tallest-tower test is left for you to mark and fp report, which turns that Server cell in your sample matrix from missing to present. Makes no API calls and never writes over an existing directory (--dir picks another place).
  • When the API address answers with a web page instead of the API (FPAPIURL pointed at the site, say), every command now says so and suggests the API host, instead of crashing with undefined method '[]' for nil.
  • fp projects coming back empty while the active profile's key was made for another environment says that a key only works where it was minted, instead of suggesting you create a project. fp whoami's environment warning says the same, and so does a "project not found".
  • fp report --junit run from outside the checkout (fp report --junit hexhaven/junit.xml) reads the project from the report's own .featureparity.yml and, when nothing resolves from the working directory, finds the test files beside the report.
  • fp tutorial writes an AGENTS.md into Hexhaven: a short note about the sample, followed by exactly the FeatureParity section fp init writes (the same code produces both), so asking an agent to bind a test works there. fp tutorial --restart deals a fresh Hexhaven over an existing one, and only over a Hexhaven checkout.
  • fp comments <slug> reads the team's comments on a requirement and lists who can be tagged; fp comments <slug> --body "..." --tag who,... posts one (Fizzy #1494). --tag takes a teammate's email or name, or one of the team's agents by name or key name. Tagged people get an email with a link to the requirement; each tagged agent fires the project's requirement.agent_mentioned webhook, so whatever runs that agent can start it on the requirement. Not to be confused with fp comment, which threads a comment onto an open change proposal and is unchanged.
  • fp history prints the text of comments and who they tagged, instead of a bare "commented".
  • fp propose prints the new draft's quality feedback (verdict, issues, suggestions) in the same run, and --json carries it as analysis. When analysis is unavailable the draft is still created and the output says the feedback couldn't be produced.

0.0.27 (2026-11-02)

  • Publishes the refreshed requirement-writing guidance that shipped in #248. No new commands, flags, or behaviour — the embedded prose in fp help, fp init's generated AGENTS.md section, and the bundled fp agent skill now read naturally and teach the decision-ready title/why/acceptance style. Cutting a release pushes a gem so gem update featureparity and fp init --force hand agents the current text, rather than it living only on the repo's master until the next functional change.

0.0.26 (2026-10-27)

  • A pull request's CI no longer turns the matrix red, and no longer rewrites the merged run's receipt (Fizzy #1631). fp ci-report --pr records what the branch said as the row's branch verdict — status, PR, run, commit — beside the default branch's verdict, which stays the cell's state and the receipt a reader sees. The only state a PR may still add is provisional: a green test on a cell the default branch's CI has never judged is pr_passing, as before; a red run withdraws one. A red test on an open PR used to write failing over the merged passing for everyone, with the PR's run, commit and card in place of the merged run's — so a requirement nobody had touched looked broken on master, and "View Card" led to whichever card last ran the suite. The matrix now shows a corner mark and names the PR in the cell's hint; the requirement page shows the PR's verdict under the merged receipt; fp show prints On PR: failing <url> (not merged). The PR itself is still judged by fp check --junit --pr, exactly as before.
  • fp report --junit puts --pr and --work-item only on the tests in files this branch changed — the commits since it left the default branch, plus anything uncommitted — and says how many receipts got them. A suite run covers every marker in the repo, and stamping the card on all of them rewrote the work item on every requirement the branch never touched. On the default branch the HEAD commit's files count as the change; without git, every receipt is stamped as before, with a note. --stamp-all restores the old behaviour. --sha still applies to every receipt: it is where the run was observed, not what prompted it.
  • fp ci-report sends the checkout commit (--sha, or git rev-parse HEAD) at the top level too, so the evidence — or a PR run's branch verdict — links the exact revision the suite ran at. Before, the receipt's commit was whatever an agent's fp report --sha last left on it.

0.0.25 (2026-10-22)

  • fp check --junit <report> --pr [url] asks the pull-request question — "does this change make parity worse?" — instead of the standing one. The server judges the run against what the default branch has recorded and fails only on what the run introduced: a bound test gone red, a bound test that vanished, or a non-green test added where there was none. Everything the default branch already owed (an unapproved removal proposal's suspect, a missing cell nobody has written a test for, a present marker CI has never run) is listed as "already on the default branch" and not counted. Previously a PR was asked whether the whole project was in parity, so on a strict project every PR failed with master's own standing violations — none of which it touched — and a reviewer couldn't tell from the gate whether a PR was safe to merge. Without --pr, fp check --junit still gives the standing verdict, which is what a push to the default branch should gate on: it stays red until a human approves or rejects the pending proposals, and that is where that signal belongs. --pr needs --junit; a server that predates it is reported rather than silently answering the other question.
  • fp check --pr also tells an agent what its branch did: a "cells this change fixed" table (violating on the default branch, green with the run applied) and a "results bound to draft requirements" table for tests whose requirement a human hasn't activated yet, so a branch that proposed a requirement and wrote its test isn't met with silence. Both are in --json as improvements and unmeasured.
  • Every violation fp check prints now ends with Next steps, grouped by who acts: "An agent can fix" (write_test, fix_test, replace_stub, run_in_ci, reverify) and "Waiting on a human" (await_review for a suspect cell under an open proposal, await_merge for pr_passing), each with a one-line hint. The server names the action and owner on each violation in --json, so an agent asked to bring the default branch up to parity can take the agent rows and leave the rest.
  • A pull request's CI no longer loses the default branch's verdict. Evidence keeps merged_status (what the default branch last recorded) next to status; a default-branch run or an agent's fp report writes both, a PR run writes only status. The PR gate judges cells a PR's CI has written against merged_status, so a test the branch skips or turns red where master passes is a regression even though the PR's own fp ci-report --pr ran first. fp show prints Merged: when the two differ.
  • fp ci-report sends the fp markers that bind to no requirement (slug, surface, file, line). A default-branch run records them per surface, replace-on-run, like loose ends; a PR run never does. fp check --pr then lists an orphan the default branch already has as "already on the default branch" and doesn't fail the PR for it — a slug rename that left markers behind no longer fails every open PR. The matrix shows the recorded markers in their own panel.
  • A bound test that goes missing from a run is now also flagged when its evidence is suspect — unless the requirement has an open removal proposal. Proposing a change marks the evidence suspect, so deleting the test and proposing any change at all used to turn a red cell into one that doesn't fail below strict. A modification asks for the test to be rewritten, not removed; only a removal proposal excuses the test's absence, and only until a human decides. Applies to both fp ci-report (recorded as failing) and fp check --junit.

0.0.24 (2026-10-21)

  • fp showroom media add <image> --surface <key> --icon sets the surface's own icon in the client showroom, replacing the built-in logo for its kind (the Android robot, the Apple logo, a globe for web). A surface has one icon, so adding another replaces the first, and fp showroom media remove <id> puts the built-in logo back. An icon must be a png, jpg/jpeg, gif or webp of up to 5 MB, on a surface, with no --caption or --position. Anything else is refused before anything is sent. fp showroom media shows the surface's icon with icon in the position column.

0.0.23 (2026-10-21)

  • fp showroom media manages the screenshots and videos on the client showroom — on a surface's card, or in the project gallery under the welcome note — so the agent that recorded a run can show a client the product without them opening the demo. fp showroom media lists the gallery and then each surface's media in the order a client sees them (id, kind, filename, caption, position). fp showroom media add <file> [--surface <key>] [--caption "..."] [--position N] uploads one (no --surface means the gallery); png, jpg/jpeg, gif, webp, mp4, webm, and mov up to 100 MB are accepted, and anything else — SVG and PDF included — is refused with the reason before anything is sent, as is a position that isn't a whole number of 1 or more. fp showroom media edit <id> [--caption "..."] [--position N] changes the caption or order — positions run 1..n within a card or the gallery, so --position N takes slot N and shifts the others; an empty caption clears it and an empty position moves the item to the end, and fp showroom media remove <id> takes one down, asking you to type the filename back in a terminal and refusing non-interactively without --yes.
  • fp showroom prints the gallery and each card's media (counts and captions), and a surface with media but no link or instructions is now shown, not listed as hidden.
  • fp surfaces edit <key> --showroom-position N sets where the surface sits in the client showroom (1 is first; the showroom opens on the first). Surfaces with no position follow the placed ones alphabetically, which is the whole order until someone picks one. Pass an empty value to clear it; anything but a whole number of 1 or more is refused before anything is sent. fp surfaces show/edit print the position, and fp showroom lists cards in the order a client sees them.

0.0.22 (2026-10-21)

  • fp <command> --help (and -h, and fp help <command>) now prints that command's usage, its flags, and the global flags instead of running the command. Previously a command's flags were only discoverable by reading the gem's source — there was no per-command help, so fp report --help just ran fp report and failed validation. Help needs no API key and never trips required-flag validation, so you can discover a command's flags before you can run it.
  • fp --version and fp -v now print the installed version, as aliases for fp version. Previously a bare version flag reported Unknown command: --version.
  • fp <command> --help --json emits the command's flag schema (name, description, required-ness, usage, and examples) as JSON, so agents and the Agent Skills package can read a command's real flags straight from the installed gem instead of scraping KNOWN_FLAGS.
  • fp report --junit now warns when two or more distinct test files in one run resolve to the same evidence cell (same slug, surface, and test type). Server-side, evidence identity is (slug, surface, repo, test_type) and does not include the file, so those reports share one row and the last one posted silently overwrites the others — exactly what happens when a unit suite and an e2e suite both land on the unspecified test type. The warning names the colliding slug/surface/type and the files, and points at the fix: give each kind of test its own test type (a :type marker suffix like fp:slug@api:e2e, or --test-type). fp help now documents --test-type on the --junit example.
  • fp report --junit and fp ci-report understand Playwright's JUnit reporter natively, so an unmodified report binds without a hand-rolled annotation script. Titles joined with › (Playwright) or :: (pytest-style ids) bind by name the same way > already did. When a report gives no file and its path-like classname is relative to the runner's testDir (Playwright writes loyalty.spec.js, not e2e/loyalty.spec.js), fp searches for the file — the testDir from a playwright.config.* under --base-dir, then common test directories (e2e/, tests/, test/, spec/), then a bounded unique-match glob — and prints which location it used.
  • fp report --junit --attach-media uploads the videos and screenshots a run recorded (Playwright's [[ATTACHMENT|…]] entries) as visual evidence, one per bound test, with the test's name set as the example title so each capture nests under the receipt it proves. Paths resolve against --base-dir; unknown requirements and unsupported or oversized files are skipped with a reason rather than aborting the batch.
  • fp report --junit warns when a bound testcase has an empty name — a receipt with no title is almost always an upstream reporter problem — naming the slug, surface, and file instead of filing nameless receipts silently.
  • fp propose-change <slug> --no-parent proposes un-nesting a child requirement back to the top level. It clears the parent (recorded as a parent change to none) and, like any proposal, drops the requirement to draft for a human to review. --parent and --no-parent can't be combined.
  • fp propose-change <slug> --withdraw takes back an open proposal you opened. The single-open-proposal rule means you can't open a second one to amend the first — so you withdraw it (restoring the requirement to exactly what it was, including its evidence binding) and propose again. Only the proposal's author can withdraw it; someone else's proposal still goes through review or a comment.
  • A change proposal's --source-type/--source-url/--source-context are recorded as the provenance of that proposal in the history and no longer overwrite the requirement's own origin fields. Previously, proposing a change citing a different card silently erased where the requirement first came from.
  • fp surfaces edit <key> takes --showroom-url, --showroom-label, and --showroom-instructions (or --showroom-instructions-file for anything longer than a line) to write the surface's card on the client showroom: the link a client opens, the button text, and how to sign in and try it. Pass an empty value to clear a field; a surface with neither a link nor instructions leaves the showroom. Links must be http(s), checked before anything is sent. fp surfaces show prints the card and says whether the surface is shown to clients.
  • fp projects edit <slug> takes --showroom-welcome / --showroom-welcome-file for the note at the top of the showroom.
  • fp showroom --project <slug> prints the showroom as a client will see it — welcome, each card, instructions with their line breaks — and then the surfaces that are not shown and why, so a card that dropped out is noticed. The share link is reported as unknown: only a person can see or change it.
  • The skill gains a "fill in the client showroom when a surface is deployed" step. Leaving feedback and managing the share link stay human-only.

0.0.21 (2026-10-20)

  • fp surfaces edit <key> changes an existing surface's name, kind, audience, repo, default branch, or key, sending only the flags you pass. Use it to fill in the kind and repo of surfaces that fp projects create --surfaces made with defaults.
  • fp surfaces delete <key> removes a surface. Like fp projects delete, it asks you to type the key back in a terminal and refuses non-interactively unless --yes is passed.
  • A surface key is now unique within a project. fp surfaces add on a key that already exists used to create a silent duplicate; the server now refuses it with a conflict, and the CLI points you at fp surfaces edit instead. Changing a surface's key to one another surface uses is refused the same way.
  • fp surfaces delete, and fp surfaces edit --key, are refused for a surface that any non-archived requirement still requires; the error names those requirements. Take the surface off them first.
  • fp history shows a member's request for changes (requests changes, with their note saying what to change). Members ask for changes in the web app when they'd neither approve a requirement as written nor reject it outright.
  • fp history shows each project member's own decision on a requirement (approves / rejects, with their note). Members record these in the web app on requirements that already have a status; a later decision from the same person replaces their earlier one, and both stay in the history. Agents can read decisions but can't record them.

0.0.20 (2026-10-17)

  • fp projects create <slug> --name "..." [--surfaces api,web] creates a project from the CLI, so an agent can onboard a repo FeatureParity has never seen without waiting on a human in the web app. The project is owned by the person who minted the key and counts against their plan allowance; the same key reaches it immediately. fp projects show, fp projects edit, and fp projects delete round out project management. Delete is guarded like gh repo delete: it asks you to type the slug back, refuses non-interactively without --yes, and the server only admits a project owner or a key minted by one.

0.0.19 (2026-10-17)

  • API keys are account-level. A key belongs to the person who minted it and works across every project they are a member of, including projects created later, so an agent is set up once rather than once per project. Mint keys under Account → Agents & API keys in the web app; project settings no longer manages keys. fp setup, fp projects, and the bundled skill docs reflect the change. Existing keys keep working with no re-minting.

0.0.18 (2026-10-16)

  • fp attach accepts PNG/JPEG/GIF/WebP screenshots and MP4/WebM/MOV recordings up to 100 MB, streams them directly to private S3, and records surface, capture time, observed deployment time/URL/commit, and test-run URL. Requirement detail renders safe raster images and videos inline with exact deployment recency; SVG and document attachments remain downloads.
  • fp analyze [<slug>] triages requirement quality — duplicates (naming the requirement they duplicate), fragments of a broader promise, vague wording, and possible conflicts — one requirement at a time, reusing cached results. It is read-only and never files proposals; the bundled skill explains how to turn findings into proposals a human picks.

0.0.17 (2026-10-13)

  • fp ci-report now sends one SHA-256 source receipt per bound testcase, using an isolated-test range when it can determine one reliably and an explicitly labelled whole-file fallback otherwise. FeatureParity preserves the accepted baseline, opens a changed-test audit finding for a different fingerprint without changing the CI outcome, and treats every test type uniformly.
  • fp changed-tests lists every unresolved finding with requirement, outcome, scope, accepted/candidate revisions, locations, and links. fp changed-tests assess records a plain-language still_proves, no_longer_proves, or uncertain assessment for an exact candidate fingerprint; stale candidates are rejected, only still-proves resolves the finding, and PR candidates advance the baseline only when the default branch reports the same digest.
  • Agent guidance now treats existing tests as protected product evidence: edits to passing proof must be called out, behavior-changing edits wait for human approval, FP-detected revisions are assessed against the requirement through the CLI, and a new draft or active requirement never authorizes changing a pre-existing failing test.
  • Existing hosted projects need no data or configuration migration. Upgrade CI to fp 0.0.17 or newer and run the existing fp ci-report on the default branch once to establish accepted source baselines lazily; add trusted PR reporting with --pr to discover later revisions before merge.

0.0.16 (2026-10-12)

  • fp changes --github-pr writes the linked requirement-change table into one managed section of a pull request's description, and --github-summary mirrors it into the job summary. It reads work-item URLs from the PR body, lists the requirement creations, edits, and modification/removal proposals tracing to them, and replaces its managed section on re-run rather than duplicating it. When GitHub can't be read or updated the step fails instead of silently dropping the table; when the PR links no work item, or the linked item has no activity, it says so explicitly.
  • Work-item URL detection is now source-agnostic. A heuristic recognises common ticket-tracker URLs (paths with /issues/, /cards/, /browse/, /tickets/, /pull/, /merge_requests/, /story/, etc., or ending in a numeric id), covering Fizzy, GitHub, GitLab, Jira, Linear, Shortcut, Azure DevOps, Trello, YouTrack, ClickUp, and Discord without configuration. For URLs it can't recognise (Notion, Asana, internal tools), an explicit fp-source: <url> marker anywhere in the PR body takes precedence.
  • The PR change table shows one row per requirement — its latest event, by title — so a requirement created and later changed under the same work item no longer appears as a duplicate.

0.0.15 (2026-10-09)

  • fp propose-change can propose corrections to a requirement's title (--name) and key (--slug) for human review. Existing evidence follows a proposed key and returns to the original key if the proposal is rejected; test markers still need to be updated in the affected repositories.
  • Expanded the bundled requirement-authoring guidance around evolving requirements, human ownership of value and priority, observed customer behaviour, outcome-oriented discovery, and examples/tests as checks on a general rule rather than substitutes for one.

0.0.14 (2026-09-21)

  • Reported test-file paths are now relative to the repository root instead of to the runner's working directory. A JUnit report names files relative to wherever the runner ran — vitest invoked in frontend/ reports src/pages/Matrix.test.jsx — and fp uploaded that verbatim, so the web app built a GitHub blob link from a path that does not exist in the repo and every web-surface evidence link was a 404. --base-dir still says where those paths resolve from; the path that gets reported is now translated against the repo root (found by walking up for .git, so worktrees work), falling back to the path as given when there is no repo to relativise against. Applies to both fp report --junit and fp ci-report.
  • fp ci-report now names the test behind each verdict, and names the failing one when a requirement's cell goes red. Evidence is keyed by slug + surface, so a row outlives any single test; because CI never sent a title, a failing row kept whatever name an earlier agent report had left on it and the detail page showed a green test's name beside the failure.

0.0.13 (2026-09-21)

  • fp ci-report now surfaces loose ends: tests that failed in CI but carry no fp:<slug> marker, so no requirement tracks them. A red test nobody is tracking is exactly the failure a green-looking gate can hide (the failures aren't bound to a requirement, so nothing goes red). The CLI ships these failing-and-unmarked tests to the server on ingest, warns about them in CI (stderr + a ::warning:: annotation, the same way orphan markers are surfaced), and the web matrix shows them in a collapsible "N tests failing with no requirement" panel below the grid. Informational only — loose ends never fail the gate. Green unmarked tests are ignored; only failures are surfaced. A PR run never records them (a pull request is a different branch and must not overwrite the merged truth), and a later clean run for a surface clears its loose ends.

0.0.9 (2026-09-17)

  • fp surfaces show <key> --project <slug> — view a single surface's details. Looks the surface up by its key (agents speak keys, not the stored id, the same way fp show speaks requirement slugs) and prints its full configuration: name, key, kind, audience, repo, default branch, owner, team, and resolved test globs. An unknown key returns a not-found error. fp surfaces (bare) still lists, so existing callers are unaffected.

0.0.8 (2026-09-17)

  • fp ci-report --pr <url> — mark a run as a pull request's CI. Passing tests are recorded as pr_passing ("would pass once merged") instead of passing, and no merged evidence is demoted. pr_passing ranks between present and passing: it reads on the matrix as its own state (glyph ◐), counts as covered at the covered level, but is a violation at strict, which holds out for the merged-green truth. On merge, the plain fp ci-report (no --pr) records the real passing, superseding the pr_passing a prior PR left behind. Lets a reviewer see, on the PR, that a requirement would go green once merged.
  • fp whoami — show the resolved configuration this invocation would use: the active profile (and where it came from), the environment, the API URL (with its source: flag / env / profile / global / default), and whether an API key is present (masked, never the full token). Makes no API calls, so it works without a valid key. Also available as fp config whoami. Supports --json, --profile, and --api-url.
  • Environment-tagged API keys — profiles now record the environment they target. fp profile add and fp setup accept --environment; when omitted it's derived from the API URL host following the Belt DNS convention (api.staging.featureparity.dev → staging, api.featureparity.dev → production, nested/ephemeral api-abc-1234.dev.featureparity.dev → abc-1234, localhost → local). fp profile list shows the tag, and fp whoami warns when a profile's tagged environment doesn't match the resolved API URL.
  • fp setup now prompts for (and records) the API URL interactively, so users targeting a non-default/self-hosted/ephemeral environment configure it up front instead of silently defaulting to production. --api-url / --profile passed as global flags are now honored by fp setup and fp profile add.
  • Fall back to a profile named default when no --profile flag and no FP_PROFILE env var are set. Matches AWS/git/gcloud behavior — fp setup already creates a default profile, so fp <command> now uses it automatically. Profile resolution priority: --profile flag > FP_PROFILE env > default profile (if it exists). FP_API_KEY still overrides all profiles.
  • Ship Agent Skills package (skills/fp/) for cross-agent compatibility. Install with npx skills add stowzilla/feature_parity --skill fp to teach any AI agent (Claude Code, Codex, Cursor, Gemini, Kiro, etc.) how to use the fp CLI.

0.0.3 (2026-08-30)

Upload evidence without CI.

  • fp report --junit <file> — parse a JUnit XML report, discover the fp:<slug> markers in the referenced test files, and upload evidence for every requirement the suite covered. Run your suite locally, emit JUnit XML, and report evidence without waiting on CI (e.g. GitHub is offline).
  • Per-marker surfaces: fp:<slug>@api or fp:<slug>@api,web pin one or more surfaces right in the test comment (handy when a backend test satisfies several surfaces). Each surface produces its own evidence upload. Markers without an @surface fall back to --surface; --surface is only required when a matched marker pins none.
  • --base-dir flag to resolve relative test file paths from the JUnit report.
  • Skipped tests are reported as stub; everything else as present. Agents never report passing/failing — that stays CI's job.
  • Unknown slugs (no matching requirement) and markerless testcases are skipped with a warning instead of aborting the batch.
  • fp report --sha <sha> is now forwarded to the evidence payload.
  • Per-marker surface pinning: fp:print_qr@api or fp:print_qr@api,web pins surfaces directly in the test file. One marker can report to multiple surfaces.

0.0.2 (2026-08-25)

Custom API URL support and global settings.

  • fp config set|get|unset|list — manage global CLI settings
  • fp config set api_url https://api.dev.featureparity.dev — pin all requests to a custom API
  • --api-url global flag to override API URL for a single invocation
  • Global api_url setting in ~/.config/fp/config.yml (applies without a profile)
  • API URL priority: --api-url flag > FP_API_URL env > profile api_url > global api_url > default

0.0.1 (2026-08-25)

Initial release.

  • fp setup — interactive guided setup (validates API key, saves profile)
  • fp projects — list accessible projects
  • fp surfaces — list surfaces for a project
  • fp list — list active requirements (with --gaps filter)
  • fp show — show requirement details
  • fp propose — propose new requirements (as draft)
  • fp report — report evidence for a requirement
  • fp matrix — display parity matrix (ASCII or CSV)
  • fp profile — manage named profiles
  • --json flag on all commands for machine-readable output
  • --profile / -p flag for multi-project setups
FeatureParity

Connect product requirements to test evidence across every platform and repository.

Product

  • How it works
  • Pricing
  • Documentation
  • Download CLI
  • For coding agents

Guides

  • Verify agent-written code
  • Cross-platform feature parity
  • FeatureParity vs Tiden

Resources

  • Sign in
  • Get started
  • X
© 2026 Stowzilla Inc. All rights reserved.Made with Belt
X