What's new

Unless a change is specific to one surface, changes listed here apply equally to the CLI and the corresponding MCP tools.

• meticulous agent test-runs (new) lists a project's pull request test runs, newest first, or its base test runs with --baseTestRuns. Options filter the runs and add more detail to each one.
• meticulous agent reject-check, approve-check and ignore-check (new) record an agent decision on a failing builtin or custom check, the same way the diff commands do for screenshot diffs. Rejecting is always available; approving and ignoring need Enable approve/ignore check actions under the project's Agents settings. An agent can never approve or ignore a check a person rejected. Like the other test-run commands, they take --prNumber as an alternative to --testRunId.
• meticulous agent check-comments (new) reads back the reasons given with those decisions, which are stored as their justification.

meticulous agent test-runs --prNumber=123
meticulous agent reject-check --testRunId="<id>" --checkId="network-requests" --reason="..."
meticulous agent check-comments --testRunId="<id>" --checkId="network-requests"

• Every command that resolves a test run from --testRunId or --commitSha — test-run-for-commit, test-run-diffs, test-run-check, js-coverage and js-coverage-diff — now also accepts --prNumber, which resolves to the latest test run for the pull request's head commit, exactly as --commitSha would for that commit. On the MCP server, the test-run tools take prNumber in place of testRunId.

meticulous agent test-run-diffs --prNumber=123

• meticulous agent approve-diff (new) approves a screenshot diff, optionally with a review comment explaining why (--reason with --x/--y). It is only available on projects that turn on Enable approve/ignore diff actions under the project's Agents settings; on those projects ignore-diff also records a real ignore rather than just a comment, so an agent can pass the Meticulous check without a human review. An agent can never approve or ignore a diff a person rejected.

meticulous agent approve-diff --replayDiffId="<id>" --screenshotName="<name>"

• meticulous agent promote-sessions (new) adds sessions you recorded to the selected set straight away, rather than waiting for the next session selection. Pass the test run you triggered over them with trigger-test-run --sessionIds. The commit's coverage reflects the promotion as soon as the updated base run it creates has finished post-processing.

meticulous agent trigger-test-run --sessionIds="<id1>,<id2>"
meticulous agent promote-sessions --testRunId="<id>"

meticulous agent upload-build no longer accepts --appZip. Pass the build output directory instead; it uploads in the format replays can start from without unpacking. This change is CLI-only: the MCP asset upload still takes a zip.

meticulous agent upload-build --appDirectory="<path-to-build>"

meticulous agent sessions can drop sessions recorded by Agent swarm (--excludeAgentReviewSessions), keep only sessions that captured their page's HTML document (--requireInitialNavigationResponse), and show what recorded each session (--includeSource).

meticulous agent sessions --excludeAgentReviewSessions --includeSource
meticulous agent sessions --requireInitialNavigationResponse --includeStartUrl

• meticulous agent sessions --selectedSet narrows the listing to the selected set Meticulous replays.
• --includeSelectedSince adds when each session entered that set.
• --includeAdditionalCoverage adds the coverage each session contributed over everything picked before it.
• --orderBy chooses the order (rank, selectedSince, additionalCoverage), and --order sets the direction (asc/desc).

meticulous agent sessions --selectedSet --includeSelectedSince
meticulous agent sessions --selectedSet --orderBy=rank
meticulous agent sessions --selectedSet="2026-07-01"
meticulous agent sessions --selectedSet --orderBy=selectedSince --order=asc
meticulous agent sessions --selectedSet --includeAdditionalCoverage --orderBy=additionalCoverage

Three new commands export test-run, daily-project, and test-run-event reporting statistics in machine-readable pages, scoped by --since (--until defaults to now) or by identifiers.

meticulous agent test-run-stats --since="2026-08-01"
meticulous agent project-daily-stats --since="2026-08-01"
meticulous agent test-run-event-stats --testRunIds="<id1>,<id2>" --json

• meticulous agent js-coverage --summary (new) reports a run's overall coverage — executed, executable and uncovered line counts and the coverage percentage — instead of the per-file list.
• --includeLineCounts (new) adds per-file executedLines/executableLines/uncoveredLines instead of ranges.
• --orderBy and --limit/--offset (new) order and page the output server-side.
• --globFilter is now repeatable, matching any of several globs.
• meticulous agent js-coverage-diff now diffs a whole test run against the base run it was compared against, and shares most of its arguments with js-coverage.

meticulous agent js-coverage --summary
meticulous agent js-coverage --includeLineCounts --orderBy=uncoveredLines --limit=50
meticulous agent js-coverage-diff --summary

• Gallery group headers have "Copy link to group" in Similar, URL, User flow, and custom groupings. The link opens that grouping and scrolls to the group.
• For a Similar-group link, meticulous agent test-run-diffs --similarGroupId="<id>" returns every screenshot in that group. --includeSimilarGroupId adds the id on each row.

meticulous agent test-run-diffs --similarGroupId="<id>" --testRunId="<id>"

• meticulous agent complete-base-run (new) replays the rest of a base run's selected sessions, to complete its coverage information.
• meticulous agent js-coverage now refuses a base run whose selected set hasn't fully replayed, saying how many sessions are missing, rather than reporting an understated total.

meticulous agent complete-base-run
meticulous agent js-coverage

• meticulous agent test-run-checks is renamed to meticulous agent test-run-check, since it operates on a single check.
• The new --availableIds flag (MCP: get_test_run_check_available_ids) lists the check IDs that have reported results for a test run.

meticulous agent test-run-check --availableIds --testRunId="<id>"
meticulous agent test-run-check --checkId="accessibility" --testRunId="<id>"

• meticulous agent reject-diff records a rejection with a review comment explaining why.
• meticulous agent ignore-diff says a diff looks like an unrelated variant / flake, currently as a comment only.
• The new create-diff-comment and reply-to-diff-comment commands let agents start and continue review threads independently of a decision.
• meticulous agent diff-comments gained an isAgentAuthored attribute, distinguishing agent-written comments from human ones.

meticulous agent reject-diff --replayDiffId="<id>" --screenshotName="<name>" --reason="..." --x=0.5 --y=0.5
meticulous agent reply-to-diff-comment --commentId="<id>" --text="..."

• meticulous agent test-run-checks retrieves the Markdown report for a non-visual check. For customer-reported checks, use --checkType="custom".
• meticulous agent sessions gained --includeNumberUserEvents and --includeNumberUrlsVisited for adding the recorded user-event and URL-visit counts to each session, and --includeDurationSeconds for adding each session's duration in seconds (omitted for sessions where a duration couldn't be computed, e.g. recorded before this was tracked).
• The MCP server gained whoami, list_projects, get_project and set_project, matching the existing meticulous auth commands — so an agent can now check which project its calls resolve to, and change it, without leaving the connection. meticulous auth get-project and set-project also gained --json.
• Relatedly, an empty test-run or session lookup now names the project it searched and how to change it, rather than just reporting nothing found: a default project lives on your user account, so it is shared across machines and sessions and an unexpectedly empty result is usually the wrong project rather than missing data.

meticulous agent test-run-checks --checkId="accessibility"
meticulous agent test-run-checks --checkId="network-requests" --testRunId="<id>"
meticulous agent sessions --includeDurationSeconds
meticulous agent sessions --includeNumberUserEvents
meticulous agent sessions --includeNumberUrlsVisited
meticulous auth get-project --json

• meticulous agent test-run-diffs --onlyWithComments filters to screenshot diffs with at least one open review comment.
• The --only* row filters now combine as a union, so passing several returns the diffs matching any of them.
• meticulous agent test-run-diffs returns all diffs when there are at most five; above that, a selected representative subset in priority order. Full-diff results no longer include an isSelected field. --onlyRejected/--onlyWithComments are unaffected by this cap, they always return every matching diff.
• meticulous agent test-run-diffs --counts now also reports numWithOpenComments.

• meticulous agent test-run-diffs --includeReviews adds decision (previously --includeReviewDecisions) and openComments to each diff.
• meticulous agent diff-comments --replayDiffId="<id>" --screenshotName="<name>" retrieves the corresponding open comments with nested replies.
• meticulous agent test-run-diffs --onlyRejected returns every screenshot diff already marked rejected, across every difference rather than only the selected subset.
• meticulous agent test-run-diffs no longer returns index or outcome, and now returns mismatchFraction only with --includeMismatchFraction.

meticulous agent test-run-diffs --includeReviews
meticulous agent diff-comments --replayDiffId="<id>" --screenshotName="<name>"
meticulous agent test-run-diffs --onlyRejected
meticulous agent test-run-diffs --includeMismatchFraction

• meticulous agent submit-feedback (new) lets an agent send free-form feedback to the Meticulous team — whether Meticulous helped catch or debug a problem, what was confusing, and what information would have made the task easier. Optionally tag it with --outcome (helped/neutral/hindered), the related --testRunId, the --skill being followed, and --agentName/--agentModel.

meticulous agent submit-feedback --message="Caught a real regression in the checkout flow" --outcome="helped" --testRunId="<id>" --skill="meticulous-review"

• meticulous auth login --device (new) logs in via the OAuth 2.0 Device Authorization Grant: the CLI prints a URL and code you can open and confirm in a browser on any device, then polls until the grant is confirmed. Use this on remote or sandboxed machines (SSH sessions, containers, cloud coding agents) where a browser can't reach the CLI's localhost — unlike --non-interactive, which still requires opening the printed URL on the same machine as the CLI.
• meticulous agent js-coverage gained --latestForProject, which returns per-file coverage from the project's preferred latest successful test run.

• meticulous agent sessions (new) lists a project's most recently created sessions, newest first — useful, for instance, for finding the id of a session you just recorded.
• meticulous agent trigger-test-run gained --maxDurationSeconds (or none for unlimited) to override the replay engine's duration cap on runs with pinned --sessionIds — useful, for instance, to prevent agent-recorded sessions from being cut at the default 5min cap.

meticulous agent sessions
meticulous agent sessions --createdSince="2026-07-01" --createdUntil="2026-07-10"
meticulous agent sessions --recordedBy="user@example.com" --visitedUrlFilter="*/checkout*"
meticulous agent sessions --recordedSince 2026-07-10 --excludeSyntheticSessions --limit 10
meticulous agent trigger-test-run --sessionIds="<id1>,<id2>" --maxDurationSeconds=none

The Meticulous MCP server exposes the agent CLI's read and analysis commands as tools your coding agent can call directly — see the MCP server page for setup and the full list of available tools. Every read-only agent command has a matching tool; the two mutating ones, upload-build and trigger-test-run, aren't exposed yet but are coming soon.

• meticulous agent test-run-diffs now understands PR review state, and can report totals without the full list:

  Flag	What it does
  --includeReviewDecisions	Add a decision column with each diff's PR review decision (accepted/rejected/ignored/unreviewed; unreviewed when undecided or there's no PR)
  --onlyUnreviewed	Return only the diffs still awaiting review — everything left to look at, across every difference (implies --includeAllDiffs, so the isSelected column is included)
  --counts	Print just the aggregate totals — number of replays, number of differences, and the review-decision breakdown (approved / ignored / rejected / unreviewed) — instead of the per-diff list

• Your default project is now a per-account setting, too:

  • meticulous auth set-project now persists your default project on your Meticulous account instead of a local file — so it's consistent across machines and available to the MCP server. meticulous auth logout leaves it untouched.
  • meticulous auth get-project (new) prints your default project, which you can also view and change from your user settings in the web app.
  • meticulous agent test-run-for-commit, test-run-diffs, js-coverage, and trigger-test-run gained --project — a one-off override (id, organization/name slug, or unique bare name) for that call only, which doesn't change your stored default.

  meticulous auth set-project --project="my-org/my-project"
  meticulous auth get-project
  meticulous agent js-coverage --project="my-org/my-project"
  

  CopyCopied!

meticulous agent test-run-diffs no longer returns matching screenshots — it reports only genuine visual differences, the same set Meticulous counts and displays everywhere else. The --includeMatches flag is removed.

meticulous agent js-coverage gained --headPlusTestRunIds and --testRunIds for unioning coverage across several test runs (same project, same commit) — e.g. combining a run's head coverage with a separate run triggered via agent trigger-test-run --sessionIds="<ids>" to assess how these sessions improve coverage.

meticulous agent js-coverage --headPlusTestRunIds="<id1>,<id2>"
meticulous agent js-coverage --testRunIds="<id1>,<id2>,<id3>"

• agent and auth commands gained --json for JSON-structured output instead of default format.
• agent and auth commands also gained --verbose, which prints additional progress logs on stderr.
• --rawJson is renamed to --jsonArgs (old name still works, now deprecated).

meticulous agent js-coverage --json
meticulous auth whoami --json

• meticulous agent js-coverage gained new flags for richer per-file coverage data: --includeExecutableRanges, --includeUncoveredRanges, --includeCoveragePercentage, and --prDiffOnly (test-run queries only), plus --includeAllFiles and --globFilter (also for replay and replay-diff queries).
• meticulous agent trigger-test-run can now run with no arguments at all — it infers the already-uploaded deployment for your local HEAD commit.
• meticulous agent trigger-test-run now accepts --sessionIds, a comma-separated list of session IDs to replay for both the base and the head, instead of the project's auto-selected golden set.
• meticulous agent trigger-test-run now also accepts --commitSha as an alternative to --deploymentId, resolving to the most recently uploaded deployment for that commit — useful for re-triggering a run against a commit that has already gone through Meticulous.
• meticulous auth login --non-interactive lets the login flow run without a TTY: it prints the login URL instead of opening a browser.

meticulous agent js-coverage --includeCoveragePercentage --prDiffOnly
meticulous agent trigger-test-run
meticulous agent trigger-test-run --deploymentId="<id>" --baseSha="<base-sha>" --sessionIds="<id1>,<id2>"
meticulous agent trigger-test-run --commitSha="<sha>" --baseSha="<base-sha>"
meticulous auth login --non-interactive --project="my-org/my-project"

Two new agent commands, upload-build and trigger-test-run, give agents their own counterparts to the CI upload commands (ci upload-assets / ci upload-container) — and split building and uploading your app from kicking off a test run. You can now upload a build once, capture its deployment ID, and trigger one or more runs against it independently. Git options such as the commit SHA are resolved automatically from your local repository.

# Upload a static build (or a container image) and capture the deploymentId
meticulous agent upload-build --appDirectory="<path-to-build>"
meticulous agent upload-build --localImageTag="<image-tag>"

# Trigger a run against an uploaded build
meticulous agent trigger-test-run --deploymentId="<id>"

Authentication is easier to drive from scripts and agents, and a stored login is no longer shadowed by a stale token.

• A logged-in OAuth session now takes precedence over a stale METICULOUS_API_TOKEN or ~/.meticulous/config.json token, so you won't get silently stuck on an expired credential.
• meticulous auth login (new) forces a fresh browser login and then selects a project.
• meticulous auth whoami now also reports which credential is actually in use.
• meticulous auth logout now also clears the selected project, and warns if an environment-variable or config-file token will keep being used.
• meticulous auth list-projects (new) lists the projects you can access.
• Argument --project org/project (new) on login / set-project lets you select a project non-interactively.

meticulous auth login --project="my-org/my-project"
meticulous auth list-projects

By default, meticulous agent test-run-diffs now returns a curated, priority-ordered set of the most relevant visual differences as a single flat list. New flags let you control what comes back:

Polling output is also quieter, and runs that can't produce diffs now fail fast with a clear message.

New agent commands surface the JavaScript code coverage captured during replays, and let you resolve a test run straight from a commit — so an agent can go from local git context to the right run without tracking run IDs.

meticulous agent js-coverage          # coverage for a test run (defaults to the current git HEAD)
meticulous agent js-coverage-diff     # base-vs-head coverage diff for a replay diff
meticulous agent test-run-for-commit  # the latest test run for the current commit