Using the CLI

Check commands

Check supertests, inspect their results, apply proposed fixes, and cancel checks.

`pup check`

Pup uses mathematical reasoning to check whether your supertests’ assertions hold for every input allowed by their types and assumptions.

pup check [path] [options]

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

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

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

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

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

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

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

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

Pup 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 pup cancel.

Select supertests

Path	What Pup checks
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>:

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

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

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

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

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

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

$ pup 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, qualifications, 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`	Pup verified that the supertest’s requirement holds for every input it covers.
`fail`	Pup 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, qualifications, 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 pup status --watch to follow updates later.

When Pup proposes a fix, the result includes a pup fix command to review it.

Explore results

pup check and pup 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:

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

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

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

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

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

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

$ pup 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, any qualifications, 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.

   This example uses ASCII 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.

   This example uses ASCII 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.

   This example uses ASCII 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.

   This example uses ASCII 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.

   This example uses ASCII 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.

   This example uses ASCII 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.

   This example uses values from 0 through 255.

   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 Pup accepts the checks:

$ pup check supertests/collapse_spaces.py --detach
  Accepted 1 check · supertest-python · 8e44bea
  collapsing_spaces_again_changes_nothing · #4
  Checks continue remotely.
  Watch: pup status --check 4 --watch

$ pup check tests/collapse_spaces.rs --detach
  Accepted 1 check · supertest-rust · 8e44bea
  collapsing_spaces_again_changes_nothing · #4
  Checks continue remotely.
  Watch: pup status --check 4 --watch

$ pup check supertests/collapse_spaces.c --detach
  Accepted 1 check · supertest-c · 8e44bea
  collapsing_spaces_again_changes_nothing · #4
  Checks continue remotely.
  Watch: pup status --check 4 --watch

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

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

$ pup check src/test/java/texttools/CollapseSpaces.java --detach
  Accepted 1 check · supertest-java · 8e44bea
  collapsingSpacesAgainChangesNothing · #4
  Checks continue remotely.
  Watch: pup status --check 4 --watch

$ pup check supertests/increment.vhd --detach
  Accepted 1 check · supertest-vhdl · 8e44bea
  increment_never_decreases · #4
  Checks continue remotely.
  Watch: pup status --check 4 --watch

Follow the printed pup status command to return to the live view. Use pup cancel if you want to stop the checks themselves.

Select source

Pup checks 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:

$ pup check --commit HEAD~1

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

$ pup check --problems

Add a path to narrow that run’s selection. Pup checks your current source and, if there are no problems to recheck, says so without starting checks. A passing recheck applies only to the selected supertests. Run pup check to check the whole repository.

See Troubleshooting for blocked or canceled checks.

`pup status`

pup status [path] [options]

Inspect existing checks without starting new ones. With no target, Pup shows the latest run in the linked repository and exits. To inspect one check, use --check:

$ pup 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: pup status --check 4 --details

$ pup 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: pup status --check 4 --details

$ pup 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: pup status --check 4 --details

$ pup 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: pup status --check 4 --details

$ pup 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: pup status --check 4 --details

$ pup 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: pup status --check 4 --details

$ pup 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: pup 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 Pup 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 pup 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, qualifications, 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

$ pup status --watch

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

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

`pup fix`

Review and apply a proposed fix for a problem found by Pup.

pup fix [path] [options]

Use pup status to see available proposals, or pup status --watch to follow updates. Proposals may arrive after the check result, and not every finding has a fix.

Run the pup fix command shown with the result to review the patch and choose whether to apply it:

$ pup 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: pup check supertests/collapse_spaces.py::collapsing_spaces_again_changes_nothing

$ pup 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: pup check tests/collapse_spaces.rs::collapsing_spaces_again_changes_nothing

$ pup 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: pup check supertests/collapse_spaces.c::collapsing_spaces_again_changes_nothing

$ pup 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: pup check supertests/CollapseSpaces.cs::CollapsingSpacesAgainChangesNothing

$ pup 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: pup check supertests/collapse_spaces.js::collapsingSpacesAgainChangesNothing

$ pup 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: pup check src/test/java/texttools/CollapseSpaces.java::collapsingSpacesAgainChangesNothing

$ pup 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: pup check supertests/increment.vhd::increment_never_decreases

Changes remain uncommitted. Follow the printed pup check command to include the changes and verify the updated code.

You can also run pup fix while a proposal is pending. It waits for the proposal; Ctrl+C stops waiting without canceling the check.

Select a fix

Command	Selects
`pup fix`	The single problematic supertest in the latest run.
`pup fix <path>`	The latest check for the supertest selected by the path.
`pup 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.

`pup cancel`

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

Stop checks with pup 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.

Pup confirms when the check has stopped:

$ pup cancel --check 1
  ○ canceled · collapsing_spaces_again_changes_nothing · #1

  To check again: pup check supertests/collapse_spaces.py::collapsing_spaces_again_changes_nothing

$ pup cancel --check 1
  ○ canceled · collapsing_spaces_again_changes_nothing · #1

  To check again: pup check tests/collapse_spaces.rs::collapsing_spaces_again_changes_nothing

$ pup cancel --check 1
  ○ canceled · collapsing_spaces_again_changes_nothing · #1

  To check again: pup check supertests/collapse_spaces.c::collapsing_spaces_again_changes_nothing

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

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

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

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

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

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

$ pup cancel --check 1
  ○ canceled · increment_never_decreases · #1

  To check again: pup check supertests/increment.vhd::increment_never_decreases

If stopping takes longer, Pup prints Cancellation requested and a pup status --watch command to follow the outcome. A check that finishes before cancellation keeps its result.

For several checks, Pup summarizes what stopped. Completed checks remain unchanged:

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

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

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

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

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

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

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

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

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

$ pup 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 pup check with your chosen path to check again. Pup creates a new attempt and keeps the canceled one in history. If cancellation is still underway, Pup waits before starting the new attempt.

Check commands

pup check#

Select supertests#

Result meanings#

Explore results#

Leave checks running#

Select source#

Recheck findings#

pup status#

Follow updates#

Print history#

pup fix#

Select a fix#

Preview and options#

pup cancel#