# Upload results with qf collect

Source: https://docs.qualflare.com/docs/cli/collect · Last updated: 2026-11-21

Upload test results to Qualflare with the qf collect command: syntax, flags, launch metadata and exit codes, for JUnit XML, pytest, Jest, Playwright and more.

`qf <identifier> collect` is the Qualflare CLI command that parses test result files and uploads them as one launch. It reads 27 frameworks and 4 generic formats, and it gives up after 30 seconds unless you raise `--timeout`.

> **Caution: Uploaded screenshots, videos and traces are deleted after 30 days**
>
> Screenshots, videos and trace files that `qf <identifier> collect` uploads with your test results are deleted 30 days after upload and can't be restored. Download any you need to keep before then. See [Data Retention](https://docs.qualflare.com/docs/administration/project-settings#data-retention).

## Basic syntax

```bash
qf <identifier> collect [files...] [flags]
```

`<identifier>` is a project alias you saved with `qf login`. See [Authenticate with qf login](https://docs.qualflare.com/docs/cli/authentication) for setup.

### Arguments

| Argument   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `files...` | One or more test result files or directories. `qf` expands a quoted glob such as `"test-results/*.xml"` itself. In a glob `qf` expands, `**` is not recursive: it matches one directory level, like `*`. An unquoted glob is expanded by your shell first. A glob that matches nothing is an error. A directory adds the `.json` files directly inside it, unless it holds [Allure results](https://docs.qualflare.com/docs/cli/formats#allure); see [Collect a directory](https://docs.qualflare.com/docs/cli/sharding#collect-a-directory). |

### Examples

```bash
# Collect a single JUnit XML file
qf myapp collect results.xml --format junit

# pytest: write JUnit XML with --junitxml, then collect it
pytest --junitxml=pytest-report.xml
qf myapp collect pytest-report.xml --format python

# Auto-detect format from file
qf myapp collect playwright-results.json

# Collect multiple files with glob pattern
qf myapp collect test-results/*.xml --format junit

# Specify environment and git metadata
qf myapp collect results.xml --environment production --branch main --commit abc123

# Dry run - parse without uploading
qf myapp collect results.xml --dry-run

# Output parsed results as JSON (use with dry-run)
qf myapp collect results.xml --dry-run --output json
```

For every format and its `--format` value, see [Supported formats](https://docs.qualflare.com/docs/cli/formats).

## Flags

Some flags also have an environment variable. See [Configuration](https://docs.qualflare.com/docs/cli/configuration#environment-variables).

| Flag                   | Short | Type     | Default                 | Description                                                                                                                                                                                                                                                                                      |
| ---------------------- | ----- | -------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `--format`             | `-f`  | string   | `""` (auto-detect)      | Test framework format. Use `qf list-formats` to see all supported formats.                                                                                                                                                                                                                       |
| `--environment`        | `-e`  | string   | `development`           | Identifier of an environment that exists in the project (e.g., `development`, `staging`, `production`, `qa`)                                                                                                                                                                                     |
| `--lang`               |       | string   | `en-US`                 | Language of the launch. Must be a language tag Qualflare supports (e.g., `en-US`, `de-DE`, `ja-JP`).                                                                                                                                                                                             |
| `--platform`           |       | string   | `api`                   | Platform the tests ran on. One of `android`, `ios`, `desktop`, `web`, `api`.                                                                                                                                                                                                                     |
| `--branch`             |       | string   | `""`                    | Git branch name (e.g., `main`, `develop`, `feature/login`)                                                                                                                                                                                                                                       |
| `--commit`             |       | string   | `""`                    | Git commit hash for tracking which code version was tested                                                                                                                                                                                                                                       |
| `--milestone`          |       | int64    | `0` (none)              | Milestone sequence number to link this launch to.                                                                                                                                                                                                                                                |
| `--shard`              |       | bool     | `false`                 | Treat each input file as one shard of a parallel test run. See [Number shards with --shard](https://docs.qualflare.com/docs/cli/sharding#shard-flag).                                                                                                                                            |
| `--no-capture-output`  |       | bool     | `false`                 | Strip captured stdout/stderr and custom test properties before uploading.                                                                                                                                                                                                                        |
| `--debug`              |       | bool     | `false`                 | Log full HTTP request/response detail to stderr (token redacted).                                                                                                                                                                                                                                |
| `--timeout`            |       | duration | `30s`                   | Overall deadline for parsing and uploading the report, retries included. Go duration, e.g. `90s`, `2m`. See [`--timeout`](https://docs.qualflare.com/docs/cli/collect#--timeout).                                                                                                  |
| `--dry-run`            |       | bool     | `false`                 | Parse files without uploading to Qualflare. Useful for validation and debugging.                                                                                                                                                                                                                 |
| `--output`             | `-o`  | string   | `""`                    | Output format for dry-run mode. Currently supports `json`.                                                                                                                                                                                                                                       |
| `--upload-artifacts`   |       | string   | `""` (screenshots only) | Artifact kinds to add to the default (screenshots): `video`, `trace`. `image` (screenshots) is accepted and already on. `none` uploads no artifacts. Also set by `QF_UPLOAD_ARTIFACTS`. See [Upload screenshots, videos and traces](https://docs.qualflare.com/docs/cli/artifacts).              |
| `--artifacts-dir`      |       | string   | `""`                    | Directory of artifacts a framework left on disk, attached to the matching test cases. Applies to Detox reports. See [Attach Detox artifacts](https://docs.qualflare.com/docs/cli/artifacts#detox-artifacts-dir).                                                                                 |
| `--allow-mixed-runs`   |       | bool     | `false`                 | Upload report files from different runs as one launch. See [Collect a directory](https://docs.qualflare.com/docs/cli/sharding#collect-a-directory).                                                                                                                                              |
| `--warn-on-plan-limit` |       | bool     | `false`                 | When a plan limit refuses the upload, print a warning and exit `0` instead of `4`. The results are not uploaded. Also set by `QF_WARN_ON_PLAN_LIMIT`. See [`--warn-on-plan-limit`](https://docs.qualflare.com/docs/cli/collect#--warn-on-plan-limit). (requires qf 0.7.0 or later) |

### Flag descriptions

#### `--format` / `-f`

Specifies the test framework format. If not provided, the CLI attempts to auto-detect the format based on file content and extension.

```bash
qf myapp collect results.xml --format junit
qf myapp collect results.json --format playwright
```

Every value: [Supported formats](https://docs.qualflare.com/docs/cli/formats).

#### `--environment` / `-e`

The Identifier of the environment the tests ran against. The environment must already exist in the project: `collect` does not create it. New projects start with `development`, `staging`, `production` and `qa`. To add one, open **Settings** → **Environments** in your project and click **Create Environment**. Without the flag, `qf` uses `QF_ENVIRONMENT`, then the environment a native reporter wrote into its report, then `development`.

```bash
qf myapp collect results.xml --environment production
qf myapp collect results.xml --environment staging
```

An unknown environment fails the whole upload with exit code `1`:

```bash
$ qf myapp collect results.xml --environment dev
Error: failed to process test results: send: environment "dev" does not exist in this project (status: 400) [request_id: …]
```

#### `--lang`

Sets the language of the launch, which you can filter launches by. The value must be a language tag Qualflare supports, such as `en-US`, `de-DE` or `ja-JP`. An unsupported tag fails the upload. Without the flag, `qf` uses `QF_LANGUAGE`, then `en-US`.

```bash
qf myapp collect results.xml --lang de-DE
qf myapp collect results.xml --lang ja-JP
```

#### `--platform`

Labels the test run with the platform it ran on. Useful for separating mobile, desktop, and API results in the same project.

```bash
qf myapp collect espresso-results.xml --platform android
qf myapp collect xctest-results.xml --platform ios
```

#### `--branch` and `--commit`

Git metadata for tracking which code version was tested. Enables integration with Git workflows.

```bash
qf myapp collect results.xml --branch main --commit a1b2c3d
```

In CI/CD, these are often auto-populated from common environment variables (see [CI/CD Integration](https://docs.qualflare.com/docs/cli/ci-cd)):

```bash
# GitHub Actions
qf myapp collect results.xml --branch ${GITHUB_REF_NAME} --commit ${GITHUB_SHA}

# GitLab CI
qf myapp collect results.xml --branch ${CI_COMMIT_REF_NAME} --commit ${CI_COMMIT_SHA}
```

#### `--milestone`

Links this launch to a milestone by its sequence number. Useful for tracking release-health across multiple launches tied to the same milestone.

```bash
qf myapp collect results.xml --milestone 12
```

#### `--timeout`

The overall deadline for one `collect`: parsing the files and uploading the report, retries included. Default is 30 seconds. Raise it for large reports or slow networks.

```bash
qf myapp collect results.xml --timeout 2m  # 2 minutes
```

Screenshot and video uploads are not cut off by this deadline: each one gets its own 5-minute limit. The deadline starts when `collect` starts, though, so the time they take still counts against it. Raise `--timeout` when you upload videos, traces or many screenshots. `QF_TIMEOUT` (default `120s`) caps each single HTTP request, so raise it as well only when one request takes longer than two minutes. See [Retry & Timeout](https://docs.qualflare.com/docs/cli/configuration#retry--timeout).

#### `--dry-run`

Parse and validate test files without uploading. Useful for:

* Validating file format
* Debugging parsing issues
* Previewing what will be collected

```bash
qf myapp collect results.xml --dry-run
# Output: OK Test results parsed successfully (dry run)
```

#### `--output` / `-o`

Used with `--dry-run` to output parsed results as JSON. Useful for debugging and integration.

```bash
qf myapp collect results.xml --dry-run --output json
```

#### `--no-capture-output`

Strips captured `system-out`/`system-err` output, and any non-structural custom test property (e.g. a JUnit or pytest `<property>`, or TestCafe `fixture.*`/`test.*` metadata), before uploading. Properties a parser generates itself to describe the test (file path, duration, etc.) are still uploaded — only custom, test-authored properties and captured console output are removed.

```bash
qf myapp collect results.xml --no-capture-output
```

Use this when your test output may contain sensitive data (secrets, tokens, PII) that shouldn't leave your CI environment.

#### `--debug`

Logs the full HTTP request and response for the upload to stderr, with the auth token redacted. Useful when diagnosing upload failures.

```bash
qf myapp collect results.xml --debug
```

#### `--warn-on-plan-limit`

Requires qf 0.7.0 or later.

The `--warn-on-plan-limit` flag keeps a CI job green when the workspace has reached a plan limit: `collect` prints a warning to stderr and exits `0` instead of failing with exit code `4`. It is off by default. `QF_WARN_ON_PLAN_LIMIT=true` (or `1`) turns it on for every `collect`, and `--warn-on-plan-limit=false` turns it off for one command.

```bash
qf myapp collect results.xml --warn-on-plan-limit
```

The warning gives the server's reason and the request ID:

```text
warning: test results were NOT uploaded: this workspace has reached a plan limit. Not failing the build because --warn-on-plan-limit or QF_WARN_ON_PLAN_LIMIT is set. Reason from Qualflare: Launches quota exceeded (100/100) [request_id: …]
```

**The results of that run are not in Qualflare.** All the files of one `collect`, shards included, go up as one launch that is accepted or refused as a whole. Screenshots upload before the report, so some of them may already be stored. `--quiet` does not hide the warning.

The flag covers only the plan limits on monthly test reports, test cases and test suites. Everything else still fails as before: an invalid token, access denied, a [frozen workspace](https://docs.qualflare.com/docs/administration/billing#frozen-workspace), full storage, an inactive subscription, a rejected report, and network or server errors. See [What happens at a limit](https://docs.qualflare.com/docs/administration/plans#what-happens-at-a-limit).

### Global flags

These flags are available on all commands, as are `--debug` and `--no-capture-output` (all four, with their variables: [Global flags](https://docs.qualflare.com/docs/cli/configuration#global-flags)):

| Flag        | Short | Description                   |
| ----------- | ----- | ----------------------------- |
| `--verbose` | `-v`  | Enable detailed debug output  |
| `--quiet`   | `-q`  | Suppress all non-error output |

## Launch metadata

Every launch that `qf <identifier> collect` creates records an environment, a language, a platform, the git branch and commit and, optionally, a milestone.

| Field             | Flag                   | Variable                 | Default                                                                                                                              | Rule                                                                                                                                       |
| ----------------- | ---------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
| Environment       | `--environment`        | `QF_ENVIRONMENT`         | The value a native reporter wrote, then `development`                                                                                | The Identifier of an environment that exists in the project                                                                                |
| Language          | `--lang`               | `QF_LANGUAGE`            | `en-US`                                                                                                                              | A language tag Qualflare supports                                                                                                          |
| Platform          | `--platform`           | `QF_PLATFORM`            | The value a native reporter wrote, then `api`                                                                                        | One of `android`, `ios`, `desktop`, `web`, `api`. `qf` checks `--platform` before it uploads; a bad `QF_PLATFORM` is refused by the server |
| Branch and commit | `--branch`, `--commit` | `QF_BRANCH`, `QF_COMMIT` | CI variables, then the local git checkout ([CI auto-detection](https://docs.qualflare.com/docs/cli/configuration#ci-auto-detection)) | None                                                                                                                                       |
| Milestone         | `--milestone`          | `QF_MILESTONE`           | None                                                                                                                                 | The sequence number of an existing milestone. Values below `1` are ignored                                                                 |

An environment, milestone or language that doesn't exist fails the whole upload with `400` and exit code `1`, and no launch is created. The server names the value it refused, and `qf` refuses a bad `--platform` before it sends anything:

```text
environment "staging" does not exist in this project
milestone #12 does not exist in this project
language "xx-XX" is not supported
invalid --platform "linux": must be one of android, ios, desktop, web, api
```

![The header of a launch uploaded with qf collect, with its status, environment, branch and qf version chips.](https://docs.qualflare.com/images/cli/collect-launch-metadata-light.png)

*A launch uploaded with qf collect shows its environment, branch and qf version in its header.*

Fixes: [Troubleshoot qf and CI uploads](https://docs.qualflare.com/docs/cli/troubleshooting#environment-mismatch).

## Exit codes

| Code | Meaning                                                                                        |
| ---- | ---------------------------------------------------------------------------------------------- |
| `0`  | Success - test results collected or validated successfully                                     |
| `1`  | Generic error - file not found, parse error, invalid configuration, or invalid arguments/flags |
| `3`  | Auth error - `401`, invalid or expired token                                                   |
| `4`  | Forbidden - `402`/`403`, quota exceeded or plan/access denied                                  |
| `5`  | Not found - `404`                                                                              |
| `7`  | Transient error - `429` or `5xx` from the server; safe to retry                                |

With [`--warn-on-plan-limit`](https://docs.qualflare.com/docs/cli/collect#--warn-on-plan-limit), an upload refused at a plan limit exits `0` instead of `4`. What to do for each: [Exit codes](https://docs.qualflare.com/docs/cli/troubleshooting#exit-codes).

## Error handling

The CLI provides clear error messages for common issues:

### File not found

```bash
$ qf myapp collect missing.xml
Error: file does not exist: missing.xml
```

### Invalid format

```bash
$ qf myapp collect results.xml --format unsupported
Error: unsupported format: unsupported. Use 'qf list-formats' to see supported formats
```

### Parse error

```bash
$ qf myapp collect invalid.xml
Error: failed to process test results: failed to parse file invalid.xml: <parser error>
```

### Not logged in

```bash
$ qf myapp collect results.xml
Error: no identifier "myapp" configured. Run 'qf login myapp' to sign in. (See 'qf projects' for the list.)
```

### Network error

```bash
$ qf myapp collect results.xml
Error: failed to process test results: connection refused
```

The causes and fixes for these and other errors: [Troubleshoot qf and CI uploads](https://docs.qualflare.com/docs/cli/troubleshooting).

## Collecting a directory

Pass a directory to upload every `.json` report directly inside it; a directory with a `*-result.json` file directly inside it is read as [Allure results](https://docs.qualflare.com/docs/cli/formats#allure) instead, and its other `.json` files are not uploaded. `collect` uploads the newest run in a directory and any report without a run ID: see [Sharded runs and result directories](https://docs.qualflare.com/docs/cli/sharding#collect-a-directory).

### Artifacts

Screenshots in a report upload by default; videos and Playwright traces upload only with `--upload-artifacts video,trace`. See [Upload screenshots, videos and traces](https://docs.qualflare.com/docs/cli/artifacts).

When a file would take the workspace past its storage limit, `qf` skips that file and still uploads the results, and `collect` exits with code `0`. For each file it skips, it prints a `skipping <kind> attachment` line with the server's `Storage is full` message, and the case keeps a placeholder for the file. See [When storage is full](https://docs.qualflare.com/docs/security/data-retention#storage-full).

### Upload limits

Each input file can be up to 100 MB, and the report `qf` sends must fit the server's 10 MB limit. See [Size limits](https://docs.qualflare.com/docs/cli/artifacts#upload-limits).

## Sharding parallel test runs

To merge parallel or sharded CI jobs into one launch, collect all their results in one `qf <identifier> collect` call; `--shard` numbers the files by position. See [Sharded runs and result directories](https://docs.qualflare.com/docs/cli/sharding).

## Supported formats

The `qf <identifier> collect` command supports 27 frameworks and 4 generic formats across six categories. Use the `--format` flag to specify your framework, or let the CLI auto-detect it. Run `qf list-formats` to print every `--format` value the CLI accepts.

| Format | `--format` value | File type | Category | Reporter |
| --- | --- | --- | --- | --- |
| JUnit XML | `junit` | XML | Generic (JUnit-compatible) | — |
| CTRF | `ctrf` | JSON | Generic (JUnit-compatible) | — |
| Allure results | `allure` | JSON | Generic (JUnit-compatible) | — |
| Qualflare JSON | `qualflare-json` | JSON | Generic (JUnit-compatible) | — |
| pytest | `python` | XML | Unit Testing | [`qualflare-pytest`](https://docs.qualflare.com/docs/reporters/pytest) |
| Go | `golang` | JSON | Unit Testing | [`qualflare-go`](https://docs.qualflare.com/docs/reporters/go) |
| Jest | `jest` | JSON | Unit Testing | [`@qualflare/jest`](https://docs.qualflare.com/docs/reporters/jest) |
| Vitest | `vitest` | JSON | Unit Testing | [`@qualflare/vitest`](https://docs.qualflare.com/docs/reporters/vitest) |
| Mocha | `mocha` | JSON | Unit Testing | [`@qualflare/mocha`](https://docs.qualflare.com/docs/reporters/mocha) |
| RSpec | `rspec` | JSON | Unit Testing | — |
| PHPUnit | `phpunit` | XML | Unit Testing | — |
| TestNG | `testng` | XML | Unit Testing | [`com.qualflare:qualflare-testng`](https://docs.qualflare.com/docs/reporters/testng) |
| Cucumber | `cucumber` | JSON | BDD / Behavior-Driven | [`@qualflare/cucumberjs`](https://docs.qualflare.com/docs/reporters/cucumber) |
| Karate | `karate` | JSON | BDD / Behavior-Driven | — |
| Detox | `detox` | JSON | UI / E2E / Mobile Testing | [`@qualflare/detox`](https://docs.qualflare.com/docs/reporters/detox) |
| Playwright | `playwright` | JSON | UI / E2E / Mobile Testing | [`@qualflare/playwright`](https://docs.qualflare.com/docs/reporters/playwright) |
| Cypress | `cypress` | JSON | UI / E2E / Mobile Testing | [`@qualflare/cypress`](https://docs.qualflare.com/docs/reporters/cypress) |
| Selenium | `selenium` | JSON | UI / E2E / Mobile Testing | — |
| TestCafe | `testcafe` | JSON | UI / E2E / Mobile Testing | — |
| Maestro | `maestro` | XML | UI / E2E / Mobile Testing | [`qualflare-maestro`](https://docs.qualflare.com/docs/reporters/maestro) |
| XCTest | `xctest` | XML | UI / E2E / Mobile Testing | — |
| Espresso | `espresso` | XML | UI / E2E / Mobile Testing | [`com.qualflare:qualflare-espresso`](https://docs.qualflare.com/docs/reporters/espresso) |
| WebdriverIO | `webdriverio` | JSON | UI / E2E / Mobile Testing | [`@qualflare/webdriverio`](https://docs.qualflare.com/docs/reporters/webdriverio) |
| Appium | `appium` | JSON | UI / E2E / Mobile Testing | [`@qualflare/appium`](https://docs.qualflare.com/docs/reporters/appium) |
| Flutter | `flutter` | JSON | UI / E2E / Mobile Testing | [`qualflare_flutter`](https://docs.qualflare.com/docs/reporters/flutter) |
| Newman | `newman` | JSON | API Testing | — |
| k6 | `k6` | JSON | API Testing | — |
| OWASP ZAP | `zap` | JSON | Security Testing | — |
| Trivy | `trivy` | JSON | Security Testing | — |
| Snyk | `snyk` | JSON | Security Testing | — |
| SonarQube | `sonarqube` | JSON | Security Testing | — |

Each card opens the page of the framework's [Qualflare reporter](https://docs.qualflare.com/docs/reporters) where there is one, and the format's section in [Supported formats](https://docs.qualflare.com/docs/cli/formats) otherwise.

### Native reporters

Qualflare publishes native reporters for Playwright, Cypress, Jest, Vitest, Mocha, Cucumber.js, WebdriverIO, Appium, Detox, Espresso, Maestro, Flutter, pytest, Go, JUnit 5 and TestNG. Each one writes its results to files that `qf <identifier> collect` uploads, and none makes a network call: see [Reporters](https://docs.qualflare.com/docs/reporters).

#### What a native reporter adds

A native reporter records per-attempt retry history, steps, attachments and the metadata a test sets about itself, which JUnit XML can't carry: see [What a native reporter adds](https://docs.qualflare.com/docs/reporters#what-a-native-reporter-adds).

### Allure results

Requires qf 0.4.0 or later.

Pass an Allure 2 results directory, for example `qf <identifier> collect allure-results/`: how `qf` reads it is in [Allure results](https://docs.qualflare.com/docs/cli/formats#allure), and the steps are in [Upload Allure results](https://docs.qualflare.com/docs/cli/allure).

## Usage examples

### CI/CD integration

Collect test results as part of your CI/CD pipeline (see [CI/CD Integration](https://docs.qualflare.com/docs/cli/ci-cd) for full platform examples):

```yaml
# GitHub Actions
- name: Collect test results to Qualflare
  run: |
    qf login ci --force
    qf ci collect test-results/*.xml
  env:
    QF_TOKEN: ${{ secrets.QF_TOKEN }}
    QF_BRANCH: ${{ github.ref_name }}
    QF_COMMIT: ${{ github.sha }}
```

### Multiple test suites

Collect results from multiple test types:

```bash
# Unit tests
qf myapp collect unit-results.xml --format junit --environment qa

# E2E tests
qf myapp collect e2e-results.json --format playwright --environment qa

# Security scan
qf myapp collect security-report.json --format trivy --environment qa
```

### Dry run validation

Validate your test results before collecting:

```bash
# Validate file can be parsed
qf myapp collect results.xml --format junit --dry-run

# Preview what will be sent
qf myapp collect results.xml --format junit --dry-run --output json
```

### Verbose debugging

Enable verbose output for debugging:

```bash
qf myapp collect results.xml --verbose
# Prints to stderr:
# Processing 1 test result file(s)...
# POST https://api.qualflare.com/api/v1/collect
# OK Test results collected successfully
```

## Related

* **Guides:** [Install the CLI](https://docs.qualflare.com/docs/cli/installation) · [Authenticate with qf login](https://docs.qualflare.com/docs/cli/authentication) · [Upload screenshots, videos and traces](https://docs.qualflare.com/docs/cli/artifacts) · [Sharded runs and result directories](https://docs.qualflare.com/docs/cli/sharding) · [CI/CD Integration](https://docs.qualflare.com/docs/cli/ci-cd)
* **Reference:** [Supported formats](https://docs.qualflare.com/docs/cli/formats) · [Configuration and environment variables](https://docs.qualflare.com/docs/cli/configuration) · [qf command reference](https://docs.qualflare.com/docs/cli/commands) · [Troubleshoot qf and CI uploads](https://docs.qualflare.com/docs/cli/troubleshooting) · [Upload results with the API](https://docs.qualflare.com/docs/api/collect)
* **Changelog:** [Import Allure results with qf](https://changelog.qualflare.com/allure-results-import) · [Sharded test runs, with a timeline of every shard](https://changelog.qualflare.com/sharded-ci-runs) · [qf 0.1.9: no more false-green uploads, plus debug and privacy flags](https://changelog.qualflare.com/qf-cli-reliability-release)
