> Canonical HTML: [https://docs.schematic.tech/super/commands/checks/](https://docs.schematic.tech/super/commands/checks/)
# Check commands
Check supertests, inspect their results, apply proposed fixes, and cancel checks.
## `super check`
`super check` submits your supertests to Schematic, which uses mathematical reasoning to check
whether their assertions hold for every input allowed by their types and assumptions.
**Usage**
```console
super check [path] [options]
```
Start a check by passing a file containing a supertest to `super check`:
**Python · Bash**
```console
$ super check supertests/collapse_spaces.py
⠧ checking · collapsing_spaces_again_changes_nothing
supertests/collapse_spaces.py:6 · 8e44bea · #4
Sniffing... Beginning direct analysis of the claim and code.
Elapsed 3s · last update 0s ago
Esc/Ctrl+C detach
```
**Rust · Bash**
```console
$ super check tests/collapse_spaces.rs
⠧ checking · collapsing_spaces_again_changes_nothing
tests/collapse_spaces.rs:4 · 8e44bea · #4
Sniffing... Beginning direct analysis of the claim and code.
Elapsed 3s · last update 0s ago
Esc/Ctrl+C detach
```
**C · Bash**
```console
$ super check supertests/collapse_spaces.c
⠧ checking · collapsing_spaces_again_changes_nothing
supertests/collapse_spaces.c:7 · 8e44bea · #4
Sniffing... Beginning direct analysis of the claim and code.
Elapsed 3s · last update 0s ago
Esc/Ctrl+C detach
```
**C# · Bash**
```console
$ super check supertests/CollapseSpaces.cs
⠧ checking · CollapsingSpacesAgainChangesNothing
supertests/CollapseSpaces.cs:8 · 8e44bea · #4
Sniffing... Beginning direct analysis of the claim and code.
Elapsed 3s · last update 0s ago
Esc/Ctrl+C detach
```
**JavaScript · Bash**
```console
$ super check supertests/collapse_spaces.js
⠧ checking · collapsingSpacesAgainChangesNothing
supertests/collapse_spaces.js:5 · 8e44bea · #4
Sniffing... Beginning direct analysis of the claim and code.
Elapsed 3s · last update 0s ago
Esc/Ctrl+C detach
```
**Java · Bash**
```console
$ super check src/test/java/texttools/CollapseSpaces.java
⠧ checking · collapsingSpacesAgainChangesNothing
src/test/java/texttools/CollapseSpaces.java:11 · 8e44bea · #4
Sniffing... Beginning direct analysis of the claim and code.
Elapsed 3s · last update 0s ago
Esc/Ctrl+C detach
```
**VHDL · Bash**
```console
$ super check supertests/increment.vhd
⠧ checking · increment_never_decreases
supertests/increment.vhd:11 · 8e44bea · #4
Sniffing... Beginning direct analysis of the claim and code.
Elapsed 3s · last update 0s ago
Esc/Ctrl+C detach
```
Super CLI shows progress while checking, then keeps the results open for review. Press Esc or Ctrl+C
from the main view to close it; checks still in progress continue running.
To cancel a check, use [`super cancel`](#super-cancel).
### Select supertests
| Path | Supertests submitted |
| -------------------------- | ----------------------------------------------------------- |
| No path | Every supertest in the linked repository. |
| `.` | Supertests in the current directory and its subdirectories. |
| A file path | Every supertest declared in that file. |
| A directory path | Supertests in that directory and its subdirectories. |
| `::` | One named supertest. |
Paths are relative to your current directory. To check one supertest in a file, append
`::`:
**Python · Bash**
```console
$ super check 'supertests/collapse_spaces.py::collapsing_spaces_again_changes_nothing'
```
**Rust · Bash**
```console
$ super check 'tests/collapse_spaces.rs::collapsing_spaces_again_changes_nothing'
```
**C · Bash**
```console
$ super check 'supertests/collapse_spaces.c::collapsing_spaces_again_changes_nothing'
```
**C# · Bash**
```console
$ super check 'supertests/CollapseSpaces.cs::CollapsingSpacesAgainChangesNothing'
```
**JavaScript · Bash**
```console
$ super check 'supertests/collapse_spaces.js::collapsingSpacesAgainChangesNothing'
```
**Java · Bash**
```console
$ super check 'src/test/java/texttools/CollapseSpaces.java::collapsingSpacesAgainChangesNothing'
```
**VHDL · Bash**
```console
$ super check 'supertests/increment.vhd::increment_never_decreases'
```
One command can select up to 128 supertests. For larger repositories, pass a file or a smaller directory.
| Option | Effect |
| --------------------- | ------------------------------------------------------------------------------------ |
| `--problems` | Recheck problematic supertests from the latest run. |
| `--commit ` | Check a local Git commit, excluding uncommitted changes. |
| `--dirty` | Include uncommitted changes without prompting. |
| `--detach` | Return once the checks are accepted. |
| `--details` | Show the full explanation and evidence, including reproduction steps. |
| `--json` | Return structured output with full result details. |
| `--stream` | Stream check updates as JSON. Requires `--json`; cannot be combined with `--detach`. |
See [Automation and JSON](/super/reference/automation/) for use in scripts and coding agents.
### Result meanings
| Result | Meaning |
| ------ | ------------------------------------------------------------------------------------ |
| `pass` | Schematic verified that the supertest’s requirement holds for every input it covers. |
| `fail` | Schematic found that the supertest’s requirement does not always hold. |
Both ordinary and certified checks use mathematical reasoning. Results marked `pass (certified)`
or `fail (certified)` provide stronger assurance through an accepted formal certificate.
Press **Enter** in the interactive view, or use `--details`, to read the full explanation
and evidence.
Before a result is available, a check can be `pending`, `queued`, or `checking`. A `blocked`,
`canceled`, or `error` state means the check did not finish normally.
Explanations can arrive after the result. Keep the view open, or use
[`super status --watch`](#super-status) to follow updates later.
When a fix proposal is available, the result includes a [`super fix`](#super-fix) command to review it.
### Explore results
`super check` and [`super status --watch`](#super-status) share the same interactive view.
With multiple supertests, a table shows their status. Use ↑/↓ to select a row and read its
result in the shaded pane. Here is a completed run in a repository with three supertests:
**Python · Bash**
```console
$ super status --watch
supertest-python · 8e44bea
3 supertests · 2 passed · 1 failed
SUPERTEST · STATUS
› × collapsing_spaces_again_changes_nothing · fail
✓ empty_text_stays_empty · pass
✓ single_spaces_stay_unchanged · pass
supertests/collapse_spaces.py:6 · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
↑/↓ select · Enter for more details · Esc/Ctrl+C close
```
**Rust · Bash**
```console
$ super status --watch
supertest-rust · 8e44bea
3 supertests · 2 passed · 1 failed
SUPERTEST · STATUS
› × collapsing_spaces_again_changes_nothing · fail
✓ empty_text_stays_empty · pass
✓ single_spaces_stay_unchanged · pass
tests/collapse_spaces.rs:4 · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
↑/↓ select · Enter for more details · Esc/Ctrl+C close
```
**C · Bash**
```console
$ super status --watch
supertest-c · 8e44bea
3 supertests · 2 passed · 1 failed
SUPERTEST · STATUS
› × collapsing_spaces_again_changes_nothing · fail
✓ empty_text_stays_empty · pass
✓ single_spaces_stay_unchanged · pass
supertests/collapse_spaces.c:7 · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
↑/↓ select · Enter for more details · Esc/Ctrl+C close
```
**C# · Bash**
```console
$ super status --watch
supertest-csharp · 8e44bea
3 supertests · 2 passed · 1 failed
SUPERTEST · STATUS
› × CollapsingSpacesAgainChangesNothing · fail
✓ EmptyTextStaysEmpty · pass
✓ SingleSpacesStayUnchanged · pass
supertests/CollapseSpaces.cs:8 · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
↑/↓ select · Enter for more details · Esc/Ctrl+C close
```
**JavaScript · Bash**
```console
$ super status --watch
supertest-javascript · 8e44bea
3 supertests · 2 passed · 1 failed
SUPERTEST · STATUS
› × collapsingSpacesAgainChangesNothing · fail
✓ emptyTextStaysEmpty · pass
✓ singleSpacesStayUnchanged · pass
supertests/collapse_spaces.js:5 · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
↑/↓ select · Enter for more details · Esc/Ctrl+C close
```
**Java · Bash**
```console
$ super status --watch
supertest-java · 8e44bea
3 supertests · 2 passed · 1 failed
SUPERTEST · STATUS
› × collapsingSpacesAgainChangesNothing · fail
✓ emptyTextStaysEmpty · pass
✓ singleSpacesStayUnchanged · pass
src/test/java/texttools/CollapseSpaces.java:11 · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
↑/↓ select · Enter for more details · Esc/Ctrl+C close
```
**VHDL · Bash**
```console
$ super status --watch
supertest-vhdl · 8e44bea
3 supertests · 2 passed · 1 failed
SUPERTEST · STATUS
› × increment_never_decreases · fail
✓ zero_increments_to_one · pass
✓ ordinary_values_increment · pass
supertests/increment.vhd:11 · #4
Incrementing 255 decreases the value.
An 8-bit addition wraps from 255 to zero.
Counterexample
witness = value = 255
expected = the result is at least 255
observed = the result is 0
No fix proposal available.
↑/↓ select · Enter for more details · Esc/Ctrl+C close
```
Passed checks show a short conclusion. Problems include their explanation and counterexamples.
Press **Enter** for the selected supertest's full details and check history:
**Python · Output**
```console
collapsing_spaces_again_changes_nothing
Check history
STATUS · COMMIT · CHECK · REQUESTED
› × fail · 8e44bea · #4 · 2m ago
× fail · 3a3e126 · #1 · 12m ago
supertests/collapse_spaces.py:6
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Problem 1
Location: supertests/collapse_spaces.py:6
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
reproduce = Call collapse_spaces("a b"), then call it on that result.
No fix proposal available.
↑/↓ attempts · Esc back · Ctrl+C close
```
**Rust · Output**
```console
collapsing_spaces_again_changes_nothing
Check history
STATUS · COMMIT · CHECK · REQUESTED
› × fail · 8e44bea · #4 · 2m ago
× fail · 3a3e126 · #1 · 12m ago
tests/collapse_spaces.rs:4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Problem 1
Location: tests/collapse_spaces.rs:4
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
reproduce = Call collapse_spaces("a b"), then call it on that result.
No fix proposal available.
↑/↓ attempts · Esc back · Ctrl+C close
```
**C · Output**
```console
collapsing_spaces_again_changes_nothing
Check history
STATUS · COMMIT · CHECK · REQUESTED
› × fail · 8e44bea · #4 · 2m ago
× fail · 3a3e126 · #1 · 12m ago
supertests/collapse_spaces.c:7
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Problem 1
Location: supertests/collapse_spaces.c:7
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
reproduce = Call collapse_spaces("a b"), then call it on that result.
No fix proposal available.
↑/↓ attempts · Esc back · Ctrl+C close
```
**C# · Output**
```console
CollapsingSpacesAgainChangesNothing
Check history
STATUS · COMMIT · CHECK · REQUESTED
› × fail · 8e44bea · #4 · 2m ago
× fail · 3a3e126 · #1 · 12m ago
supertests/CollapseSpaces.cs:8
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Problem 1
Location: supertests/CollapseSpaces.cs:8
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
reproduce = Call Text.CollapseSpaces("a b"), then call it on that result.
No fix proposal available.
↑/↓ attempts · Esc back · Ctrl+C close
```
**JavaScript · Output**
```console
collapsingSpacesAgainChangesNothing
Check history
STATUS · COMMIT · CHECK · REQUESTED
› × fail · 8e44bea · #4 · 2m ago
× fail · 3a3e126 · #1 · 12m ago
supertests/collapse_spaces.js:5
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Problem 1
Location: supertests/collapse_spaces.js:5
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
reproduce = Call collapseSpaces("a b"), then call it on that result.
No fix proposal available.
↑/↓ attempts · Esc back · Ctrl+C close
```
**Java · Output**
```console
collapsingSpacesAgainChangesNothing
Check history
STATUS · COMMIT · CHECK · REQUESTED
› × fail · 8e44bea · #4 · 2m ago
× fail · 3a3e126 · #1 · 12m ago
src/test/java/texttools/CollapseSpaces.java:11
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Problem 1
Location: src/test/java/texttools/CollapseSpaces.java:11
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
reproduce = Call Text.collapseSpaces("a b"), then call it on that result.
No fix proposal available.
↑/↓ attempts · Esc back · Ctrl+C close
```
**VHDL · Output**
```console
increment_never_decreases
Check history
STATUS · COMMIT · CHECK · REQUESTED
› × fail · 8e44bea · #4 · 2m ago
× fail · 3a3e126 · #1 · 12m ago
supertests/increment.vhd:11
Incrementing 255 decreases the value.
An 8-bit addition wraps from 255 to zero.
Problem 1
Location: supertests/increment.vhd:11
Counterexample
witness = value = 255
expected = the result is at least 255
observed = the result is 0
reproduce = Call saturating_increment(to_unsigned(255, 8)).
No fix proposal available.
↑/↓ attempts · Esc back · Ctrl+C close
```
Use ↑/↓ to compare earlier attempts, then Esc to return to the supertest table.
For a single supertest, available history is shown alongside the result.
| Control | Action |
| ------------------- | ------------------------------------------------------------------------------ |
| ↑ / ↓ | Select a supertest or history row. With no rows to select, scroll the details. |
| Enter | Open history and full details. |
| Esc | Go back, or close the main view. |
| Ctrl+C | Close from any view without canceling checks. |
| Page Up / Page Down | Scroll longer details. |
| Mouse drag | Select text to copy with your terminal's copy shortcut. |
| `n`, when shown | Load older history or retry loading it. |
### Leave checks running
To leave checks running, press Esc or Ctrl+C from the main view. You can also start with `--detach`
to return as soon as Schematic accepts the checks:
**Python · Bash**
```console
$ super check supertests/collapse_spaces.py --detach
Accepted 1 check · supertest-python · 8e44bea
collapsing_spaces_again_changes_nothing · #4
Checks continue remotely.
Watch: super status --check 4 --watch
```
**Rust · Bash**
```console
$ super check tests/collapse_spaces.rs --detach
Accepted 1 check · supertest-rust · 8e44bea
collapsing_spaces_again_changes_nothing · #4
Checks continue remotely.
Watch: super status --check 4 --watch
```
**C · Bash**
```console
$ super check supertests/collapse_spaces.c --detach
Accepted 1 check · supertest-c · 8e44bea
collapsing_spaces_again_changes_nothing · #4
Checks continue remotely.
Watch: super status --check 4 --watch
```
**C# · Bash**
```console
$ super check supertests/CollapseSpaces.cs --detach
Accepted 1 check · supertest-csharp · 8e44bea
CollapsingSpacesAgainChangesNothing · #4
Checks continue remotely.
Watch: super status --check 4 --watch
```
**JavaScript · Bash**
```console
$ super check supertests/collapse_spaces.js --detach
Accepted 1 check · supertest-javascript · 8e44bea
collapsingSpacesAgainChangesNothing · #4
Checks continue remotely.
Watch: super status --check 4 --watch
```
**Java · Bash**
```console
$ super check src/test/java/texttools/CollapseSpaces.java --detach
Accepted 1 check · supertest-java · 8e44bea
collapsingSpacesAgainChangesNothing · #4
Checks continue remotely.
Watch: super status --check 4 --watch
```
**VHDL · Bash**
```console
$ super check supertests/increment.vhd --detach
Accepted 1 check · supertest-vhdl · 8e44bea
increment_never_decreases · #4
Checks continue remotely.
Watch: super status --check 4 --watch
```
Follow the printed `super status` command to return to the live view. Use [`super cancel`](#super-cancel)
if you want to stop the checks themselves.
### Select source
Super CLI selects your current commit and prompts before including uncommitted changes. Use `--dirty`
to include them without prompting, or `--commit HEAD` to exclude them.
To check an earlier commit without changing your checkout:
**Bash**
```console
$ super check --commit HEAD~1
```
Checking leaves your files, branch, and staging unchanged. See
[Source and commits](/super/help/source/) for which files the CLI includes and how it handles
uncommitted changes.
Consecutive checks of the same supertest, source, and checking options reuse the same check.
Blocked, canceled, and errored checks can start a new attempt after the previous work stops.
### Recheck findings
After changing your code, recheck the problematic supertests from your latest run:
**Bash**
```console
$ super check --problems
```
Add a path to narrow that run's selection. Super CLI submits your current source for checking. If there
are no problems to recheck, it reports that without submitting checks. A passing recheck applies only to the
selected supertests. Run `super check` to check the whole repository.
See [Troubleshooting](/super/help/troubleshooting/#an-existing-check-is-blocked-or-canceled) for
blocked or canceled checks.
## `super status`
**Usage**
```console
super status [path] [options]
```
Inspect existing checks without starting new ones. With no target, Super CLI shows the latest run in
the linked repository and exits. To inspect one check, use `--check`:
**Python · Bash**
```console
$ super status --check 4
× fail · collapsing_spaces_again_changes_nothing
supertests/collapse_spaces.py:6 · 8e44bea · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
Details: super status --check 4 --details
```
**Rust · Bash**
```console
$ super status --check 4
× fail · collapsing_spaces_again_changes_nothing
tests/collapse_spaces.rs:4 · 8e44bea · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
Details: super status --check 4 --details
```
**C · Bash**
```console
$ super status --check 4
× fail · collapsing_spaces_again_changes_nothing
supertests/collapse_spaces.c:7 · 8e44bea · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
Details: super status --check 4 --details
```
**C# · Bash**
```console
$ super status --check 4
× fail · CollapsingSpacesAgainChangesNothing
supertests/CollapseSpaces.cs:8 · 8e44bea · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
Details: super status --check 4 --details
```
**JavaScript · Bash**
```console
$ super status --check 4
× fail · collapsingSpacesAgainChangesNothing
supertests/collapse_spaces.js:5 · 8e44bea · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
Details: super status --check 4 --details
```
**Java · Bash**
```console
$ super status --check 4
× fail · collapsingSpacesAgainChangesNothing
src/test/java/texttools/CollapseSpaces.java:11 · 8e44bea · #4
Collapsing spaces again changes the text.
A single replacement can leave adjacent spaces.
Counterexample
witness = text = "a b"
expected = the second call returns the same text as the first
observed = first call: "a b"; second call: "a b"
No fix proposal available.
Details: super status --check 4 --details
```
**VHDL · Bash**
```console
$ super status --check 4
× fail · increment_never_decreases
supertests/increment.vhd:11 · 8e44bea · #4
Incrementing 255 decreases the value.
An 8-bit addition wraps from 255 to zero.
Counterexample
witness = value = 255
expected = the result is at least 255
observed = the result is 0
No fix proposal available.
Details: super status --check 4 --details
```
A **run** groups the checks requested by one command. A **check** has a number within its linked
repository and covers one supertest at one source revision.
| Target | What Super CLI shows |
| ------------------ | ------------------------------------------------------------- |
| No target | The latest run, even if your local commit has changed. |
| A path | The latest check for each matching supertest, across commits. |
| `--check ` | One exact check, even if your local commit has changed. |
| `--run ` | One exact run, using its ID from JSON output. |
Choose one target. Paths use the same [selection syntax as `super check`](#select-supertests).
Check numbers appear in results and follow-up commands. The displayed commit identifies the
checked source; your local files may have changed since then.
| Option | Effect |
| ------------------- | ----------------------------------------------------------------------------------------------- |
| `--watch` | Open the interactive view and follow updates until you close it. |
| `--details` | Show the full explanation and evidence, including reproduction steps. |
| `--history` | Include a page of earlier attempts in printed or JSON output. |
| `--before ` | Load history before this check number. Requires `--history`. |
| `--json` | Return full structured results. With `--watch`, stream until checks and pending updates finish. |
### Follow updates
**Bash**
```console
$ super status --watch
```
Add a path, `--check`, or `--run` to watch a particular selection. This uses the
[same tables, details, history, and controls](#explore-results) as `super check`, and stays open
for later explanations and fixes. Without `--watch`, the output is a snapshot you can copy
from your terminal.
### Print history
Interactive history is available without `--history`. Use that flag when you want a printed
list of attempts instead:
**Bash**
```console
$ super status --check 4 --history
```
Add `--details` to include each attempt's full details. For older history, follow the
`--history --before ` command printed at the end of the output.
## `super fix`
Review and apply a proposed fix for a reported problem.
**Usage**
```console
super fix [path] [options]
```
Use [`super status`](#super-status) to see available proposals, or
[`super status --watch`](#super-status) to follow updates. Proposals may arrive after the check result,
and not every finding has a fix.
Run the `super fix` command shown with the result to review the patch and choose whether to apply it:
**Python · Bash**
```console
$ super fix --check 1
supertest-python · 8e44bea
Fix proposal · collapsing_spaces_again_changes_nothing · #1
Repeat the replacement until no consecutive spaces remain.
text_tools/text.py +3 -1
old new @@ -1,2 +1,4 @@
1 1 def collapse_spaces(text: str) -> str:
2 - return text.replace(" ", " ")
2 + while " " in text:
3 + text = text.replace(" ", " ")
4 + return text
? Apply this fix to your working tree? [Y/n] › yes
✓ Applied · 1 file changed
Changes are uncommitted.
Next: super check supertests/collapse_spaces.py::collapsing_spaces_again_changes_nothing
```
**Rust · Bash**
```console
$ super fix --check 1
supertest-rust · 8e44bea
Fix proposal · collapsing_spaces_again_changes_nothing · #1
Repeat the replacement until no consecutive spaces remain.
src/text.rs +5 -1
old new @@ -1,3 +1,7 @@
1 1 pub fn collapse_spaces(text: &str) -> String {
2 - text.replace(" ", " ")
2 + let mut normalized = text.to_owned();
3 + while normalized.contains(" ") {
4 + normalized = normalized.replace(" ", " ");
5 + }
6 + normalized
3 7 }
? Apply this fix to your working tree? [Y/n] › yes
✓ Applied · 1 file changed
Changes are uncommitted.
Next: super check tests/collapse_spaces.rs::collapsing_spaces_again_changes_nothing
```
**C · Bash**
```console
$ super fix --check 1
supertest-c · 8e44bea
Fix proposal · collapsing_spaces_again_changes_nothing · #1
Skip the rest of each run of spaces by changing if to while.
src/text.c +1 -1
old new @@ -11,7 +11,7 @@
11 11 char *dst = normalized;
12 12 for (const char *src = text; *src != '\0'; ++src) {
13 13 *dst++ = *src;
14 - if (*src == ' ' && src[1] == ' ') {
14 + while (*src == ' ' && src[1] == ' ') {
15 15 ++src;
16 16 }
17 17 }
? Apply this fix to your working tree? [Y/n] › yes
✓ Applied · 1 file changed
Changes are uncommitted.
Next: super check supertests/collapse_spaces.c::collapsing_spaces_again_changes_nothing
```
**C# · Bash**
```console
$ super fix --check 1
supertest-csharp · 8e44bea
Fix proposal · CollapsingSpacesAgainChangesNothing · #1
Repeat the replacement until no consecutive spaces remain.
Text.cs +5 -1
old new @@ -4,6 +4,10 @@
4 4 {
5 5 public static string CollapseSpaces(string text)
6 6 {
7 - return text.Replace(" ", " ");
7 + while (text.Contains(" "))
8 + {
9 + text = text.Replace(" ", " ");
10 + }
11 + return text;
8 12 }
9 13 }
? Apply this fix to your working tree? [Y/n] › yes
✓ Applied · 1 file changed
Changes are uncommitted.
Next: super check supertests/CollapseSpaces.cs::CollapsingSpacesAgainChangesNothing
```
**JavaScript · Bash**
```console
$ super fix --check 1
supertest-javascript · 8e44bea
Fix proposal · collapsingSpacesAgainChangesNothing · #1
Replace each complete run of spaces with one space.
src/text.js +1 -1
old new @@ -1,3 +1,3 @@
1 1 export function collapseSpaces(text) {
2 - return text.replaceAll(' ', ' ');
2 + return text.replace(/ +/g, ' ');
3 3 }
? Apply this fix to your working tree? [Y/n] › yes
✓ Applied · 1 file changed
Changes are uncommitted.
Next: super check supertests/collapse_spaces.js::collapsingSpacesAgainChangesNothing
```
**Java · Bash**
```console
$ super fix --check 1
supertest-java · 8e44bea
Fix proposal · collapsingSpacesAgainChangesNothing · #1
Replace each complete run of spaces with one space.
src/main/java/texttools/Text.java +1 -1
old new @@ -4,6 +4,6 @@
4 4 private Text() {}
5 5
6 6 public static String collapseSpaces(String text) {
7 - return text.replace(" ", " ");
7 + return text.replaceAll(" +", " ");
8 8 }
9 9 }
? Apply this fix to your working tree? [Y/n] › yes
✓ Applied · 1 file changed
Changes are uncommitted.
Next: super check src/test/java/texttools/CollapseSpaces.java::collapsingSpacesAgainChangesNothing
```
**VHDL · Bash**
```console
$ super fix --check 1
supertest-vhdl · 8e44bea
Fix proposal · increment_never_decreases · #1
Return 255 unchanged and increment smaller values normally.
src/incrementer.vhd +3 -0
old new @@ -9,6 +9,9 @@
9 9 package body incrementer is
10 10 function saturating_increment(value : byte_value) return byte_value is
11 11 begin
12 + if value = 255 then
13 + return value;
14 + end if;
12 15 return value + 1;
13 16 end function;
14 17 end package body;
? Apply this fix to your working tree? [Y/n] › yes
✓ Applied · 1 file changed
Changes are uncommitted.
Next: super check supertests/increment.vhd::increment_never_decreases
```
Changes remain uncommitted. Follow the printed [`super check`](#super-check) command to include
the changes and verify the updated code.
You can also run `super fix` while a proposal is pending. It waits for the proposal; Ctrl+C stops
waiting without canceling the check.
### Select a fix
| Command | Selects |
| ---------------------------- | -------------------------------------------------------- |
| `super fix` | The single problematic supertest in the latest run. |
| `super fix ` | The latest check for the supertest selected by the path. |
| `super fix --check ` | A particular check, including an older one. |
A file or directory path must select one supertest. If a file contains several, use
`::`. Paths are relative to your current directory and cannot be combined
with `--check`.
### Preview and options
| Option | Effect |
| ----------- | ------------------------------------------------------------------------------ |
| `--dry-run` | Preview without applying. Cannot be combined with `--yes`. |
| `--details` | Include the proposal's instructions and suggested validation. |
| `--yes` | Apply without prompting. Required for noninteractive application. |
| `--json` | Return structured output. Use with `--dry-run` to preview or `--yes` to apply. |
JSON previews include the full patch, instructions, and suggested validation, without requiring
`--details`.
If a fix is unavailable or won’t apply, see
[Fix troubleshooting](/super/help/troubleshooting/#a-fix-is-unavailable-or-wont-apply).
## `super cancel`
**Usage**
```console
super cancel
super cancel --run
super cancel --check
```
Stop checks with `super cancel`. Pass a file or directory to select the latest check for each
matching supertest, or append `::` to select one. Use `--check` for an exact check or
`--run` for an exact run.
Super CLI confirms when the check has stopped:
**Python · Bash**
```console
$ super cancel --check 1
○ canceled · collapsing_spaces_again_changes_nothing · #1
To check again: super check supertests/collapse_spaces.py::collapsing_spaces_again_changes_nothing
```
**Rust · Bash**
```console
$ super cancel --check 1
○ canceled · collapsing_spaces_again_changes_nothing · #1
To check again: super check tests/collapse_spaces.rs::collapsing_spaces_again_changes_nothing
```
**C · Bash**
```console
$ super cancel --check 1
○ canceled · collapsing_spaces_again_changes_nothing · #1
To check again: super check supertests/collapse_spaces.c::collapsing_spaces_again_changes_nothing
```
**C# · Bash**
```console
$ super cancel --check 1
○ canceled · CollapsingSpacesAgainChangesNothing · #1
To check again: super check supertests/CollapseSpaces.cs::CollapsingSpacesAgainChangesNothing
```
**JavaScript · Bash**
```console
$ super cancel --check 1
○ canceled · collapsingSpacesAgainChangesNothing · #1
To check again: super check supertests/collapse_spaces.js::collapsingSpacesAgainChangesNothing
```
**Java · Bash**
```console
$ super cancel --check 1
○ canceled · collapsingSpacesAgainChangesNothing · #1
To check again: super check src/test/java/texttools/CollapseSpaces.java::collapsingSpacesAgainChangesNothing
```
**VHDL · Bash**
```console
$ super cancel --check 1
○ canceled · increment_never_decreases · #1
To check again: super check supertests/increment.vhd::increment_never_decreases
```
If stopping takes longer, the CLI prints **Cancellation requested** and a `super status --watch`
command to follow the outcome. A check that finishes before cancellation keeps its result.
For several checks, the CLI summarizes what stopped. Completed checks remain unchanged:
**Python · Bash**
```console
$ super cancel .
supertest-python
2 canceled · 1 already finished
SUPERTEST · STATUS · CHECK
collapsing_spaces_again_changes_nothing · canceled · #1
empty_text_stays_empty · canceled · #2
single_spaces_stay_unchanged · pass · #3
```
**Rust · Bash**
```console
$ super cancel .
supertest-rust
2 canceled · 1 already finished
SUPERTEST · STATUS · CHECK
collapsing_spaces_again_changes_nothing · canceled · #1
empty_text_stays_empty · canceled · #2
single_spaces_stay_unchanged · pass · #3
```
**C · Bash**
```console
$ super cancel .
supertest-c
2 canceled · 1 already finished
SUPERTEST · STATUS · CHECK
collapsing_spaces_again_changes_nothing · canceled · #1
empty_text_stays_empty · canceled · #2
single_spaces_stay_unchanged · pass · #3
```
**C# · Bash**
```console
$ super cancel .
supertest-csharp
2 canceled · 1 already finished
SUPERTEST · STATUS · CHECK
CollapsingSpacesAgainChangesNothing · canceled · #1
EmptyTextStaysEmpty · canceled · #2
SingleSpacesStayUnchanged · pass · #3
```
**JavaScript · Bash**
```console
$ super cancel .
supertest-javascript
2 canceled · 1 already finished
SUPERTEST · STATUS · CHECK
collapsingSpacesAgainChangesNothing · canceled · #1
emptyTextStaysEmpty · canceled · #2
singleSpacesStayUnchanged · pass · #3
```
**Java · Bash**
```console
$ super cancel .
supertest-java
2 canceled · 1 already finished
SUPERTEST · STATUS · CHECK
collapsingSpacesAgainChangesNothing · canceled · #1
emptyTextStaysEmpty · canceled · #2
singleSpacesStayUnchanged · pass · #3
```
**VHDL · Bash**
```console
$ super cancel .
supertest-vhdl
2 canceled · 1 already finished
SUPERTEST · STATUS · CHECK
increment_never_decreases · canceled · #1
zero_increments_to_one · canceled · #2
ordinary_values_increment · pass · #3
```
Cancellation also stops pending background work, including fix proposals. Existing results and
findings remain available.
Cancellation affects everyone watching the same check. To close your view while checks keep
running, press Esc or Ctrl+C instead.
Run `super check` with your chosen path to check again. Schematic creates a new attempt and retains
the canceled attempt in history. If cancellation is still underway, Super CLI waits before submitting
the new attempt.