Using the CLI

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.

super check [path] [options]

Start a check by passing a file containing a supertest to super check:

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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.

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.
`<file>::<supertest_name>`	One named supertest.

Paths are relative to your current directory. To check one supertest in a file, append ::<supertest_name>:

$ super check 'supertests/collapse_spaces.py::collapsing_spaces_again_changes_nothing'

$ super check 'tests/collapse_spaces.rs::collapsing_spaces_again_changes_nothing'

$ super check 'supertests/collapse_spaces.c::collapsing_spaces_again_changes_nothing'

$ super check 'supertests/CollapseSpaces.cs::CollapsingSpacesAgainChangesNothing'

$ super check 'supertests/collapse_spaces.js::collapsingSpacesAgainChangesNothing'

$ super check 'src/test/java/texttools/CollapseSpaces.java::collapsingSpacesAgainChangesNothing'

$ 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 <revision>`	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 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 to follow updates later.

When a fix proposal is available, the result includes a super fix command to review it.

Explore results

super check and super status --watch 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:

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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:

  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

  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

  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

  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

  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

  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

  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:

$ 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

$ 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

$ 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

$ super check supertests/CollapseSpaces.cs --detach
  Accepted 1 check · supertest-csharp · 8e44bea
  CollapsingSpacesAgainChangesNothing · #4
  Checks continue remotely.
  Watch: super status --check 4 --watch

$ super check supertests/collapse_spaces.js --detach
  Accepted 1 check · supertest-javascript · 8e44bea
  collapsingSpacesAgainChangesNothing · #4
  Checks continue remotely.
  Watch: super status --check 4 --watch

$ 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

$ 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 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:

$ super check --commit HEAD~1

Checking leaves your files, branch, and staging unchanged. See Source and commits 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:

$ 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 for blocked or canceled checks.

`super status`

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:

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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 <number>`	One exact check, even if your local commit has changed.
`--run <uuid>`	One exact run, using its ID from JSON output.

Choose one target. Paths use the same selection syntax as super check. 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 <number>`	Load history before this check number. Requires `--history`.
`--json`	Return full structured results. With `--watch`, stream until checks and pending updates finish.

Follow updates

$ super status --watch

Add a path, --check, or --run to watch a particular selection. This uses the same tables, details, history, and controls 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:

$ super status --check 4 --history

Add --details to include each attempt’s full details. For older history, follow the --history --before <number> command printed at the end of the output.

`super fix`

Review and apply a proposed fix for a reported problem.

super fix [path] [options]

Use super status to see available proposals, or super status --watch 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:

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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

$ 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 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 <path>`	The latest check for the supertest selected by the path.
`super fix --check <number>`	A particular check, including an older one.

A file or directory path must select one supertest. If a file contains several, use <file>::<supertest_name>. 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 cancel`

super cancel <path>
super cancel --run <uuid>
super cancel --check <number>

Stop checks with super cancel. Pass a file or directory to select the latest check for each matching supertest, or append ::<supertest_name> to select one. Use --check for an exact check or --run for an exact run.

Super CLI confirms when the check has stopped:

$ 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

$ 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

$ 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

$ super cancel --check 1
  ○ canceled · CollapsingSpacesAgainChangesNothing · #1

  To check again: super check supertests/CollapseSpaces.cs::CollapsingSpacesAgainChangesNothing

$ super cancel --check 1
  ○ canceled · collapsingSpacesAgainChangesNothing · #1

  To check again: super check supertests/collapse_spaces.js::collapsingSpacesAgainChangesNothing

$ super cancel --check 1
  ○ canceled · collapsingSpacesAgainChangesNothing · #1

  To check again: super check src/test/java/texttools/CollapseSpaces.java::collapsingSpacesAgainChangesNothing

$ 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:

$ 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

$ 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

$ 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

$ super cancel .
  supertest-csharp
  2 canceled · 1 already finished

  SUPERTEST                           · STATUS   · CHECK
  CollapsingSpacesAgainChangesNothing · canceled · #1
  EmptyTextStaysEmpty                 · canceled · #2
  SingleSpacesStayUnchanged           · pass     · #3

$ super cancel .
  supertest-javascript
  2 canceled · 1 already finished

  SUPERTEST                           · STATUS   · CHECK
  collapsingSpacesAgainChangesNothing · canceled · #1
  emptyTextStaysEmpty                 · canceled · #2
  singleSpacesStayUnchanged           · pass     · #3

$ super cancel .
  supertest-java
  2 canceled · 1 already finished

  SUPERTEST                           · STATUS   · CHECK
  collapsingSpacesAgainChangesNothing · canceled · #1
  emptyTextStaysEmpty                 · canceled · #2
  singleSpacesStayUnchanged           · pass     · #3

$ 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.

Check commands

super check#

Select supertests#

Result meanings#

Explore results#

Leave checks running#

Select source#

Recheck findings#

super status#

Follow updates#

Print history#

super fix#

Select a fix#

Preview and options#

super cancel#