--project-name  (string, required, default: —)
    Project name.
 
--ios  (path, default: —)
    iOS project root path.
 
--ios-mode  (enum, default: swiftui)
    iOS rendering mode: `swiftui`, `uikit`, or `all` (generate for both renderers).
 
--android  (path, default: —)
    Android project root path.
 
--android-mode  (enum, default: compose)
    Android rendering mode: compose or xml.
 
--package-name  (string, default: —)
    Android package name (e.g. com.example.app).
 
--web  (path, default: —)
    Web project root path.
 
--no-sync-tools  (flag, default: false)
    Skip copying sjui_tools / kjui_tools / rjui_tools into the platform roots.

--file  (path, default: all specs)
    Single spec file to process.
 
--force  (flag, default: false)
    Force-overwrite declaration files.
 
--skip-layout  (flag, default: false)
    Skip Layout JSON generation.
 
--dry-run  (flag, default: false)
    Show what would be generated without writing.
 
--ios-only  (flag, default: false)
    Generate iOS files only.
 
--android-only  (flag, default: false)
    Generate Android files only.
 
--web-only  (flag, default: false)
    Generate Web files only.
 
--type-map  (path, default: .jsonui-type-map.json)
    Path to the type map file.

names  (positional, required, default: —)
    Screen names (PascalCase).
 
--display-name  (string, default: —)
    Display name (single screen only).

name  (positional, default: —)
    Component name.
 
--from  (path, default: —)
    Component spec file (resolved against component_spec_directory).
 
--all  (flag, default: false)
    Generate from all component specs.
 
--attributes  (string, default: —)
    Attributes as key:type,... pairs.
 
--container  (flag, default: false)
    Mark as a container component.
 
--skip-existing  (flag, default: false)
    Skip converters that already exist (used by jui build).

--dry-run  (flag, default: false)
    Show what would be generated without writing files.
 
--platform  (enum, default: all)
    Restrict to a single platform.
 
--json  (flag, default: false)
    Emit JSON (used by MCP wrappers).

--lang  (enum, default: all)
    Target language: swift, kotlin, ruby, or all.
 
--out  (path, default: build/attr_codegen/<lang>)
    Output directory (per-language subdirs with --lang all).
 
--definitions  (path, default: bundled SSoT)
    Override the attribute definitions file.

--clean  (flag, default: false)
    Clean build — regenerate everything.
 
--ios-only  (flag, default: false)
    Build iOS only.
 
--android-only  (flag, default: false)
    Build Android only.
 
--web-only  (flag, default: false)
    Build Web only.
 
--platform  (enum)
    Build one platform: `ios`, `android` or `web`. Equivalent to the matching `--*-only` flag — it exists so the CLI and the MCP `jui_build` tool share one vocabulary (since jsonui-cli 1.8.10).
 
--allow-partial  (flag, default: false)
    Exit 0 even when a screen failed to generate. Without it a failed stage fails the command, which is the default since jsonui-cli 1.8.43 — an exit-0 run that dropped a screen ships a tree with a hole in it, and a CI gating on the exit code goes green over it. Measured before that release: a layout that could not be generated printed four `[ERROR]` lines, wrote no file, and exited 0.
 
--lint-strings  (flag, default: false)
    Run the localize scan (`jui lint-strings`) as part of the build and print its findings as build warnings. The build's exit code does not change; to fail on them, run `jui lint-strings` directly, which exits 2. Also settable as `"lint": {"strings": true}` in jui.config.json.

--fail-on-diff  (flag, default: false)
    Exit non-zero if any diff is detected.
 
--detail  (flag, default: false)
    Include per-screen diff details in the report.
 
--file  (path, default: all specs)
    Verify a single spec file.
 
--platform  (enum, default: first in config)
    Target platform.
 
--json  (path)
    Write the counts (`verified` / `skipped` / `total`, with `skippedByReason`) to PATH as JSON, for automation that cannot read the report.

--json  (flag, default: false)
    Emit JSON instead of the aligned table (what the MCP wrappers consume). Adds `derivedScreens` — every screen the resolver derived rather than read from an explicit `role`, which is the complete set to audit. The `needsReview` list beside it is a name-shaped hint, never complete.
 
--layouts-dir  (string, default: project's shared layouts)
    Classify a different layout directory instead of the one in jui.config.json.

--json  (flag, default: false)
    Emit JSON (used by MCP wrappers).

--platform  (enum, default: all)
    Restrict to a single platform.
 
--json  (flag, default: false)
    Emit JSON (used by MCP wrappers).

--from  (enum, default: ios)
    Which platform project to copy the layouts out of: `ios`, `android` or `web`.
 
--dry-run  (flag, default: false)
    Show planned changes without writing.

--from  (path, default: $JSONUI_CLI_PATH or ~/.jsonui-cli)
    Source directory.
 
--platform  (enum, default: all in config)
    Sync only one platform.
 
--prune  (flag, default: false)
    Delete target files missing from the source (outside extensions/).
 
--dry-run  (flag, default: false)
    Print actions without modifying files.

--host  (string, default: from docs/hotload/config.json)
    Override server.host.
 
--port  (number, default: 8081)
    Override server.port.
 
--ws-path  (string, default: /ws)
    Override server.wsPath.

--definitions  (path, default: bundled SSoT)
    Path to attribute_definitions.json.
 
--out  (path, default: conformance/)
    Output directory.

--dir  (path, default: conformance/)
    Conformance directory containing manifest.json.
 
--results  (path, default: <dir>/results)
    Results directory.
 
--out  (path, default: <dir>/REPORT.md)
    Report output path.
 
--env  (string, default: local)
    Render-environment key for the visual comparison — baselines are read from `baselines/<env>/`. A baseline is a fact about one renderer, so CI lanes pass their own key and never compare against developer-machine bakes.

--platform  (enum (repeatable), required, default: —)
    Platform whose results this gate judges; repeatable. Cross-platform mismatches are judged only when all three platforms are selected — with fewer, the results for the unselected ones are committed snapshots rather than this run's.
 
--dir  (path, default: conformance/)
    Conformance directory.
 
--results  (path, default: <dir>/results)
    Results directory.
 
--out  (path, default: <dir>/REPORT.md)
    Report output path.
 
--no-visual  (flag, default: false)
    Skip the screenshot-dependent checks — baseline comparison, attribute effect, artifact ratchets. For lanes that cannot compare renders: the per-push web lane runs on a different OS than the committed baselines were rendered on.
 
--env  (string, default: local)
    Render-environment key. Visual checks compare against `baselines/<env>/` and use that environment's ratchet ceilings. Severity is env-dependent: the attribute-effect ledger fails the gate only under `local`, where it is asserted, and is reported as a notice elsewhere.
 
--value-discrimination  (flag, default: false)
    Also judge that two declared VALUES of one attribute draw different pictures. This is the only check that can see a collapse: every other one compares a fixture to its control, to another platform, or to the codegen's render of itself, so an attribute that maps every value onto the same layout passes all of them. Collapses must be recorded in `value_discrimination.json` with an owner and a reason, and stale entries fail too.
 
--no-ledger-keys  (flag, default: false)
    Skip the check that every ledger key still names a fixture the manifest has. That check runs by DEFAULT, and this is the opt-out: a rename leaves the row pointing nowhere, the entry still looks live, the gate keeps running, and nothing that row claims is ever checked again. Dangling rows are reported, never deleted. Use it only on a checkout mid-rename.
 
--rendered-by  (string (NAME=SHA, repeatable), default: —)
    Which library drew this run's screenshots, e.g. `swiftjsonui=<sha>`. Compared against what the baseline records; when a regression is reported against a baseline drawn by a different library, the gate says so out loud. That is a notice, not a failure — the library is meant to move and the baseline is meant to be rebaked.
 
--codegen-effect  (flag, default: false)
    Also judge the codegen differential (C0/C1/C2/C3) against `codegen_effect.json`: defects must be recorded with an owner and a reason, and recorded entries must still measure — unrecorded defects and stale entries both fail. Needs no renders, so `--no-visual` does not affect it.
 
--parity  (flag, default: false)
    Also judge dynamic ≡ codegen: the codegen-host screenshots (`artifacts/<platform>-codegen`) must match the dynamic baseline within its threshold, deviations must be recorded in `codegen_parity.json`, and recorded entries must still measure — unrecorded drift and stale entries fail.
 
--inert-complete  (flag, default: false)
    Also judge inert COMPLETENESS: every fixture that renders identically to its control must be accounted for by some ledger or contract, or recorded in `inert_audit.json`. This is what catches an attribute that silently stops rendering — it looks exactly like an unrecorded inert verdict, and no other check can see it. Unrecorded verdicts and stale entries fail under env `local` and are a notice elsewhere. Needs the visual checks.
 
--cross-effect  (flag, default: false)
    Also judge cross-platform activeness agreement: a fixture's control-diff verdict (active or inert) must agree across the selected platforms its attribute is declared for, and values enumerated by the SSoT must not be inert everywhere. Findings must be recorded in `cross_effect.json`, and recorded entries must still measure — unrecorded findings and stale entries fail under env `local`, a notice elsewhere. Needs at least two selected platforms and the visual checks.

--platform  (enum, required, default: —)
    Platform whose results feed the coverage column.
 
--definitions  (path, default: bundled SSoT)
    Path to attribute_definitions.json.
 
--dir  (path, default: conformance/)
    Conformance directory.
 
-o, --out  (path, required, default: —)
    Output markdown path.

--platform  (enum, required, default: —)
    Platform whose artifacts to baseline.
 
--dir  (path, default: conformance/)
    Conformance directory.
 
--artifacts  (path, default: <dir>/artifacts/<platform>)
    Artifacts directory.
 
--env  (string, default: )
    Render-environment key to bake the baseline under.
 
--only-new  (flag, default: false)
    Bake only fixtures that have no baseline yet, leaving existing ones untouched.
 
--fail-on-moved  (flag, default: false)
    Exit non-zero when a fixture that already had a baseline moved. Which of two behaviours you get is decided by the jui version the machine resolves, and by nothing else — not the flag, not a project setting. From jsonui-cli 1.8.85 the command refuses before writing, so the baseline file is left untouched; up to 1.8.84 it wrote the file first and chose the exit code afterwards, so a run stopped there had already replaced the baseline — restore it from version control before re-running, and do not read the non-zero exit as "nothing was written". Pairing this with `--only-new` turns the refusal off: that combination writes entries for fixtures that had no baseline, and only leaves the existing ones alone.
 
--rendered-by  (string, default: )
    Metadata only (NAME=SHA): recorded in the manifest, never part of a comparison. A local bake does not know what CI would have used, so nothing looks it up.
 
--threshold  (number, default: the shared calibrated value)
    Comparison threshold stored in this manifest. Recalibrate per (env, platform) by measuring the renderer's repeat-run noise first.

--platform  (enum (repeatable), default: all)
    Limit the check to a platform.
 
--definitions  (path, default: bundled SSoT)
    Path to attribute_definitions.json.
 
--dir  (path, default: conformance/)
    Conformance directory holding coverage.json.
 
--repo-root  (path, default: —)
    Repo root holding the converter sources.
 
--update  (flag, default: false)
    Rewrite coverage.json from the current gaps.
 
--binding  (flag, default: false)
    Report the BINDING lane instead: attributes the SSoT declares a `@{...}` form for that no fixture ever writes in that form, so no platform's behaviour on it is measured. Reporting only — it cannot gate until the queue is consumed.
 
--json  (path, default: —)
    With `--binding`, write the queue to this path as JSON.

--platform  (enum, required, default: —)
    Platform whose artifacts to measure.
 
--dir  (path, default: conformance/)
    Conformance directory.
 
--artifacts  (path, default: <dir>/artifacts/<platform>)
    Directory holding this platform's screenshots.
 
--update  (flag, default: false)
    Record fixtures that differ from control into control_diff.json (existing entries kept).
 
--env  (string, default: local)
    Render-environment key, passed through to the fixture-vs-control comparison so that environment's system chrome bands are excluded — the Android CI status bar's clock ticks between a pair's two captures and otherwise reads as the attribute having had an effect.

--platform  (enum, default: —)
    Platform whose codegen artifacts to measure.
 
--env  (string, default: local)
    Render-environment key of the dynamic baseline to compare against.
 
--dir  (path, default: conformance/)
    Conformance directory.
 
--codegen-artifacts  (path, default: <dir>/artifacts/<platform>-codegen)
    Codegen screenshots directory.
 
--update  (flag, default: false)
    Record the measured deviations into `codegen_parity.json`: reasons and notes on surviving entries are preserved and new entries get the unreviewed marker. Without it, unrecorded deviations and stale entries exit non-zero — the same check that `gate --parity` runs.

--platform  (enum (repeatable), default: all three)
    Platform to include in the comparison. At least two are required — activeness agreement across one platform compares nothing.
 
--dir  (path, default: conformance/)
    Conformance directory.
 
--results  (path, default: <dir>/results)
    Results directory.
 
--definitions  (path, default: shared/core/attribute_definitions.json)
    Path to the attribute declarations, for the uniformly-inert check.
 
--semantics  (path, default: shared/core/attribute_semantics.json)
    Path to the attribute-semantics contract; adjudicated rulings are verified from it instead of from the ledger.
 
--update  (flag, default: false)
    Record the measured findings into `cross_effect.json`: reasons and notes are preserved where the fact still holds, new entries get the unreviewed marker, and entries no longer supported are pruned. Without it, unrecorded findings and stale entries exit non-zero — the same check that `gate --cross-effect` runs.
 
--env  (string, default: local)
    Render-environment key, passed through to the fixture-vs-control comparison so that environment's system chrome bands are excluded — the Android CI status bar's clock ticks between a pair's two captures and otherwise reads as the attribute having had an effect.

--platform  (enum (repeatable), default: all three)
    Platform to audit. Attribution is per platform, but the queue reports every item's full cross-platform picture.
 
--dir  (path, default: conformance/)
    Conformance directory.
 
--results  (path, default: <dir>/results)
    Results directory.
 
--definitions  (path, default: shared/core/attribute_definitions.json)
    Path to the attribute declarations, for the declared-value and value-is-default triage.
 
--semantics  (path, default: shared/core/attribute_semantics.json)
    Path to the attribute-semantics contract; fixtures it declares an observable for are attributed to the contract.
 
--json  (path, default: —)
    Write the adjudication queue here as JSON. The file is a report, not a ledger — nothing reads it back.
 
--untriaged-only  (flag, default: false)
    List only the items no mechanical triage family closes.
 
--update  (flag, default: false)
    Record the unattributed inert verdicts into `inert_audit.json` — the ledger that `gate --inert-complete` reads. Reasons already written are kept as long as the platform set still holds; entries the measurement no longer supports are dropped.
 
--env  (string, default: local)
    Render-environment key, passed through to the fixture-vs-control comparison so that environment's system chrome bands are excluded.

--platform  (enum (repeatable), default: all three)
    Limit to a platform. UIKit and the dynamic renderers have no codegen output to compare and are scoped out with a reason.
 
--definitions  (path, default: shared/core/attribute_definitions.json)
    Path to the attribute declarations the run enumerates.
 
--repo-root  (path, default: the toolchain root)
    Repo root holding the three tool trees.
 
--ruby  (path, default: ruby)
    Ruby interpreter used to run the probe scripts.
 
--check  (enum (repeatable), default: all)
    Report only these judgements: `C0` attribute-vs-control (is the spelling read at all), `C1` bound-vs-control (does the `@{...}` form survive), `C2` value1-vs-value2 (is the value read, or is a constant emitted).
 
--paired  (flag, default: false)
    Paired probe: write the COMPANION attributes the adjudication ledger says an attribute needs onto the control and onto every case alike, so they cancel and the attribute under test is again the only difference. Without it, an attribute the ledger rules inert on its own — `borderWidth` needs `borderColor` — can only ever measure the ruling. The companion sets are derived from the semantics contract, never listed by hand.
 
--json  (path, default: —)
    Write the full queue — findings, evidence and the scope ledger — here.
 
--limit  (number, default: 40)
    How many findings to print. The JSON holds them all.
 
--update  (flag, default: false)
    Record the measured defects into `codegen_effect.json` (owners and reasons on surviving entries are preserved) instead of judging against it. Without it, unrecorded defects and stale entries both exit non-zero — the same check that `gate --codegen-effect` runs.
 
--conformance-dir  (path, default: conformance/)
    Where `codegen_effect.json` lives.

--json  (flag, default: false)
    Emit the report as JSON (findings, stale entries, counts). With --usage the report also carries a `usage` object.
 
--usage  (flag, default: false)
    Since v1.6.15. Also check set agreement between strings.json and every referencing face — unused keys, missing keys, and dynamic references that bypass a *_STRING_KEYS map. Opt-in per run, or per project via lint.stringsUsage in jui.config.json.
 
--update-allowlist  (flag, default: false)
    Write the current raw-literal set into the allowlist ledger, preserving existing reasons. New entries get an empty reason and keep the lint failing until documented.
 
--allowlist  (string, default: .jui-strings-allowlist.json)
    Ledger path. Defaults to the project root file, or lint.stringsAllowlist from jui.config.json.

--fix  (flag, default: false)
    Print the regeneration command when markers are missing (it does not edit files).
 
--verbose  (flag, default: false)
    List every checked file, not just the failures.
 
--max-depth  (number, default: 5 (or lint.max_depth))
    Per-function brace-nesting bound for generated view code. Depth is what actually matters on iOS: SwiftUI composes one generic type per view and the runtime decodes its metadata on a 1 MB device stack. Omit the flag and `jui.config.json`'s `lint.max_depth` applies; omit both and the built-in 5 does. A configured value looser than 5 is refused with a warning — record accepted depths in `.jui-size-waivers` instead.
 
--max-lines  (number, default: 250 (or lint.max_lines))
    Per-function line-count bound. A soft target: a function that satisfies the depth bound but overruns the line count is reported, not rejected. Resolved the same way as `--max-depth` — flag, then `lint.max_lines`, then the built-in 250 — and a looser configured value is likewise refused.
 
--fail-on  (enum, default: any)
    Which finding sets a non-zero exit code: `any`, `size-ratchet`, or `health`. Exit 2 is a size-ratchet regression, 3 is generated-artifact health, and non-gating findings are still printed. Splitting them lets one signal gate a job without the other holding it red.
 
--update-size-baseline  (flag, default: false)
    Write the current oversized-function set to `.jui-size-waivers`. Commit that file and later runs can separate the known set from functions that became oversized after it.

--mode  (enum, default: detected)
    Initialize mode (all, uikit, swiftui).

<subcommand>  (positional, required)
    `view` / `partial` / `collection` / `binding` / `converter` / `adapter`.
 
<name>  (positional, required)
    PascalCase name; `collection` takes `Parent/Cell`.
 
--root  (flag, default: false)
    `view` only: make the generated view the root view.

<type>  (positional, required)
    `view` / `partial` / `collection` / `binding`.
 
<name>  (positional, required)
    The generated name, nested paths allowed (`home/dashboard`).

--mode  (enum, default: detected from sjui.config.json)
    Build mode (all, uikit, swiftui).
 
--clean  (flag, default: false)
    Clean cache before building.
 
--no-validate  (flag, default: false)
    Skip JSON attribute validation.
 
--strict  (flag, default: false)
    Fail the build on validation findings. Since jsonui-cli 1.8.43 that includes binding warnings, not attribute ones alone: measured on 1.8.44, a layout whose only findings are two undefined-variable binding warnings exits 0 plain and 1 under `--strict`. A canonical binding-rule error (`@{a ?? b ?? c}`, say) fails the build whether or not you pass the flag. Before 1.8.43 the counter held attribute warnings alone, and a binding-only layout passed `--strict`. One more thing moved in 1.8.45: findings are reported on a cached run too. Until then a build that skipped codegen skipped validation with it, so a second run over an unchanged tree printed nothing and `--strict` exited 0 — the gate answered from the cache rather than from the layouts. Measured on both sides, on the run where the log says `No files need updating (all cached)`: 1.8.44 exits 0 with no findings, 1.8.45 exits 1 and prints them.

<input.json>  (positional, required)
    The layout to convert.
 
[output.swift]  (positional)
    Where to write the SwiftUI source.
 
--from  (enum, default: json)
    Input format (json).
 
--to  (enum, default: swiftui)
    Output format (swiftui).

[files...]  (positional)
    Files or glob patterns; default is every JSON under the layouts directory.
 
--verbose  (flag, default: false)
    Show detailed error messages. Short form `-v`.

--mode  (enum, default: detected from sjui.config.json)
    Watch mode (all, uikit, swiftui).

--mode  (enum, default: detected)
    Initialize mode (all, xml, compose).

--mode  (enum, default: from kjui.config.json)
    Override the mode (xml / compose). Short form `-m`.
 
--activity  (flag, default: true)
    XML mode, `view`: generate as an Activity.
 
--fragment  (flag, default: false)
    XML mode, `view`: generate as a Fragment.
 
--type  (enum)
    XML mode, `view`: activity or fragment.
 
--force  (flag, default: false)
    Overwrite existing files. Short form `-f`.

--no-mock-check  (flag, default: false)
    Skip the mock contract check. The check is on by default deliberately: `mock generate --check` existed for a long time while nothing called it, which is why stale mocks survived unnoticed.
 
--no-install  (flag, default: false)
    Validate only: skip the flatten-install even when `test.install` is configured.
 
--config  (path, default: jui.config.json)
    Config file the `test.install` destinations are read from.

--check  (flag, default: false)
    Write nothing; compare each scenario body against the schema for its status code — declared types, `required` (including nested fields and array elements) and `enum`, with `nullable` respected. Scenarios are matched by route, not filename. Findings under `generated/` are warnings (regeneration fixes them); findings outside it are errors.
 
--update-default  (flag, default: false)
    Rewrite only the `default` body and the `source` route of existing files, leaving every other scenario byte-identical so test-driven data survives. `source.swagger` is preserved, so running from a different directory does not churn every file.
 
--swagger  (path)
    Path to an OpenAPI file; repeatable.
 
--out  (path, default: mock.mockDir or tests/mocks)
    Output mock directory.
 
--config  (path, default: jui.config.json)
    Config file.
 
--strict  (flag, default: false)
    With `--check`, treat a missing OPTIONAL field as drift too. Off by default: omitting an optional field is a valid instance, and failing on it buries the real violations.
 
--dry-run  (flag, default: false)
    With `--update-default`, report what would change without writing.

--no-validate-requests  (flag, default: false)
    Turn off request-side validation. On by default: request bodies and query parameters are checked against the contract (path-level `parameters` merged in). The request is still answered — a violation means the implementation does not satisfy the contract, and returning 422 would rewrite what every test on that endpoint is testing. Violations are deduplicated, summarized at end of run with a non-zero exit code, and readable at `/__jsonui__/contract-violations`. Also settable as `mock.validateRequests=false`, or per scenario with `skipRequestValidation`.
 
--port  (number)
    Port to listen on.
 
--mock-dir  (path, default: mock.mockDir or tests/mocks)
    Directory of mock files to serve.
 
--config  (path, default: jui.config.json)
    Config file to read the mock settings from.
 
--artifacts  (flag, default: false)
    After an ios/android run target finishes, pull its artifacts automatically (the same collection `jsonui-test artifacts pull` performs).

--port  (number, default: mock.server.port or 8790)
    Port to ask.
 
--config  (path, default: jui.config.json)
    Config file to read the port and project root from.
 
--expect-root  (path, default: this project's root)
    The project root to require of the answer.
 
--any-project  (flag, default: false)
    Report the identity without failing on a mismatch.

--check  (flag, default: false)
    Compare and exit non-zero on drift. Writes nothing.
 
--dry-run  (flag, default: false)
    Report what would be written without writing it.
 
--spec-dir  (path, default: spec_directory from jui.config.json)
    Spec directory to scan.

--format  (string, required)
    `junit` or `html`. Short form `-f`.
 
--output  (string, default: report.xml / report.html)
    Output file path. Short form `-o`.

--platform  (string, default: all)
    Platform to pull from: `ios` / `android` / `web` / `all`.
 
--xcresult  (string)
    Explicit .xcresult path or glob (overrides `test.artifacts.ios.xcresult`).
 
--serial  (string)
    adb device serial (overrides `test.artifacts.android.serial`). Selects the device, not the app — see `--clean`.
 
--out  (string, default: tests/artifacts)
    Output dir (overrides `test.artifacts.dir`).
 
--config  (string, default: jui.config.json)
    Config file.
 
--clean  (flag, default: false)
    After pulling, remove the app's OWN artifact directories from the Android device — its external files dir and the uninstall-surviving mirror `/data/local/tmp/jsonui-artifacts/<appId>`, which android driver 1.8.9 and later write. A device still running an older driver mirrors into the flat root instead. It never removes the flat legacy mirror `/data/local/tmp/jsonui-artifacts`, which has no app dimension: on a shared device that path holds every app's suites side by side, and one project's `pull --clean` was measured taking 74 directories and 71 MB of another project's runs off the device. `--serial` does not help there — it narrows the device, not the app. `artifacts prune-legacy` is the one command that empties that mirror, and it lists before it deletes.
 
--json  (flag, default: false)
    Print the result as a single JSON object.

--config  (string, default: jui.config.json)
    Config file.
 
--json  (flag, default: false)
    Print the status as a single JSON object.

--serial  (string)
    adb device serial (overrides `test.artifacts.android.serial`). Required when more than one device or emulator is attached — adb refuses to choose.
 
--yes  (flag, default: false)
    Actually delete the listed suite directories. Without it the command only lists them.
 
--config  (path, default: jui.config.json)
    Config file to read `test.artifacts.android` from.
 
--json  (flag, default: false)
    Print the result as a single JSON object (`root`, `suites`, `packages`, `deleted`, `dryRun`, `skipped`).

--platform  (string, default: both)
    Limit the run to one platform: `ios` or `android`. Default: both — each arm no-ops when its scan finds nothing.
 
--app-id  (string)
    Android application id to revoke on. Default: `test.install.android.applicationId`, falling back to `test.artifacts.android.appId`.
 
--serial  (string)
    adb device serial. Default: `test.artifacts.android.serial`, or the single connected device — with several devices connected and no serial, the arm stops and lists them.
 
--bundle-id  (string)
    UITest target bundle id (`.xctrunner` is appended automatically). Default: `test.install.ios.uitestBundleId` from the config.
 
--udid  (string)
    Simulator UDID. Default: the single booted simulator.
 
--config  (string, default: jui.config.json)
    Config file.
 
--force  (flag, default: false)
    iOS arm: grant even when no `addMedia` usage is found.

--output  (path)
    Output file (single spec) or output directory (batch). Short form `-o`.
 
--format  (enum, default: single file: inferred from the output extension, else markdown; directory: html)
    `markdown` or `html`. Honoured for a single file and, since 1.8.18, for a directory.
 
--layouts-dir  (path)
    Shared layouts directory, for resolving `layoutFile` imports. Auto-detected from jui.config.json when omitted.

--output  (path)
    Output file (single spec) or output directory (batch). Short form `-o`.
 
--format  (enum, default: single file: inferred from the output extension, else markdown; directory: html)
    `markdown` or `html`. Honoured for a single file and, since 1.8.18, for a directory.

--allow-partial  (flag, default: false)
    Accept an incomplete site: page failures are still reported, but the exit code stays 0. The escape hatch for a run that legitimately cannot fix its inputs yet.
 
--with-checks  (flag, default: false)
    Run the doc contract checks during generation and put the drift onto the page. Independent of `--allow-partial`: this is about drift being reported, that one is about the page existing at all.
 
--output  (path, default: html)
    Site output directory. Short form `-o`. NOT the only place this command writes — the run also regenerates doc trees in the source tree; see the purpose above.
 
--title  (string, default: JsonUI Test Documentation)
    Title for the index page. Short form `-t`.
 
--docs  (path)
    Directory holding OpenAPI / Swagger files; repeatable. Short form `-d`.
 
--figma  (path, default: auto-detected: figma/ next to the input)
    Directory holding Figma JSON files. Short form `-fig`.
 
--app  (string)
    An app and its docs directory as `name:path`; repeatable, for multi-app documentation. Each app resolves its own `jui.config.json` from its directory rather than sharing one found above the tests tree — the `--config` help names that as the default alongside the walk-up.
 
--config  (path, default: walk up from the input directory, or per --app directory)
    The `jui.config.json` to read `unitContracts` from. Name it when the config governing the specs is not the first one above the tests tree — the released help gives the split-tree case, where an unrelated config sits at the repository root. Since jsonui-cli 1.8.41.
 
--layouts-dir  (path, default: auto-detected per spec from jui.config.json)
    Override the layouts directory used to resolve `layoutFile` imports.

--specs  (path, default: `spec_directory` of the governing jui.config.json)
    The screen spec directory the diagram is drawn from. Flow tests under the input directory are checked against it. Since jsonui-cli 1.8.66.
 
--output  (path)
    Output HTML file path. Short form `-o`. Without it the Mermaid source is written to stdout.
 
--title  (string, default: Flow Diagram)
    Title of the diagram page. Short form `-t`.
 
--screens  (path, default: auto-detected)
    Path to the screens directory. Short form `-s`.
 
--layouts-dir  (path, default: auto-detected from jui.config.json)
    Path to the layout tree, used to tell screens from Collection cells and partials so sub-areas are not drawn as screens.

--output  (path, default: current directory)
    `init` only: where to write the file. Short form `-o`.
 
--flutter  (flag, default: false)
    `init` only: include Flutter-specific rules (Scaffold, AppBar, lifecycle methods).
 
--directory  (path, default: current directory)
    `show` only: directory to search for the config file. Short form `-d`.