diff --git a/exercises/practice/acronym/.meta/template.j2 b/exercises/practice/acronym/.meta/template.j2
index f0541652..764d713a 100644
--- a/exercises/practice/acronym/.meta/template.j2
+++ b/exercises/practice/acronym/.meta/template.j2
@@ -1,10 +1,10 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["phrase"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["phrase"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
 # bash-specific test: Focus the student's attention on the effects of 
@@ -12,8 +12,8 @@
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
 @test "contains shell globbing character" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "Two * Words"
-  assert_success
-  assert_output "TW"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "Two * Words"
+    assert_success
+    assert_output "TW"
 }
diff --git a/exercises/practice/acronym/acronym.bats b/exercises/practice/acronym/acronym.bats
index a4ebf3d5..f268d865 100644
--- a/exercises/practice/acronym/acronym.bats
+++ b/exercises/practice/acronym/acronym.bats
@@ -1,69 +1,69 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "basic" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "Portable Network Graphics"
-  assert_success
-  assert_output "PNG"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "Portable Network Graphics"
+    assert_success
+    assert_output "PNG"
 }
 
 @test "lowercase words" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "Ruby on Rails"
-  assert_success
-  assert_output "ROR"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "Ruby on Rails"
+    assert_success
+    assert_output "ROR"
 }
 
 @test "punctuation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "First In, First Out"
-  assert_success
-  assert_output "FIFO"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "First In, First Out"
+    assert_success
+    assert_output "FIFO"
 }
 
 @test "all caps word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "GNU Image Manipulation Program"
-  assert_success
-  assert_output "GIMP"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "GNU Image Manipulation Program"
+    assert_success
+    assert_output "GIMP"
 }
 
 @test "punctuation without whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "Complementary metal-oxide semiconductor"
-  assert_success
-  assert_output "CMOS"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "Complementary metal-oxide semiconductor"
+    assert_success
+    assert_output "CMOS"
 }
 
 @test "very long abbreviation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "Rolling On The Floor Laughing So Hard That My Dogs Came Over And Licked Me"
-  assert_success
-  assert_output "ROTFLSHTMDCOALM"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "Rolling On The Floor Laughing So Hard That My Dogs Came Over And Licked Me"
+    assert_success
+    assert_output "ROTFLSHTMDCOALM"
 }
 
 @test "consecutive delimiters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "Something - I made up from thin air"
-  assert_success
-  assert_output "SIMUFTA"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "Something - I made up from thin air"
+    assert_success
+    assert_output "SIMUFTA"
 }
 
 @test "apostrophes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "Halley's Comet"
-  assert_success
-  assert_output "HC"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "Halley's Comet"
+    assert_success
+    assert_output "HC"
 }
 
 @test "underscore emphasis" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "The Road _Not_ Taken"
-  assert_success
-  assert_output "TRNT"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "The Road _Not_ Taken"
+    assert_success
+    assert_output "TRNT"
 }
 
 # bash-specific test: Focus the student's attention on the effects of 
@@ -71,8 +71,8 @@ load bats-extra
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
 @test "contains shell globbing character" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash acronym.sh "Two * Words"
-  assert_success
-  assert_output "TW"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash acronym.sh "Two * Words"
+    assert_success
+    assert_output "TW"
 }
diff --git a/exercises/practice/affine-cipher/.meta/template.j2 b/exercises/practice/affine-cipher/.meta/template.j2
index bd49c498..c1203d5b 100644
--- a/exercises/practice/affine-cipher/.meta/template.j2
+++ b/exercises/practice/affine-cipher/.meta/template.j2
@@ -1,14 +1,14 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{ case["property"] }} {{ case["input"]["key"]["a"] }} {{ case["input"]["key"]["b"] }} "{{ case["input"]["phrase"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{ case["property"] }} {{ case["input"]["key"]["a"] }} {{ case["input"]["key"]["b"] }} "{{ case["input"]["phrase"] }}"
 {%- if case["expect_error"] %}
-  assert_failure
-  assert_output "{{ case["expect_error_msg"] }}"
+    assert_failure
+    assert_output "{{ case["expect_error_msg"] }}"
 {%- else %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/affine-cipher/affine_cipher.bats b/exercises/practice/affine-cipher/affine_cipher.bats
index f40b3d54..75114239 100644
--- a/exercises/practice/affine-cipher/affine_cipher.bats
+++ b/exercises/practice/affine-cipher/affine_cipher.bats
@@ -1,116 +1,117 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "encode yes" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 5 7 "yes"
-  assert_success
-  assert_output "xbt"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 5 7 "yes"
+    assert_success
+    assert_output "xbt"
 }
 
 @test "encode no" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 15 18 "no"
-  assert_success
-  assert_output "fu"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 15 18 "no"
+    assert_success
+    assert_output "fu"
 }
 
 @test "encode OMG" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 21 3 "OMG"
-  assert_success
-  assert_output "lvz"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 21 3 "OMG"
+    assert_success
+    assert_output "lvz"
 }
 
 @test "encode O M G" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 25 47 "O M G"
-  assert_success
-  assert_output "hjp"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 25 47 "O M G"
+    assert_success
+    assert_output "hjp"
 }
 
 @test "encode mindblowingly" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 11 15 "mindblowingly"
-  assert_success
-  assert_output "rzcwa gnxzc dgt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 11 15 "mindblowingly"
+    assert_success
+    assert_output "rzcwa gnxzc dgt"
 }
 
 @test "encode numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 3 4 "Testing,1 2 3, testing."
-  assert_success
-  assert_output "jqgjc rw123 jqgjc rw"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 3 4 "Testing,1 2 3, testing."
+    assert_success
+    assert_output "jqgjc rw123 jqgjc rw"
 }
 
 @test "encode deep thought" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 5 17 "Truth is fiction."
-  assert_success
-  assert_output "iynia fdqfb ifje"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 5 17 "Truth is fiction."
+    assert_success
+    assert_output "iynia fdqfb ifje"
 }
 
 @test "encode all the letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 17 33 "The quick brown fox jumps over the lazy dog."
-  assert_success
-  assert_output "swxtj npvyk lruol iejdc blaxk swxmh qzglf"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 17 33 "The quick brown fox jumps over the lazy dog."
+    assert_success
+    assert_output "swxtj npvyk lruol iejdc blaxk swxmh qzglf"
 }
 
 @test "encode with a not coprime to m" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh encode 6 17 "This is a test."
-  assert_failure
-  assert_output "a and m must be coprime."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh encode 6 17 "This is a test."
+    assert_failure
+    assert_output "a and m must be coprime."
 }
 
 @test "decode exercism" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh decode 3 7 "tytgn fjr"
-  assert_success
-  assert_output "exercism"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh decode 3 7 "tytgn fjr"
+    assert_success
+    assert_output "exercism"
 }
 
 @test "decode a sentence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh decode 19 16 "qdwju nqcro muwhn odqun oppmd aunwd o"
-  assert_success
-  assert_output "anobstacleisoftenasteppingstone"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh decode 19 16 "qdwju nqcro muwhn odqun oppmd aunwd o"
+    assert_success
+    assert_output "anobstacleisoftenasteppingstone"
 }
 
 @test "decode numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh decode 25 7 "odpoz ub123 odpoz ub"
-  assert_success
-  assert_output "testing123testing"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh decode 25 7 "odpoz ub123 odpoz ub"
+    assert_success
+    assert_output "testing123testing"
 }
 
 @test "decode all the letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh decode 17 33 "swxtj npvyk lruol iejdc blaxk swxmh qzglf"
-  assert_success
-  assert_output "thequickbrownfoxjumpsoverthelazydog"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh decode 17 33 "swxtj npvyk lruol iejdc blaxk swxmh qzglf"
+    assert_success
+    assert_output "thequickbrownfoxjumpsoverthelazydog"
 }
 
 @test "decode with no spaces in input" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh decode 17 33 "swxtjnpvyklruoliejdcblaxkswxmhqzglf"
-  assert_success
-  assert_output "thequickbrownfoxjumpsoverthelazydog"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh decode 17 33 "swxtjnpvyklruoliejdcblaxkswxmhqzglf"
+    assert_success
+    assert_output "thequickbrownfoxjumpsoverthelazydog"
 }
 
 @test "decode with too many spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh decode 15 16 "vszzm    cly   yd cg    qdp"
-  assert_success
-  assert_output "jollygreengiant"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh decode 15 16 "vszzm    cly   yd cg    qdp"
+    assert_success
+    assert_output "jollygreengiant"
 }
 
 @test "decode with a not coprime to m" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash affine_cipher.sh decode 13 5 "Test"
-  assert_failure
-  assert_output "a and m must be coprime."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash affine_cipher.sh decode 13 5 "Test"
+    assert_failure
+    assert_output "a and m must be coprime."
 }
+
diff --git a/exercises/practice/anagram/.meta/template.j2 b/exercises/practice/anagram/.meta/template.j2
index 871104ad..a6622eeb 100644
--- a/exercises/practice/anagram/.meta/template.j2
+++ b/exercises/practice/anagram/.meta/template.j2
@@ -1,13 +1,13 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["subject"] }}" "{{ case["input"]["candidates"] | join(" ") }}"
-  assert_success
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["subject"] }}" "{{ case["input"]["candidates"] | join(" ") }}"
+    assert_success
 {%- if case["expected"] | length == 0 %}
-  refute_output
+    refute_output
 {%- else %}
-  assert_output "{{ case["expected"] | join(" ") }}"
+    assert_output "{{ case["expected"] | join(" ") }}"
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/anagram/anagram.bats b/exercises/practice/anagram/anagram.bats
index a90718ff..cef8c530 100644
--- a/exercises/practice/anagram/anagram.bats
+++ b/exercises/practice/anagram/anagram.bats
@@ -1,116 +1,117 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "no matches" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "diaper" "hello world zombies pants"
-  assert_success
-  refute_output
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "diaper" "hello world zombies pants"
+    assert_success
+    refute_output
 }
 
 @test "detects two anagrams" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "solemn" "lemons cherry melons"
-  assert_success
-  assert_output "lemons melons"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "solemn" "lemons cherry melons"
+    assert_success
+    assert_output "lemons melons"
 }
 
 @test "does not detect anagram subsets" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "good" "dog goody"
-  assert_success
-  refute_output
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "good" "dog goody"
+    assert_success
+    refute_output
 }
 
 @test "detects anagram" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "listen" "enlists google inlets banana"
-  assert_success
-  assert_output "inlets"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "listen" "enlists google inlets banana"
+    assert_success
+    assert_output "inlets"
 }
 
 @test "detects three anagrams" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "allergy" "gallery ballerina regally clergy largely leading"
-  assert_success
-  assert_output "gallery regally largely"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "allergy" "gallery ballerina regally clergy largely leading"
+    assert_success
+    assert_output "gallery regally largely"
 }
 
 @test "detects multiple anagrams with different case" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "nose" "Eons ONES"
-  assert_success
-  assert_output "Eons ONES"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "nose" "Eons ONES"
+    assert_success
+    assert_output "Eons ONES"
 }
 
 @test "does not detect non-anagrams with identical checksum" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "mass" "last"
-  assert_success
-  refute_output
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "mass" "last"
+    assert_success
+    refute_output
 }
 
 @test "detects anagrams case-insensitively" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "Orchestra" "cashregister Carthorse radishes"
-  assert_success
-  assert_output "Carthorse"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "Orchestra" "cashregister Carthorse radishes"
+    assert_success
+    assert_output "Carthorse"
 }
 
 @test "detects anagrams using case-insensitive subject" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "Orchestra" "cashregister carthorse radishes"
-  assert_success
-  assert_output "carthorse"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "Orchestra" "cashregister carthorse radishes"
+    assert_success
+    assert_output "carthorse"
 }
 
 @test "detects anagrams using case-insensitive possible matches" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "orchestra" "cashregister Carthorse radishes"
-  assert_success
-  assert_output "Carthorse"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "orchestra" "cashregister Carthorse radishes"
+    assert_success
+    assert_output "Carthorse"
 }
 
 @test "does not detect an anagram if the original word is repeated" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "go" "goGoGO"
-  assert_success
-  refute_output
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "go" "goGoGO"
+    assert_success
+    refute_output
 }
 
 @test "anagrams must use all letters exactly once" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "tapper" "patter"
-  assert_success
-  refute_output
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "tapper" "patter"
+    assert_success
+    refute_output
 }
 
 @test "words are not anagrams of themselves" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "BANANA" "BANANA"
-  assert_success
-  refute_output
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "BANANA" "BANANA"
+    assert_success
+    refute_output
 }
 
 @test "words are not anagrams of themselves even if letter case is partially different" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "BANANA" "Banana"
-  assert_success
-  refute_output
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "BANANA" "Banana"
+    assert_success
+    refute_output
 }
 
 @test "words are not anagrams of themselves even if letter case is completely different" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "BANANA" "banana"
-  assert_success
-  refute_output
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "BANANA" "banana"
+    assert_success
+    refute_output
 }
 
 @test "words other than themselves can be anagrams" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash anagram.sh "LISTEN" "LISTEN Silent"
-  assert_success
-  assert_output "Silent"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash anagram.sh "LISTEN" "LISTEN Silent"
+    assert_success
+    assert_output "Silent"
 }
+
diff --git a/exercises/practice/armstrong-numbers/.meta/template.j2 b/exercises/practice/armstrong-numbers/.meta/template.j2
index 4398346b..00acad44 100644
--- a/exercises/practice/armstrong-numbers/.meta/template.j2
+++ b/exercises/practice/armstrong-numbers/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{ case["input"]["number"] }}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{ case["input"]["number"] }}
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/armstrong-numbers/armstrong_numbers.bats b/exercises/practice/armstrong-numbers/armstrong_numbers.bats
index 482a33a2..508006ca 100644
--- a/exercises/practice/armstrong-numbers/armstrong_numbers.bats
+++ b/exercises/practice/armstrong-numbers/armstrong_numbers.bats
@@ -1,67 +1,68 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test 'Zero is an Armstrong number' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 0
-  assert_success
-  assert_output "true"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 0
+    assert_success
+    assert_output "true"
 }
 
 @test 'Single-digit numbers are Armstrong numbers' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 5
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 5
+    assert_success
+    assert_output "true"
 }
 
 @test 'There are no two-digit Armstrong numbers' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 10
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 10
+    assert_success
+    assert_output "false"
 }
 
 @test 'Three-digit number that is an Armstrong number' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 153
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 153
+    assert_success
+    assert_output "true"
 }
 
 @test 'Three-digit number that is not an Armstrong number' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 100
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 100
+    assert_success
+    assert_output "false"
 }
 
 @test 'Four-digit number that is an Armstrong number' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 9474
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 9474
+    assert_success
+    assert_output "true"
 }
 
 @test 'Four-digit number that is not an Armstrong number' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 9475
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 9475
+    assert_success
+    assert_output "false"
 }
 
 @test 'Seven-digit number that is an Armstrong number' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 9926315
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 9926315
+    assert_success
+    assert_output "true"
 }
 
 @test 'Seven-digit number that is not an Armstrong number' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash armstrong_numbers.sh 9926314
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash armstrong_numbers.sh 9926314
+    assert_success
+    assert_output "false"
 }
+
diff --git a/exercises/practice/atbash-cipher/.meta/template.j2 b/exercises/practice/atbash-cipher/.meta/template.j2
index d4da9fb2..b772f5e6 100644
--- a/exercises/practice/atbash-cipher/.meta/template.j2
+++ b/exercises/practice/atbash-cipher/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{ case["property"] }} "{{ case["input"]["phrase"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{ case["property"] }} "{{ case["input"]["phrase"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/atbash-cipher/atbash_cipher.bats b/exercises/practice/atbash-cipher/atbash_cipher.bats
index e086f99b..b6a0c323 100644
--- a/exercises/practice/atbash-cipher/atbash_cipher.bats
+++ b/exercises/practice/atbash-cipher/atbash_cipher.bats
@@ -1,102 +1,103 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "encode yes" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh encode "yes"
-  assert_success
-  assert_output "bvh"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh encode "yes"
+    assert_success
+    assert_output "bvh"
 }
 
 @test "encode no" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh encode "no"
-  assert_success
-  assert_output "ml"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh encode "no"
+    assert_success
+    assert_output "ml"
 }
 
 @test "encode OMG" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh encode "OMG"
-  assert_success
-  assert_output "lnt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh encode "OMG"
+    assert_success
+    assert_output "lnt"
 }
 
 @test "encode spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh encode "O M G"
-  assert_success
-  assert_output "lnt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh encode "O M G"
+    assert_success
+    assert_output "lnt"
 }
 
 @test "encode mindblowingly" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh encode "mindblowingly"
-  assert_success
-  assert_output "nrmwy oldrm tob"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh encode "mindblowingly"
+    assert_success
+    assert_output "nrmwy oldrm tob"
 }
 
 @test "encode numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh encode "Testing,1 2 3, testing."
-  assert_success
-  assert_output "gvhgr mt123 gvhgr mt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh encode "Testing,1 2 3, testing."
+    assert_success
+    assert_output "gvhgr mt123 gvhgr mt"
 }
 
 @test "encode deep thought" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh encode "Truth is fiction."
-  assert_success
-  assert_output "gifgs rhurx grlm"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh encode "Truth is fiction."
+    assert_success
+    assert_output "gifgs rhurx grlm"
 }
 
 @test "encode all the letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh encode "The quick brown fox jumps over the lazy dog."
-  assert_success
-  assert_output "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh encode "The quick brown fox jumps over the lazy dog."
+    assert_success
+    assert_output "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
 }
 
 @test "decode exercism" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh decode "vcvix rhn"
-  assert_success
-  assert_output "exercism"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh decode "vcvix rhn"
+    assert_success
+    assert_output "exercism"
 }
 
 @test "decode a sentence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh decode "zmlyh gzxov rhlug vmzhg vkkrm thglm v"
-  assert_success
-  assert_output "anobstacleisoftenasteppingstone"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh decode "zmlyh gzxov rhlug vmzhg vkkrm thglm v"
+    assert_success
+    assert_output "anobstacleisoftenasteppingstone"
 }
 
 @test "decode numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh decode "gvhgr mt123 gvhgr mt"
-  assert_success
-  assert_output "testing123testing"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh decode "gvhgr mt123 gvhgr mt"
+    assert_success
+    assert_output "testing123testing"
 }
 
 @test "decode all the letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh decode "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
-  assert_success
-  assert_output "thequickbrownfoxjumpsoverthelazydog"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh decode "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+    assert_success
+    assert_output "thequickbrownfoxjumpsoverthelazydog"
 }
 
 @test "decode with too many spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh decode "vc vix    r hn"
-  assert_success
-  assert_output "exercism"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh decode "vc vix    r hn"
+    assert_success
+    assert_output "exercism"
 }
 
 @test "decode with no spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash atbash_cipher.sh decode "zmlyhgzxovrhlugvmzhgvkkrmthglmv"
-  assert_success
-  assert_output "anobstacleisoftenasteppingstone"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash atbash_cipher.sh decode "zmlyhgzxovrhlugvmzhgvkkrmthglmv"
+    assert_success
+    assert_output "anobstacleisoftenasteppingstone"
 }
+
diff --git a/exercises/practice/bob/.meta/template.j2 b/exercises/practice/bob/.meta/template.j2
index 3572f2ba..0a2f2b82 100644
--- a/exercises/practice/bob/.meta/template.j2
+++ b/exercises/practice/bob/.meta/template.j2
@@ -1,30 +1,30 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} ${{ case["input"]["heyBob"] | repr }}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} ${{ case["input"]["heyBob"] | repr }}
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
 # bash-specific tests
 @test "no input is silence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }}
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }}
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "yelling a filename expansion" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} '*READ* !'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} '*READ* !'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "asking a filename expansion" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} 'bob???'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} 'bob???'
+    assert_success
+    assert_output "Sure."
 }
diff --git a/exercises/practice/bob/bob.bats b/exercises/practice/bob/bob.bats
index 22098f1a..fcaa78d2 100644
--- a/exercises/practice/bob/bob.bats
+++ b/exercises/practice/bob/bob.bats
@@ -1,208 +1,208 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "asking a question" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'Does this cryogenic chamber make me look fat?'
-  assert_success
-  assert_output "Sure."
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'Does this cryogenic chamber make me look fat?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "shouting" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'WATCH OUT!'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'WATCH OUT!'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "forceful question" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $"WHAT'S GOING ON?"
-  assert_success
-  assert_output "Calm down, I know what I'm doing!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $"WHAT'S GOING ON?"
+    assert_success
+    assert_output "Calm down, I know what I'm doing!"
 }
 
 @test "silence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $''
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $''
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "stating something" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'Tom-ay-to, tom-aaaah-to.'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'Tom-ay-to, tom-aaaah-to.'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "asking a numeric question" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'You are, what, like 15?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'You are, what, like 15?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "asking gibberish" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'fffbbcbeab?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'fffbbcbeab?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "question with no letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'4?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'4?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "non-letters with question" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $':) ?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $':) ?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "prattling on" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'Wait! Hang on. Are you going to be OK?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'Wait! Hang on. Are you going to be OK?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "ending with whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'Okay if like my  spacebar  quite a bit?   '
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'Okay if like my  spacebar  quite a bit?   '
+    assert_success
+    assert_output "Sure."
 }
 
 @test "multiple line question" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'\nDoes this cryogenic chamber make\n me look fat?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'\nDoes this cryogenic chamber make\n me look fat?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "shouting gibberish" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'FCECDFCAAB'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'FCECDFCAAB'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "shouting a statement containing a question mark" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'DO LIONS EAT PEOPLE? AHHHHH.'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'DO LIONS EAT PEOPLE? AHHHHH.'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "shouting numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'1, 2, 3 GO!'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'1, 2, 3 GO!'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "shouting with special characters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "shouting with no exclamation mark" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'I HATE THE DENTIST'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'I HATE THE DENTIST'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "prolonged silence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'          '
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'          '
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "alternate silence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'\t\t\t\t\t\t\t\t\t\t'
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'\t\t\t\t\t\t\t\t\t\t'
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "other whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'\n\r \t'
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'\n\r \t'
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "talking forcefully" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'Hi there!'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'Hi there!'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "using acronyms in regular speech" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $"It's OK if you don't want to go work for NASA."
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $"It's OK if you don't want to go work for NASA."
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "no letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'1, 2, 3'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'1, 2, 3'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "statement containing question mark" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'Ending with ? means a question.'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'Ending with ? means a question.'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "starting with whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'         hmmmmmmm...'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'         hmmmmmmm...'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "non-question ending with whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh $'This is a statement ending with whitespace      '
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh $'This is a statement ending with whitespace      '
+    assert_success
+    assert_output "Whatever."
 }
 
 # bash-specific tests
 @test "no input is silence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "yelling a filename expansion" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh '*READ* !'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh '*READ* !'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "asking a filename expansion" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash bob.sh 'bob???'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash bob.sh 'bob???'
+    assert_success
+    assert_output "Sure."
 }
diff --git a/exercises/practice/collatz-conjecture/.meta/template.j2 b/exercises/practice/collatz-conjecture/.meta/template.j2
index 917d0de8..361f2ec7 100644
--- a/exercises/practice/collatz-conjecture/.meta/template.j2
+++ b/exercises/practice/collatz-conjecture/.meta/template.j2
@@ -1,14 +1,14 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{ case["input"]["number"] }}
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{ case["input"]["number"] }}
 {%- if case["expect_error"] %}
-  assert_failure
-  assert_output "Error: {{ case["expect_error_msg"] }}"
+    assert_failure
+    assert_output "Error: {{ case["expect_error_msg"] }}"
 {%- else %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/collatz-conjecture/collatz_conjecture.bats b/exercises/practice/collatz-conjecture/collatz_conjecture.bats
index a9aba2d6..989204c2 100644
--- a/exercises/practice/collatz-conjecture/collatz_conjecture.bats
+++ b/exercises/practice/collatz-conjecture/collatz_conjecture.bats
@@ -1,46 +1,47 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "zero steps for one" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash collatz_conjecture.sh 1
-  assert_success
-  assert_output "0"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash collatz_conjecture.sh 1
+    assert_success
+    assert_output "0"
 }
 
 @test "divide if even" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash collatz_conjecture.sh 16
-  assert_success
-  assert_output "4"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash collatz_conjecture.sh 16
+    assert_success
+    assert_output "4"
 }
 
 @test "even and odd steps" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash collatz_conjecture.sh 12
-  assert_success
-  assert_output "9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash collatz_conjecture.sh 12
+    assert_success
+    assert_output "9"
 }
 
 @test "large number of even and odd steps" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash collatz_conjecture.sh 1000000
-  assert_success
-  assert_output "152"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash collatz_conjecture.sh 1000000
+    assert_success
+    assert_output "152"
 }
 
 @test "zero is an error" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash collatz_conjecture.sh 0
-  assert_failure
-  assert_output "Error: Only positive integers are allowed"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash collatz_conjecture.sh 0
+    assert_failure
+    assert_output "Error: Only positive integers are allowed"
 }
 
 @test "negative value is an error" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash collatz_conjecture.sh -15
-  assert_failure
-  assert_output "Error: Only positive integers are allowed"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash collatz_conjecture.sh -15
+    assert_failure
+    assert_output "Error: Only positive integers are allowed"
 }
+
diff --git a/exercises/practice/diamond/.meta/template.j2 b/exercises/practice/diamond/.meta/template.j2
index 2101981a..239d658b 100644
--- a/exercises/practice/diamond/.meta/template.j2
+++ b/exercises/practice/diamond/.meta/template.j2
@@ -1,13 +1,13 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected="$(cat << EOT
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected="$(cat << EOT
 {{ case["expected"] | join("\n") }}
 EOT
 )"
-  run bash {{ solution }} {{ case["input"]["letter"] }}
-  assert_success
-  assert_output "$expected"
+    run bash {{ solution }} {{ case["input"]["letter"] }}
+    assert_success
+    assert_output "$expected"
 }
 {% endfor %}
diff --git a/exercises/practice/diamond/diamond.bats b/exercises/practice/diamond/diamond.bats
index e09df27b..b6e98f0a 100644
--- a/exercises/practice/diamond/diamond.bats
+++ b/exercises/practice/diamond/diamond.bats
@@ -1,35 +1,35 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "Degenerate case with a single 'A' row" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected="$(cat << EOT
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected="$(cat << EOT
 A
 EOT
 )"
-  run bash diamond.sh A
-  assert_success
-  assert_output "$expected"
+    run bash diamond.sh A
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Degenerate case with no row containing 3 distinct groups of spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected="$(cat << EOT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected="$(cat << EOT
  A 
 B B
  A 
 EOT
 )"
-  run bash diamond.sh B
-  assert_success
-  assert_output "$expected"
+    run bash diamond.sh B
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Smallest non-degenerate case with odd diamond side length" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected="$(cat << EOT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected="$(cat << EOT
   A  
  B B 
 C   C
@@ -37,14 +37,14 @@ C   C
   A  
 EOT
 )"
-  run bash diamond.sh C
-  assert_success
-  assert_output "$expected"
+    run bash diamond.sh C
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Smallest non-degenerate case with even diamond side length" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected="$(cat << EOT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected="$(cat << EOT
    A   
   B B  
  C   C 
@@ -54,14 +54,14 @@ D     D
    A   
 EOT
 )"
-  run bash diamond.sh D
-  assert_success
-  assert_output "$expected"
+    run bash diamond.sh D
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Largest possible diamond" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected="$(cat << EOT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected="$(cat << EOT
                          A                         
                         B B                        
                        C   C                       
@@ -115,7 +115,8 @@ Z                                                 Z
                          A                         
 EOT
 )"
-  run bash diamond.sh Z
-  assert_success
-  assert_output "$expected"
+    run bash diamond.sh Z
+    assert_success
+    assert_output "$expected"
 }
+
diff --git a/exercises/practice/difference-of-squares/.meta/template.j2 b/exercises/practice/difference-of-squares/.meta/template.j2
index dda4eadd..edb1171b 100644
--- a/exercises/practice/difference-of-squares/.meta/template.j2
+++ b/exercises/practice/difference-of-squares/.meta/template.j2
@@ -1,11 +1,11 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{
-    case["property"] | camel_to_snake | replace("difference_of_squares", "difference")
-  }} {{ case["input"]["number"] }}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{
+        case["property"] | camel_to_snake | replace("difference_of_squares", "difference")
+    }} {{ case["input"]["number"] }}
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/difference-of-squares/difference_of_squares.bats b/exercises/practice/difference-of-squares/difference_of_squares.bats
index 53c3a8ab..3b53ee03 100644
--- a/exercises/practice/difference-of-squares/difference_of_squares.bats
+++ b/exercises/practice/difference-of-squares/difference_of_squares.bats
@@ -1,67 +1,68 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "square of sum 1" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh square_of_sum 1
-  assert_success
-  assert_output "1"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh square_of_sum 1
+    assert_success
+    assert_output "1"
 }
 
 @test "square of sum 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh square_of_sum 5
-  assert_success
-  assert_output "225"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh square_of_sum 5
+    assert_success
+    assert_output "225"
 }
 
 @test "square of sum 100" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh square_of_sum 100
-  assert_success
-  assert_output "25502500"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh square_of_sum 100
+    assert_success
+    assert_output "25502500"
 }
 
 @test "sum of squares 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh sum_of_squares 1
-  assert_success
-  assert_output "1"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh sum_of_squares 1
+    assert_success
+    assert_output "1"
 }
 
 @test "sum of squares 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh sum_of_squares 5
-  assert_success
-  assert_output "55"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh sum_of_squares 5
+    assert_success
+    assert_output "55"
 }
 
 @test "sum of squares 100" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh sum_of_squares 100
-  assert_success
-  assert_output "338350"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh sum_of_squares 100
+    assert_success
+    assert_output "338350"
 }
 
 @test "difference of squares 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh difference 1
-  assert_success
-  assert_output "0"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh difference 1
+    assert_success
+    assert_output "0"
 }
 
 @test "difference of squares 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh difference 5
-  assert_success
-  assert_output "170"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh difference 5
+    assert_success
+    assert_output "170"
 }
 
 @test "difference of squares 100" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash difference_of_squares.sh difference 100
-  assert_success
-  assert_output "25164150"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash difference_of_squares.sh difference 100
+    assert_success
+    assert_output "25164150"
 }
+
diff --git a/exercises/practice/gigasecond/.meta/template.j2 b/exercises/practice/gigasecond/.meta/template.j2
index 4a0fbd75..a7eb60b4 100644
--- a/exercises/practice/gigasecond/.meta/template.j2
+++ b/exercises/practice/gigasecond/.meta/template.j2
@@ -1,10 +1,10 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} '{{ case["input"]["moment"] }}'
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} '{{ case["input"]["moment"] }}'
 
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/gigasecond/gigasecond.bats b/exercises/practice/gigasecond/gigasecond.bats
index f401d86d..c9b4e3a1 100644
--- a/exercises/practice/gigasecond/gigasecond.bats
+++ b/exercises/practice/gigasecond/gigasecond.bats
@@ -1,44 +1,45 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test 'date only specification of time' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash gigasecond.sh '2011-04-25'
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash gigasecond.sh '2011-04-25'
 
-  assert_success
-  assert_output "2043-01-01T01:46:40"
+    assert_success
+    assert_output "2043-01-01T01:46:40"
 }
 
 @test 'second test for date only specification of time' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash gigasecond.sh '1977-06-13'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash gigasecond.sh '1977-06-13'
 
-  assert_success
-  assert_output "2009-02-19T01:46:40"
+    assert_success
+    assert_output "2009-02-19T01:46:40"
 }
 
 @test 'third test for date only specification of time' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash gigasecond.sh '1959-07-19'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash gigasecond.sh '1959-07-19'
 
-  assert_success
-  assert_output "1991-03-27T01:46:40"
+    assert_success
+    assert_output "1991-03-27T01:46:40"
 }
 
 @test 'full time specified' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash gigasecond.sh '2015-01-24T22:00:00'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash gigasecond.sh '2015-01-24T22:00:00'
 
-  assert_success
-  assert_output "2046-10-02T23:46:40"
+    assert_success
+    assert_output "2046-10-02T23:46:40"
 }
 
 @test 'full time with day roll-over' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash gigasecond.sh '2015-01-24T23:59:59'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash gigasecond.sh '2015-01-24T23:59:59'
 
-  assert_success
-  assert_output "2046-10-03T01:46:39"
+    assert_success
+    assert_output "2046-10-03T01:46:39"
 }
+
diff --git a/exercises/practice/grains/.meta/template.j2 b/exercises/practice/grains/.meta/template.j2
index 4b86303c..cc97ac15 100644
--- a/exercises/practice/grains/.meta/template.j2
+++ b/exercises/practice/grains/.meta/template.j2
@@ -1,19 +1,19 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
 {%- if case["property"] == "total" %}
-  run bash {{ solution }} total
+    run bash {{ solution }} total
 {%- else %}
-  run bash {{ solution }} {{ case["input"]["square"] }}
+    run bash {{ solution }} {{ case["input"]["square"] }}
 {%- endif %}
 {%- if case["expect_error"] %}
-  assert_failure
-  {#- The error message from the canonical data is not used. #}
-  assert_output "Error: invalid input"
+    assert_failure
+    {#- The error message from the canonical data is not used. #}
+    assert_output "Error: invalid input"
 {%- else %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/grains/grains.bats b/exercises/practice/grains/grains.bats
index b24c058c..b59c72d4 100644
--- a/exercises/practice/grains/grains.bats
+++ b/exercises/practice/grains/grains.bats
@@ -1,81 +1,82 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "grains on square 1" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 1
-  assert_success
-  assert_output "1"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 1
+    assert_success
+    assert_output "1"
 }
 
 @test "grains on square 2" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 2
-  assert_success
-  assert_output "2"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 2
+    assert_success
+    assert_output "2"
 }
 
 @test "grains on square 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 3
-  assert_success
-  assert_output "4"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 3
+    assert_success
+    assert_output "4"
 }
 
 @test "grains on square 4" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 4
-  assert_success
-  assert_output "8"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 4
+    assert_success
+    assert_output "8"
 }
 
 @test "grains on square 16" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 16
-  assert_success
-  assert_output "32768"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 16
+    assert_success
+    assert_output "32768"
 }
 
 @test "grains on square 32" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 32
-  assert_success
-  assert_output "2147483648"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 32
+    assert_success
+    assert_output "2147483648"
 }
 
 @test "grains on square 64" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 64
-  assert_success
-  assert_output "9223372036854775808"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 64
+    assert_success
+    assert_output "9223372036854775808"
 }
 
 @test "square 0 is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 0
-  assert_failure
-  assert_output "Error: invalid input"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 0
+    assert_failure
+    assert_output "Error: invalid input"
 }
 
 @test "negative square is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh -1
-  assert_failure
-  assert_output "Error: invalid input"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh -1
+    assert_failure
+    assert_output "Error: invalid input"
 }
 
 @test "square greater than 64 is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh 65
-  assert_failure
-  assert_output "Error: invalid input"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh 65
+    assert_failure
+    assert_output "Error: invalid input"
 }
 
 @test "returns the total number of grains on the board" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash grains.sh total
-  assert_success
-  assert_output "18446744073709551615"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash grains.sh total
+    assert_success
+    assert_output "18446744073709551615"
 }
+
diff --git a/exercises/practice/hamming/.meta/template.j2 b/exercises/practice/hamming/.meta/template.j2
index 63fbc61f..e767b85a 100644
--- a/exercises/practice/hamming/.meta/template.j2
+++ b/exercises/practice/hamming/.meta/template.j2
@@ -1,29 +1,29 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} '{{ case["input"]["strand1"] }}' '{{ case["input"]["strand2"] }}'
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} '{{ case["input"]["strand1"] }}' '{{ case["input"]["strand2"] }}'
 {%- if case["expect_error"] %}
-  assert_failure
-  assert_output --partial "{{ case["expect_error_msg"] }}"
+    assert_failure
+    assert_output --partial "{{ case["expect_error_msg"] }}"
 {%- else %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 {%- endif %}
 }
 {% endfor %}
 @test "no input" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }}
-  assert_failure
-  assert_output "Usage: {{ solution }} <string1> <string2>"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }}
+    assert_failure
+    assert_output "Usage: {{ solution }} <string1> <string2>"
 }
 
 @test "invalid input" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} 'A'
-  assert_failure
-  assert_output "Usage: {{ solution }} <string1> <string2>"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} 'A'
+    assert_failure
+    assert_output "Usage: {{ solution }} <string1> <string2>"
 }
 
 # Within [[...]] the == operator is a _pattern matching_ operator.
@@ -31,8 +31,8 @@
 # quoted to prevent interpretation as a glob-style pattern.
 
 @test "expose subtle '[[ \$x == \$y ]]' bug" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} 'AAA' 'A?A'
-  assert_success
-  assert_output "1"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} 'AAA' 'A?A'
+    assert_success
+    assert_output "1"
 }
diff --git a/exercises/practice/hamming/hamming.bats b/exercises/practice/hamming/hamming.bats
index 5cd33e5e..54ccde44 100644
--- a/exercises/practice/hamming/hamming.bats
+++ b/exercises/practice/hamming/hamming.bats
@@ -1,83 +1,83 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test 'empty strands' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh '' ''
-  assert_success
-  assert_output "0"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh '' ''
+    assert_success
+    assert_output "0"
 }
 
 @test 'single letter identical strands' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'A' 'A'
-  assert_success
-  assert_output "0"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'A' 'A'
+    assert_success
+    assert_output "0"
 }
 
 @test 'single letter different strands' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'G' 'T'
-  assert_success
-  assert_output "1"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'G' 'T'
+    assert_success
+    assert_output "1"
 }
 
 @test 'long identical strands' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'GGACTGAAATCTG' 'GGACTGAAATCTG'
-  assert_success
-  assert_output "0"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'GGACTGAAATCTG' 'GGACTGAAATCTG'
+    assert_success
+    assert_output "0"
 }
 
 @test 'long different strands' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'GGACGGATTCTG' 'AGGACGGATTCT'
-  assert_success
-  assert_output "9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'GGACGGATTCTG' 'AGGACGGATTCT'
+    assert_success
+    assert_output "9"
 }
 
 @test 'disallow first strand longer' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'AATG' 'AAA'
-  assert_failure
-  assert_output --partial "strands must be of equal length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'AATG' 'AAA'
+    assert_failure
+    assert_output --partial "strands must be of equal length"
 }
 
 @test 'disallow second strand longer' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'ATA' 'AGTG'
-  assert_failure
-  assert_output --partial "strands must be of equal length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'ATA' 'AGTG'
+    assert_failure
+    assert_output --partial "strands must be of equal length"
 }
 
 @test 'disallow empty first strand' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh '' 'G'
-  assert_failure
-  assert_output --partial "strands must be of equal length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh '' 'G'
+    assert_failure
+    assert_output --partial "strands must be of equal length"
 }
 
 @test 'disallow empty second strand' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'G' ''
-  assert_failure
-  assert_output --partial "strands must be of equal length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'G' ''
+    assert_failure
+    assert_output --partial "strands must be of equal length"
 }
 
 @test "no input" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh
-  assert_failure
-  assert_output "Usage: hamming.sh <string1> <string2>"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh
+    assert_failure
+    assert_output "Usage: hamming.sh <string1> <string2>"
 }
 
 @test "invalid input" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'A'
-  assert_failure
-  assert_output "Usage: hamming.sh <string1> <string2>"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'A'
+    assert_failure
+    assert_output "Usage: hamming.sh <string1> <string2>"
 }
 
 # Within [[...]] the == operator is a _pattern matching_ operator.
@@ -85,8 +85,8 @@ load bats-extra
 # quoted to prevent interpretation as a glob-style pattern.
 
 @test "expose subtle '[[ \$x == \$y ]]' bug" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash hamming.sh 'AAA' 'A?A'
-  assert_success
-  assert_output "1"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash hamming.sh 'AAA' 'A?A'
+    assert_success
+    assert_output "1"
 }
diff --git a/exercises/practice/hello-world/.meta/template.j2 b/exercises/practice/hello-world/.meta/template.j2
index b6f1057f..42e78554 100644
--- a/exercises/practice/hello-world/.meta/template.j2
+++ b/exercises/practice/hello-world/.meta/template.j2
@@ -1,12 +1,12 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  run bash {{ solution }}
+    run bash {{ solution }}
 
-  # the program's exit status should be success (0)
-  assert_success
+    # the program's exit status should be success (0)
+    assert_success
 
-  # program's output should be the expected text
-  assert_output "{{ case["expected"] }}"
+    # program's output should be the expected text
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/hello-world/hello_world.bats b/exercises/practice/hello-world/hello_world.bats
index 53d0b052..42b2c09d 100644
--- a/exercises/practice/hello-world/hello_world.bats
+++ b/exercises/practice/hello-world/hello_world.bats
@@ -1,14 +1,15 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "Say Hi!" {
-  run bash hello_world.sh
+    run bash hello_world.sh
 
-  # the program's exit status should be success (0)
-  assert_success
+    # the program's exit status should be success (0)
+    assert_success
 
-  # program's output should be the expected text
-  assert_output "Hello, World!"
+    # program's output should be the expected text
+    assert_output "Hello, World!"
 }
+
diff --git a/exercises/practice/isbn-verifier/.meta/template.j2 b/exercises/practice/isbn-verifier/.meta/template.j2
index 8b32deb0..7044bde7 100644
--- a/exercises/practice/isbn-verifier/.meta/template.j2
+++ b/exercises/practice/isbn-verifier/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} '{{ case["input"]["isbn"] }}'
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} '{{ case["input"]["isbn"] }}'
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/isbn-verifier/isbn_verifier.bats b/exercises/practice/isbn-verifier/isbn_verifier.bats
index 70b65ebf..f08b0159 100644
--- a/exercises/practice/isbn-verifier/isbn_verifier.bats
+++ b/exercises/practice/isbn-verifier/isbn_verifier.bats
@@ -1,151 +1,152 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test 'valid isbn' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-21508-8'
-  assert_success
-  assert_output "true"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-21508-8'
+    assert_success
+    assert_output "true"
 }
 
 @test 'invalid isbn check digit' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-21508-9'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-21508-9'
+    assert_success
+    assert_output "false"
 }
 
 @test 'valid isbn with a check digit of 10' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-21507-X'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-21507-X'
+    assert_success
+    assert_output "true"
 }
 
 @test 'check digit is a character other than X' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-21507-A'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-21507-A'
+    assert_success
+    assert_output "false"
 }
 
 @test 'invalid check digit in isbn is not treated as zero' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '4-598-21507-B'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '4-598-21507-B'
+    assert_success
+    assert_output "false"
 }
 
 @test 'invalid character in isbn is not treated as zero' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-P1581-X'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-P1581-X'
+    assert_success
+    assert_output "false"
 }
 
 @test 'X is only valid as a check digit' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-2X507-9'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-2X507-9'
+    assert_success
+    assert_output "false"
 }
 
 @test 'only one check digit is allowed' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-21508-96'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-21508-96'
+    assert_success
+    assert_output "false"
 }
 
 @test 'X is not substituted by the value 10' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-2X507-5'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-2X507-5'
+    assert_success
+    assert_output "false"
 }
 
 @test 'valid isbn without separating dashes' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3598215088'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3598215088'
+    assert_success
+    assert_output "true"
 }
 
 @test 'isbn without separating dashes and X as check digit' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '359821507X'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '359821507X'
+    assert_success
+    assert_output "true"
 }
 
 @test 'isbn without check digit and dashes' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '359821507'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '359821507'
+    assert_success
+    assert_output "false"
 }
 
 @test 'too long isbn and no dashes' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3598215078X'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3598215078X'
+    assert_success
+    assert_output "false"
 }
 
 @test 'too short isbn' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '00'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '00'
+    assert_success
+    assert_output "false"
 }
 
 @test 'isbn without check digit' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-21507'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-21507'
+    assert_success
+    assert_output "false"
 }
 
 @test 'check digit of X should not be used for 0' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3-598-21515-X'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3-598-21515-X'
+    assert_success
+    assert_output "false"
 }
 
 @test 'empty isbn' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh ''
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh ''
+    assert_success
+    assert_output "false"
 }
 
 @test 'input is 9 characters' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '134456729'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '134456729'
+    assert_success
+    assert_output "false"
 }
 
 @test 'invalid characters are not ignored after checking length' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3132P34035'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3132P34035'
+    assert_success
+    assert_output "false"
 }
 
 @test 'invalid characters are not ignored before checking length' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '3598P215088'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '3598P215088'
+    assert_success
+    assert_output "false"
 }
 
 @test 'input is too long but contains a valid isbn' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isbn_verifier.sh '98245726788'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isbn_verifier.sh '98245726788'
+    assert_success
+    assert_output "false"
 }
+
diff --git a/exercises/practice/isogram/.meta/template.j2 b/exercises/practice/isogram/.meta/template.j2
index 75c4d39d..4b935511 100644
--- a/exercises/practice/isogram/.meta/template.j2
+++ b/exercises/practice/isogram/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} '{{ case["input"]["phrase"] }}'
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} '{{ case["input"]["phrase"] }}'
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/isogram/isogram.bats b/exercises/practice/isogram/isogram.bats
index a811246d..6bde7900 100644
--- a/exercises/practice/isogram/isogram.bats
+++ b/exercises/practice/isogram/isogram.bats
@@ -1,102 +1,103 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test 'empty string' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh ''
-  assert_success
-  assert_output "true"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh ''
+    assert_success
+    assert_output "true"
 }
 
 @test 'isogram with only lower case characters' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'isogram'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'isogram'
+    assert_success
+    assert_output "true"
 }
 
 @test 'word with one duplicated character' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'eleven'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'eleven'
+    assert_success
+    assert_output "false"
 }
 
 @test 'word with one duplicated character from the end of the alphabet' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'zzyzx'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'zzyzx'
+    assert_success
+    assert_output "false"
 }
 
 @test 'longest reported english isogram' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'subdermatoglyphic'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'subdermatoglyphic'
+    assert_success
+    assert_output "true"
 }
 
 @test 'word with duplicated character in mixed case' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'Alphabet'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'Alphabet'
+    assert_success
+    assert_output "false"
 }
 
 @test 'word with duplicated character in mixed case, lowercase first' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'alphAbet'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'alphAbet'
+    assert_success
+    assert_output "false"
 }
 
 @test 'hypothetical isogrammic word with hyphen' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'thumbscrew-japingly'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'thumbscrew-japingly'
+    assert_success
+    assert_output "true"
 }
 
 @test 'hypothetical word with duplicated character following hyphen' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'thumbscrew-jappingly'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'thumbscrew-jappingly'
+    assert_success
+    assert_output "false"
 }
 
 @test 'isogram with duplicated hyphen' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'six-year-old'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'six-year-old'
+    assert_success
+    assert_output "true"
 }
 
 @test 'made-up name that is an isogram' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'Emily Jung Schwartzkopf'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'Emily Jung Schwartzkopf'
+    assert_success
+    assert_output "true"
 }
 
 @test 'duplicated character in the middle' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'accentor'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'accentor'
+    assert_success
+    assert_output "false"
 }
 
 @test 'same first and last characters' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'angola'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'angola'
+    assert_success
+    assert_output "false"
 }
 
 @test 'word with duplicated character and with two hyphens' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash isogram.sh 'up-to-date'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash isogram.sh 'up-to-date'
+    assert_success
+    assert_output "false"
 }
+
diff --git a/exercises/practice/leap/.meta/template.j2 b/exercises/practice/leap/.meta/template.j2
index 4986cc96..9c40412d 100644
--- a/exercises/practice/leap/.meta/template.j2
+++ b/exercises/practice/leap/.meta/template.j2
@@ -1,41 +1,41 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{ case["input"]["year"] }}
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{ case["input"]["year"] }}
 
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
 @test 'No input should return an error' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }}
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }}
 
-  assert_failure
-  assert_output "Usage: {{ solution }} <year>"
+    assert_failure
+    assert_output "Usage: {{ solution }} <year>"
 }
 
 @test 'Too many arguments should return an error' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} 2016 4562 4566
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} 2016 4562 4566
 
-  assert_failure
-  assert_output "Usage: {{ solution }} <year>"
+    assert_failure
+    assert_output "Usage: {{ solution }} <year>"
 }
 
 @test 'Float number input should return an error' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} 2016.54
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} 2016.54
 
-  assert_failure
-  assert_output "Usage: {{ solution }} <year>"
+    assert_failure
+    assert_output "Usage: {{ solution }} <year>"
 }
 
 @test 'Alpha input should return an error' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} 'abcd'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} 'abcd'
 
-  assert_failure
-  assert_output "Usage: {{ solution }} <year>"
+    assert_failure
+    assert_output "Usage: {{ solution }} <year>"
 }
diff --git a/exercises/practice/leap/leap.bats b/exercises/practice/leap/leap.bats
index 06bf34ee..a1bc0fff 100644
--- a/exercises/practice/leap/leap.bats
+++ b/exercises/practice/leap/leap.bats
@@ -1,108 +1,108 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test 'year not divisible by 4 in common year' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 2015
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 2015
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'year divisible by 2, not divisible by 4 in common year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 1970
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 1970
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'year divisible by 4, not divisible by 100 in leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 1996
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 1996
 
-  assert_success
-  assert_output "true"
+    assert_success
+    assert_output "true"
 }
 
 @test 'year divisible by 4 and 5 is still a leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 1960
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 1960
 
-  assert_success
-  assert_output "true"
+    assert_success
+    assert_output "true"
 }
 
 @test 'year divisible by 100, not divisible by 400 in common year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 2100
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 2100
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'year divisible by 100 but not by 3 is still not a leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 1900
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 1900
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'year divisible by 400 is leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 2000
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 2000
 
-  assert_success
-  assert_output "true"
+    assert_success
+    assert_output "true"
 }
 
 @test 'year divisible by 400 but not by 125 is still a leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 2400
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 2400
 
-  assert_success
-  assert_output "true"
+    assert_success
+    assert_output "true"
 }
 
 @test 'year divisible by 200, not divisible by 400 in common year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 1800
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 1800
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'No input should return an error' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh
 
-  assert_failure
-  assert_output "Usage: leap.sh <year>"
+    assert_failure
+    assert_output "Usage: leap.sh <year>"
 }
 
 @test 'Too many arguments should return an error' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 2016 4562 4566
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 2016 4562 4566
 
-  assert_failure
-  assert_output "Usage: leap.sh <year>"
+    assert_failure
+    assert_output "Usage: leap.sh <year>"
 }
 
 @test 'Float number input should return an error' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 2016.54
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 2016.54
 
-  assert_failure
-  assert_output "Usage: leap.sh <year>"
+    assert_failure
+    assert_output "Usage: leap.sh <year>"
 }
 
 @test 'Alpha input should return an error' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash leap.sh 'abcd'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash leap.sh 'abcd'
 
-  assert_failure
-  assert_output "Usage: leap.sh <year>"
+    assert_failure
+    assert_output "Usage: leap.sh <year>"
 }
diff --git a/exercises/practice/luhn/.meta/template.j2 b/exercises/practice/luhn/.meta/template.j2
index a13ff18d..097e3ea8 100644
--- a/exercises/practice/luhn/.meta/template.j2
+++ b/exercises/practice/luhn/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["value"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["value"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/luhn/luhn.bats b/exercises/practice/luhn/luhn.bats
index 36e81ec9..7f09d3ad 100644
--- a/exercises/practice/luhn/luhn.bats
+++ b/exercises/practice/luhn/luhn.bats
@@ -1,158 +1,159 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "single digit strings can not be valid" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "1"
-  assert_success
-  assert_output "false"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "1"
+    assert_success
+    assert_output "false"
 }
 
 @test "a single zero is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "0"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "0"
+    assert_success
+    assert_output "false"
 }
 
 @test "a simple valid SIN that remains valid if reversed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "059"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "059"
+    assert_success
+    assert_output "true"
 }
 
 @test "a simple valid SIN that becomes invalid if reversed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "59"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "59"
+    assert_success
+    assert_output "true"
 }
 
 @test "a valid Canadian SIN" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "055 444 285"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "055 444 285"
+    assert_success
+    assert_output "true"
 }
 
 @test "invalid Canadian SIN" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "055 444 286"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "055 444 286"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid credit card" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "8273 1232 7352 0569"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "8273 1232 7352 0569"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid long number with an even remainder" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "1 2345 6789 1234 5678 9012"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "1 2345 6789 1234 5678 9012"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid long number with a remainder divisible by 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "1 2345 6789 1234 5678 9013"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "1 2345 6789 1234 5678 9013"
+    assert_success
+    assert_output "false"
 }
 
 @test "valid number with an even number of digits" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "095 245 88"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "095 245 88"
+    assert_success
+    assert_output "true"
 }
 
 @test "valid number with an odd number of spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "234 567 891 234"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "234 567 891 234"
+    assert_success
+    assert_output "true"
 }
 
 @test "valid strings with a non-digit added at the end become invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "059a"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "059a"
+    assert_success
+    assert_output "false"
 }
 
 @test "valid strings with punctuation included become invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "055-444-285"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "055-444-285"
+    assert_success
+    assert_output "false"
 }
 
 @test "valid strings with symbols included become invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "055# 444$ 285"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "055# 444$ 285"
+    assert_success
+    assert_output "false"
 }
 
 @test "single zero with space is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh " 0"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh " 0"
+    assert_success
+    assert_output "false"
 }
 
 @test "more than a single zero is valid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "0000 0"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "0000 0"
+    assert_success
+    assert_output "true"
 }
 
 @test "input digit 9 is correctly converted to output digit 9" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "091"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "091"
+    assert_success
+    assert_output "true"
 }
 
 @test "very long input is valid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "9999999999 9999999999 9999999999 9999999999"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "9999999999 9999999999 9999999999 9999999999"
+    assert_success
+    assert_output "true"
 }
 
 @test "valid luhn with an odd number of digits and non zero first digit" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "109"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "109"
+    assert_success
+    assert_output "true"
 }
 
 @test "using ascii value for non-doubled non-digit isn't allowed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "055b 444 285"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "055b 444 285"
+    assert_success
+    assert_output "false"
 }
 
 @test "using ascii value for doubled non-digit isn't allowed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh ":9"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh ":9"
+    assert_success
+    assert_output "false"
 }
 
 @test "non-numeric, non-space char in the middle with a sum that's divisible by 10 isn't allowed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash luhn.sh "59%59"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash luhn.sh "59%59"
+    assert_success
+    assert_output "false"
 }
+
diff --git a/exercises/practice/nucleotide-count/.meta/template.j2 b/exercises/practice/nucleotide-count/.meta/template.j2
index a67a2324..b2548a0e 100644
--- a/exercises/practice/nucleotide-count/.meta/template.j2
+++ b/exercises/practice/nucleotide-count/.meta/template.j2
@@ -1,14 +1,14 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["strand"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["strand"] }}"
 {%- if case["expect_error"] %}
-  assert_failure
-  assert_output "{{ case["expect_error_msg"] }}"
+    assert_failure
+    assert_output "{{ case["expect_error_msg"] }}"
 {%- else %}
-  assert_success
-  assert_output $'{{ case["expected"].items() | map("join", ": ") | join("\\n") }}'
+    assert_success
+    assert_output $'{{ case["expected"].items() | map("join", ": ") | join("\\n") }}'
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/nucleotide-count/nucleotide_count.bats b/exercises/practice/nucleotide-count/nucleotide_count.bats
index 7d202b9b..f7bc3122 100644
--- a/exercises/practice/nucleotide-count/nucleotide_count.bats
+++ b/exercises/practice/nucleotide-count/nucleotide_count.bats
@@ -1,39 +1,40 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "empty strand" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash nucleotide_count.sh ""
-  assert_success
-  assert_output $'A: 0\nC: 0\nG: 0\nT: 0'
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash nucleotide_count.sh ""
+    assert_success
+    assert_output $'A: 0\nC: 0\nG: 0\nT: 0'
 }
 
 @test "can count one nucleotide in single-character input" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash nucleotide_count.sh "G"
-  assert_success
-  assert_output $'A: 0\nC: 0\nG: 1\nT: 0'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash nucleotide_count.sh "G"
+    assert_success
+    assert_output $'A: 0\nC: 0\nG: 1\nT: 0'
 }
 
 @test "strand with repeated nucleotide" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash nucleotide_count.sh "GGGGGGG"
-  assert_success
-  assert_output $'A: 0\nC: 0\nG: 7\nT: 0'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash nucleotide_count.sh "GGGGGGG"
+    assert_success
+    assert_output $'A: 0\nC: 0\nG: 7\nT: 0'
 }
 
 @test "strand with multiple nucleotides" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash nucleotide_count.sh "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC"
-  assert_success
-  assert_output $'A: 20\nC: 12\nG: 17\nT: 21'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash nucleotide_count.sh "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC"
+    assert_success
+    assert_output $'A: 20\nC: 12\nG: 17\nT: 21'
 }
 
 @test "strand with invalid nucleotides" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash nucleotide_count.sh "AGXXACT"
-  assert_failure
-  assert_output "Invalid nucleotide in strand"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash nucleotide_count.sh "AGXXACT"
+    assert_failure
+    assert_output "Invalid nucleotide in strand"
 }
+
diff --git a/exercises/practice/pangram/.meta/template.j2 b/exercises/practice/pangram/.meta/template.j2
index b0d9e98c..ed34a454 100644
--- a/exercises/practice/pangram/.meta/template.j2
+++ b/exercises/practice/pangram/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} '{{ case["input"]["sentence"] }}'
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} '{{ case["input"]["sentence"] }}'
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/pangram/pangram.bats b/exercises/practice/pangram/pangram.bats
index 1fe78fb6..56be4f1e 100644
--- a/exercises/practice/pangram/pangram.bats
+++ b/exercises/practice/pangram/pangram.bats
@@ -1,74 +1,75 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "empty sentence" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh ''
-  assert_success
-  assert_output "false"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh ''
+    assert_success
+    assert_output "false"
 }
 
 @test "perfect lower case" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh 'abcdefghijklmnopqrstuvwxyz'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh 'abcdefghijklmnopqrstuvwxyz'
+    assert_success
+    assert_output "true"
 }
 
 @test "only lower case" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh 'the quick brown fox jumps over the lazy dog'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh 'the quick brown fox jumps over the lazy dog'
+    assert_success
+    assert_output "true"
 }
 
 @test "missing the letter 'x'" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh 'a quick movement of the enemy will jeopardize five gunboats'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh 'a quick movement of the enemy will jeopardize five gunboats'
+    assert_success
+    assert_output "false"
 }
 
 @test "missing the letter 'h'" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh 'five boxing wizards jump quickly at it'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh 'five boxing wizards jump quickly at it'
+    assert_success
+    assert_output "false"
 }
 
 @test "with underscores" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh 'the_quick_brown_fox_jumps_over_the_lazy_dog'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh 'the_quick_brown_fox_jumps_over_the_lazy_dog'
+    assert_success
+    assert_output "true"
 }
 
 @test "with numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh 'the 1 quick brown fox jumps over the 2 lazy dogs'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh 'the 1 quick brown fox jumps over the 2 lazy dogs'
+    assert_success
+    assert_output "true"
 }
 
 @test "missing letters replaced by numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh '7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh '7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog'
+    assert_success
+    assert_output "false"
 }
 
 @test "mixed case and punctuation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh '"Five quacking Zephyrs jolt my wax bed."'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh '"Five quacking Zephyrs jolt my wax bed."'
+    assert_success
+    assert_output "true"
 }
 
 @test "a-m and A-M are 26 different characters but not a pangram" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash pangram.sh 'abcdefghijklm ABCDEFGHIJKLM'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash pangram.sh 'abcdefghijklm ABCDEFGHIJKLM'
+    assert_success
+    assert_output "false"
 }
+
diff --git a/exercises/practice/phone-number/.meta/template.j2 b/exercises/practice/phone-number/.meta/template.j2
index e6e2b13f..6e6a2711 100644
--- a/exercises/practice/phone-number/.meta/template.j2
+++ b/exercises/practice/phone-number/.meta/template.j2
@@ -1,15 +1,15 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["phrase"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["phrase"] }}"
 {%- if case["expect_error"] %}
-  assert_failure
-  {#- The error message from the canonical data is not used. #}
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    assert_failure
+    {#- The error message from the canonical data is not used. #}
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 {%- else %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/phone-number/phone_number.bats b/exercises/practice/phone-number/phone_number.bats
index a438b23b..3031b8b7 100644
--- a/exercises/practice/phone-number/phone_number.bats
+++ b/exercises/practice/phone-number/phone_number.bats
@@ -1,130 +1,131 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "cleans the number" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "(223) 456-7890"
-  assert_success
-  assert_output "2234567890"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "(223) 456-7890"
+    assert_success
+    assert_output "2234567890"
 }
 
 @test "cleans numbers with dots" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "223.456.7890"
-  assert_success
-  assert_output "2234567890"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "223.456.7890"
+    assert_success
+    assert_output "2234567890"
 }
 
 @test "cleans numbers with multiple spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "223 456   7890   "
-  assert_success
-  assert_output "2234567890"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "223 456   7890   "
+    assert_success
+    assert_output "2234567890"
 }
 
 @test "invalid when 9 digits" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "123456789"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "123456789"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid when 11 digits does not start with a 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "22234567890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "22234567890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "valid when 11 digits and starting with 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "12234567890"
-  assert_success
-  assert_output "2234567890"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "12234567890"
+    assert_success
+    assert_output "2234567890"
 }
 
 @test "valid when 11 digits and starting with 1 even with punctuation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "+1 (223) 456-7890"
-  assert_success
-  assert_output "2234567890"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "+1 (223) 456-7890"
+    assert_success
+    assert_output "2234567890"
 }
 
 @test "invalid when more than 11 digits" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "321234567890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "321234567890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid with letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "523-abc-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "523-abc-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid with punctuations" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "523-@:!-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "523-@:!-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid if area code starts with 0" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "(023) 456-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "(023) 456-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid if area code starts with 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "(123) 456-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "(123) 456-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid if exchange code starts with 0" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "(223) 056-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "(223) 056-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid if exchange code starts with 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "(223) 156-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "(223) 156-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid if area code starts with 0 on valid 11-digit number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "1 (023) 456-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "1 (023) 456-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid if area code starts with 1 on valid 11-digit number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "1 (123) 456-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "1 (123) 456-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid if exchange code starts with 0 on valid 11-digit number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "1 (223) 056-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "1 (223) 056-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
 
 @test "invalid if exchange code starts with 1 on valid 11-digit number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash phone_number.sh "1 (223) 156-7890"
-  assert_failure
-  assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash phone_number.sh "1 (223) 156-7890"
+    assert_failure
+    assert_output "Invalid number.  [1]NXX-NXX-XXXX N=2-9, X=0-9"
 }
+
diff --git a/exercises/practice/raindrops/.meta/template.j2 b/exercises/practice/raindrops/.meta/template.j2
index 03ed4d44..3a68a821 100644
--- a/exercises/practice/raindrops/.meta/template.j2
+++ b/exercises/practice/raindrops/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{ case["input"]["number"] }}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{ case["input"]["number"] }}
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/raindrops/raindrops.bats b/exercises/practice/raindrops/raindrops.bats
index f754b7b7..c655e800 100644
--- a/exercises/practice/raindrops/raindrops.bats
+++ b/exercises/practice/raindrops/raindrops.bats
@@ -1,130 +1,131 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "the sound for 1 is 1" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 1
-  assert_success
-  assert_output "1"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 1
+    assert_success
+    assert_output "1"
 }
 
 @test "the sound for 3 is Pling" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 3
-  assert_success
-  assert_output "Pling"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 3
+    assert_success
+    assert_output "Pling"
 }
 
 @test "the sound for 5 is Plang" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 5
-  assert_success
-  assert_output "Plang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 5
+    assert_success
+    assert_output "Plang"
 }
 
 @test "the sound for 7 is Plong" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 7
-  assert_success
-  assert_output "Plong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 7
+    assert_success
+    assert_output "Plong"
 }
 
 @test "the sound for 6 is Pling as it has a factor 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 6
-  assert_success
-  assert_output "Pling"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 6
+    assert_success
+    assert_output "Pling"
 }
 
 @test "2 to the power 3 does not make a raindrop sound as 3 is the exponent not the base" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 8
-  assert_success
-  assert_output "8"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 8
+    assert_success
+    assert_output "8"
 }
 
 @test "the sound for 9 is Pling as it has a factor 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 9
-  assert_success
-  assert_output "Pling"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 9
+    assert_success
+    assert_output "Pling"
 }
 
 @test "the sound for 10 is Plang as it has a factor 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 10
-  assert_success
-  assert_output "Plang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 10
+    assert_success
+    assert_output "Plang"
 }
 
 @test "the sound for 14 is Plong as it has a factor of 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 14
-  assert_success
-  assert_output "Plong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 14
+    assert_success
+    assert_output "Plong"
 }
 
 @test "the sound for 15 is PlingPlang as it has factors 3 and 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 15
-  assert_success
-  assert_output "PlingPlang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 15
+    assert_success
+    assert_output "PlingPlang"
 }
 
 @test "the sound for 21 is PlingPlong as it has factors 3 and 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 21
-  assert_success
-  assert_output "PlingPlong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 21
+    assert_success
+    assert_output "PlingPlong"
 }
 
 @test "the sound for 25 is Plang as it has a factor 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 25
-  assert_success
-  assert_output "Plang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 25
+    assert_success
+    assert_output "Plang"
 }
 
 @test "the sound for 27 is Pling as it has a factor 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 27
-  assert_success
-  assert_output "Pling"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 27
+    assert_success
+    assert_output "Pling"
 }
 
 @test "the sound for 35 is PlangPlong as it has factors 5 and 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 35
-  assert_success
-  assert_output "PlangPlong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 35
+    assert_success
+    assert_output "PlangPlong"
 }
 
 @test "the sound for 49 is Plong as it has a factor 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 49
-  assert_success
-  assert_output "Plong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 49
+    assert_success
+    assert_output "Plong"
 }
 
 @test "the sound for 52 is 52" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 52
-  assert_success
-  assert_output "52"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 52
+    assert_success
+    assert_output "52"
 }
 
 @test "the sound for 105 is PlingPlangPlong as it has factors 3, 5 and 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 105
-  assert_success
-  assert_output "PlingPlangPlong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 105
+    assert_success
+    assert_output "PlingPlangPlong"
 }
 
 @test "the sound for 3125 is Plang as it has a factor 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash raindrops.sh 3125
-  assert_success
-  assert_output "Plang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash raindrops.sh 3125
+    assert_success
+    assert_output "Plang"
 }
+
diff --git a/exercises/practice/reverse-string/.meta/template.j2 b/exercises/practice/reverse-string/.meta/template.j2
index fa8e9905..3d06f4ea 100644
--- a/exercises/practice/reverse-string/.meta/template.j2
+++ b/exercises/practice/reverse-string/.meta/template.j2
@@ -1,10 +1,10 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["value"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["value"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
 # bash-specific test: Focus the student's attention on the effects of 
@@ -12,9 +12,9 @@
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
 @test "avoid globbing" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash reverse_string.sh " a *  b"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash reverse_string.sh " a *  b"
 
-  assert_success
-  assert_output "b  * a "
+    assert_success
+    assert_output "b  * a "
 }
diff --git a/exercises/practice/reverse-string/reverse_string.bats b/exercises/practice/reverse-string/reverse_string.bats
index 1a995140..5942e095 100644
--- a/exercises/practice/reverse-string/reverse_string.bats
+++ b/exercises/practice/reverse-string/reverse_string.bats
@@ -1,48 +1,48 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "an empty string" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash reverse_string.sh ""
-  assert_success
-  assert_output ""
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash reverse_string.sh ""
+    assert_success
+    assert_output ""
 }
 
 @test "a word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash reverse_string.sh "robot"
-  assert_success
-  assert_output "tobor"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash reverse_string.sh "robot"
+    assert_success
+    assert_output "tobor"
 }
 
 @test "a capitalized word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash reverse_string.sh "Ramen"
-  assert_success
-  assert_output "nemaR"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash reverse_string.sh "Ramen"
+    assert_success
+    assert_output "nemaR"
 }
 
 @test "a sentence with punctuation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash reverse_string.sh "I'm hungry!"
-  assert_success
-  assert_output "!yrgnuh m'I"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash reverse_string.sh "I'm hungry!"
+    assert_success
+    assert_output "!yrgnuh m'I"
 }
 
 @test "a palindrome" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash reverse_string.sh "racecar"
-  assert_success
-  assert_output "racecar"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash reverse_string.sh "racecar"
+    assert_success
+    assert_output "racecar"
 }
 
 @test "an even-sized word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash reverse_string.sh "drawer"
-  assert_success
-  assert_output "reward"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash reverse_string.sh "drawer"
+    assert_success
+    assert_output "reward"
 }
 
 # bash-specific test: Focus the student's attention on the effects of 
@@ -50,9 +50,9 @@ load bats-extra
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
 @test "avoid globbing" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash reverse_string.sh " a *  b"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash reverse_string.sh " a *  b"
 
-  assert_success
-  assert_output "b  * a "
+    assert_success
+    assert_output "b  * a "
 }
diff --git a/exercises/practice/rna-transcription/.meta/template.j2 b/exercises/practice/rna-transcription/.meta/template.j2
index 8c092b9e..fd246c41 100644
--- a/exercises/practice/rna-transcription/.meta/template.j2
+++ b/exercises/practice/rna-transcription/.meta/template.j2
@@ -1,29 +1,29 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["dna"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["dna"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
 @test "Handles invalid character" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} ACGTXCTTA
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} ACGTXCTTA
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
 
 @test "Handles completely invalid string" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} XXXX
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} XXXX
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
 
 @test "Handles partially invalid string" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} ACGTXCTTAA
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} ACGTXCTTAA
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
diff --git a/exercises/practice/rna-transcription/rna_transcription.bats b/exercises/practice/rna-transcription/rna_transcription.bats
index c1292d15..c37c4b81 100644
--- a/exercises/practice/rna-transcription/rna_transcription.bats
+++ b/exercises/practice/rna-transcription/rna_transcription.bats
@@ -1,67 +1,67 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "Empty RNA sequence" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh ""
-  assert_success
-  assert_output ""
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh ""
+    assert_success
+    assert_output ""
 }
 
 @test "RNA complement of cytosine is guanine" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh "C"
-  assert_success
-  assert_output "G"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh "C"
+    assert_success
+    assert_output "G"
 }
 
 @test "RNA complement of guanine is cytosine" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh "G"
-  assert_success
-  assert_output "C"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh "G"
+    assert_success
+    assert_output "C"
 }
 
 @test "RNA complement of thymine is adenine" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh "T"
-  assert_success
-  assert_output "A"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh "T"
+    assert_success
+    assert_output "A"
 }
 
 @test "RNA complement of adenine is uracil" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh "A"
-  assert_success
-  assert_output "U"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh "A"
+    assert_success
+    assert_output "U"
 }
 
 @test "RNA complement" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh "ACGTGGTCTTAA"
-  assert_success
-  assert_output "UGCACCAGAAUU"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh "ACGTGGTCTTAA"
+    assert_success
+    assert_output "UGCACCAGAAUU"
 }
 
 @test "Handles invalid character" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh ACGTXCTTA
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh ACGTXCTTA
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
 
 @test "Handles completely invalid string" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh XXXX
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh XXXX
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
 
 @test "Handles partially invalid string" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash rna_transcription.sh ACGTXCTTAA
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash rna_transcription.sh ACGTXCTTAA
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
diff --git a/exercises/practice/roman-numerals/.meta/template.j2 b/exercises/practice/roman-numerals/.meta/template.j2
index 03ed4d44..3a68a821 100644
--- a/exercises/practice/roman-numerals/.meta/template.j2
+++ b/exercises/practice/roman-numerals/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{ case["input"]["number"] }}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{ case["input"]["number"] }}
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/roman-numerals/roman_numerals.bats b/exercises/practice/roman-numerals/roman_numerals.bats
index 8abe96c9..90a71934 100644
--- a/exercises/practice/roman-numerals/roman_numerals.bats
+++ b/exercises/practice/roman-numerals/roman_numerals.bats
@@ -1,193 +1,194 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:24+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "1 is I" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 1
-  assert_success
-  assert_output "I"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 1
+    assert_success
+    assert_output "I"
 }
 
 @test "2 is II" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 2
-  assert_success
-  assert_output "II"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 2
+    assert_success
+    assert_output "II"
 }
 
 @test "3 is III" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 3
-  assert_success
-  assert_output "III"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 3
+    assert_success
+    assert_output "III"
 }
 
 @test "4 is IV" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 4
-  assert_success
-  assert_output "IV"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 4
+    assert_success
+    assert_output "IV"
 }
 
 @test "5 is V" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 5
-  assert_success
-  assert_output "V"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 5
+    assert_success
+    assert_output "V"
 }
 
 @test "6 is VI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 6
-  assert_success
-  assert_output "VI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 6
+    assert_success
+    assert_output "VI"
 }
 
 @test "9 is IX" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 9
-  assert_success
-  assert_output "IX"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 9
+    assert_success
+    assert_output "IX"
 }
 
 @test "16 is XVI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 16
-  assert_success
-  assert_output "XVI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 16
+    assert_success
+    assert_output "XVI"
 }
 
 @test "27 is XXVII" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 27
-  assert_success
-  assert_output "XXVII"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 27
+    assert_success
+    assert_output "XXVII"
 }
 
 @test "48 is XLVIII" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 48
-  assert_success
-  assert_output "XLVIII"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 48
+    assert_success
+    assert_output "XLVIII"
 }
 
 @test "49 is XLIX" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 49
-  assert_success
-  assert_output "XLIX"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 49
+    assert_success
+    assert_output "XLIX"
 }
 
 @test "59 is LIX" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 59
-  assert_success
-  assert_output "LIX"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 59
+    assert_success
+    assert_output "LIX"
 }
 
 @test "66 is LXVI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 66
-  assert_success
-  assert_output "LXVI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 66
+    assert_success
+    assert_output "LXVI"
 }
 
 @test "93 is XCIII" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 93
-  assert_success
-  assert_output "XCIII"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 93
+    assert_success
+    assert_output "XCIII"
 }
 
 @test "141 is CXLI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 141
-  assert_success
-  assert_output "CXLI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 141
+    assert_success
+    assert_output "CXLI"
 }
 
 @test "163 is CLXIII" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 163
-  assert_success
-  assert_output "CLXIII"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 163
+    assert_success
+    assert_output "CLXIII"
 }
 
 @test "166 is CLXVI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 166
-  assert_success
-  assert_output "CLXVI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 166
+    assert_success
+    assert_output "CLXVI"
 }
 
 @test "402 is CDII" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 402
-  assert_success
-  assert_output "CDII"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 402
+    assert_success
+    assert_output "CDII"
 }
 
 @test "575 is DLXXV" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 575
-  assert_success
-  assert_output "DLXXV"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 575
+    assert_success
+    assert_output "DLXXV"
 }
 
 @test "666 is DCLXVI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 666
-  assert_success
-  assert_output "DCLXVI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 666
+    assert_success
+    assert_output "DCLXVI"
 }
 
 @test "911 is CMXI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 911
-  assert_success
-  assert_output "CMXI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 911
+    assert_success
+    assert_output "CMXI"
 }
 
 @test "1024 is MXXIV" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 1024
-  assert_success
-  assert_output "MXXIV"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 1024
+    assert_success
+    assert_output "MXXIV"
 }
 
 @test "1666 is MDCLXVI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 1666
-  assert_success
-  assert_output "MDCLXVI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 1666
+    assert_success
+    assert_output "MDCLXVI"
 }
 
 @test "3000 is MMM" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 3000
-  assert_success
-  assert_output "MMM"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 3000
+    assert_success
+    assert_output "MMM"
 }
 
 @test "3001 is MMMI" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 3001
-  assert_success
-  assert_output "MMMI"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 3001
+    assert_success
+    assert_output "MMMI"
 }
 
 @test "3888 is MMMDCCCLXXXVIII" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 3888
-  assert_success
-  assert_output "MMMDCCCLXXXVIII"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 3888
+    assert_success
+    assert_output "MMMDCCCLXXXVIII"
 }
 
 @test "3999 is MMMCMXCIX" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash roman_numerals.sh 3999
-  assert_success
-  assert_output "MMMCMXCIX"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash roman_numerals.sh 3999
+    assert_success
+    assert_output "MMMCMXCIX"
 }
+
diff --git a/exercises/practice/satellite/.meta/template.j2 b/exercises/practice/satellite/.meta/template.j2
index d022d57c..5d4c149c 100644
--- a/exercises/practice/satellite/.meta/template.j2
+++ b/exercises/practice/satellite/.meta/template.j2
@@ -1,20 +1,20 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["preorder"] | join(" ") }}" "{{ case["input"]["inorder"] | join(" ") }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["preorder"] | join(" ") }}" "{{ case["input"]["inorder"] | join(" ") }}"
 {%- if case["expect_error"] %}
-  assert_failure
-  shopt -s nocasematch
-  assert_output "{{ case["expect_error_msg"] }}"
+    assert_failure
+    shopt -s nocasematch
+    assert_output "{{ case["expect_error_msg"] }}"
 {%- else %}
-  assert_success
-  expectedJson=$(cat << END_JSON
+    assert_success
+    expectedJson=$(cat << END_JSON
 {{ case["expected"] | tojson(separators=None, indent=4) | indent(4, first=True) }}
 END_JSON
 )
-  # compare without spaces
-  [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
+    # compare without spaces
+    [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/satellite/satellite.bats b/exercises/practice/satellite/satellite.bats
index 376b4b45..eb9b246d 100644
--- a/exercises/practice/satellite/satellite.bats
+++ b/exercises/practice/satellite/satellite.bats
@@ -1,25 +1,25 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T03:19:10+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "Empty tree" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "" ""
-  assert_success
-  expectedJson=$(cat << END_JSON
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "" ""
+    assert_success
+    expectedJson=$(cat << END_JSON
     {}
 END_JSON
 )
-  # compare without spaces
-  [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
+    # compare without spaces
+    [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
 }
 
 @test "Tree with one item" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "a" "a"
-  assert_success
-  expectedJson=$(cat << END_JSON
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "a" "a"
+    assert_success
+    expectedJson=$(cat << END_JSON
     {
         "v": "a",
         "l": {},
@@ -27,15 +27,15 @@ END_JSON
     }
 END_JSON
 )
-  # compare without spaces
-  [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
+    # compare without spaces
+    [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
 }
 
 @test "Tree with many items" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "a i x f r" "i a f x r"
-  assert_success
-  expectedJson=$(cat << END_JSON
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "a i x f r" "i a f x r"
+    assert_success
+    expectedJson=$(cat << END_JSON
     {
         "v": "a",
         "l": {
@@ -59,39 +59,39 @@ END_JSON
     }
 END_JSON
 )
-  # compare without spaces
-  [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
+    # compare without spaces
+    [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
 }
 
 @test "Reject traversals of different length" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "a b" "b a r"
-  assert_failure
-  shopt -s nocasematch
-  assert_output "traversals must have the same length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "a b" "b a r"
+    assert_failure
+    shopt -s nocasematch
+    assert_output "traversals must have the same length"
 }
 
 @test "Reject inconsistent traversals of same length" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "x y z" "a b c"
-  assert_failure
-  shopt -s nocasematch
-  assert_output "traversals must have the same elements"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "x y z" "a b c"
+    assert_failure
+    shopt -s nocasematch
+    assert_output "traversals must have the same elements"
 }
 
 @test "Reject traversals with repeated items" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "a b a" "b a a"
-  assert_failure
-  shopt -s nocasematch
-  assert_output "traversals must contain unique items"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "a b a" "b a a"
+    assert_failure
+    shopt -s nocasematch
+    assert_output "traversals must contain unique items"
 }
 
 @test "A degenerate binary tree" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "a b c d" "d c b a"
-  assert_success
-  expectedJson=$(cat << END_JSON
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "a b c d" "d c b a"
+    assert_success
+    expectedJson=$(cat << END_JSON
     {
         "v": "a",
         "l": {
@@ -111,15 +111,15 @@ END_JSON
     }
 END_JSON
 )
-  # compare without spaces
-  [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
+    # compare without spaces
+    [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
 }
 
 @test "Another degenerate binary tree" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "a b c d" "a b c d"
-  assert_success
-  expectedJson=$(cat << END_JSON
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "a b c d" "a b c d"
+    assert_success
+    expectedJson=$(cat << END_JSON
     {
         "v": "a",
         "l": {},
@@ -139,15 +139,15 @@ END_JSON
     }
 END_JSON
 )
-  # compare without spaces
-  [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
+    # compare without spaces
+    [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
 }
 
 @test "Tree with many more items" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash satellite.sh "a b d g h c e f i" "g d h b a e c i f"
-  assert_success
-  expectedJson=$(cat << END_JSON
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash satellite.sh "a b d g h c e f i" "g d h b a e c i f"
+    assert_success
+    expectedJson=$(cat << END_JSON
     {
         "v": "a",
         "l": {
@@ -187,6 +187,7 @@ END_JSON
     }
 END_JSON
 )
-  # compare without spaces
-  [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
+    # compare without spaces
+    [[ "${output//[[:space:]]/}" == "${expectedJson//[[:space:]]/}" ]]
 }
+
diff --git a/exercises/practice/scrabble-score/.meta/template.j2 b/exercises/practice/scrabble-score/.meta/template.j2
index 43e0e6f3..1d721ec0 100644
--- a/exercises/practice/scrabble-score/.meta/template.j2
+++ b/exercises/practice/scrabble-score/.meta/template.j2
@@ -1,10 +1,10 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} '{{ case["input"]["word"] }}'
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} '{{ case["input"]["word"] }}'
 
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/scrabble-score/scrabble_score.bats b/exercises/practice/scrabble-score/scrabble_score.bats
index 4b5ea138..47b62b83 100644
--- a/exercises/practice/scrabble-score/scrabble_score.bats
+++ b/exercises/practice/scrabble-score/scrabble_score.bats
@@ -1,92 +1,93 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:25+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test 'lowercase letter' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'a'
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'a'
 
-  assert_success
-  assert_output "1"
+    assert_success
+    assert_output "1"
 }
 
 @test 'uppercase letter' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'A'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'A'
 
-  assert_success
-  assert_output "1"
+    assert_success
+    assert_output "1"
 }
 
 @test 'valuable letter' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'f'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'f'
 
-  assert_success
-  assert_output "4"
+    assert_success
+    assert_output "4"
 }
 
 @test 'short word' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'at'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'at'
 
-  assert_success
-  assert_output "2"
+    assert_success
+    assert_output "2"
 }
 
 @test 'short, valuable word' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'zoo'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'zoo'
 
-  assert_success
-  assert_output "12"
+    assert_success
+    assert_output "12"
 }
 
 @test 'medium word' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'street'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'street'
 
-  assert_success
-  assert_output "6"
+    assert_success
+    assert_output "6"
 }
 
 @test 'medium, valuable word' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'quirky'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'quirky'
 
-  assert_success
-  assert_output "22"
+    assert_success
+    assert_output "22"
 }
 
 @test 'long, mixed-case word' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'OxyphenButazone'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'OxyphenButazone'
 
-  assert_success
-  assert_output "41"
+    assert_success
+    assert_output "41"
 }
 
 @test 'english-like word' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'pinata'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'pinata'
 
-  assert_success
-  assert_output "8"
+    assert_success
+    assert_output "8"
 }
 
 @test 'empty input' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh ''
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh ''
 
-  assert_success
-  assert_output "0"
+    assert_success
+    assert_output "0"
 }
 
 @test 'entire alphabet available' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash scrabble_score.sh 'abcdefghijklmnopqrstuvwxyz'
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash scrabble_score.sh 'abcdefghijklmnopqrstuvwxyz'
 
-  assert_success
-  assert_output "87"
+    assert_success
+    assert_output "87"
 }
+
diff --git a/exercises/practice/swift-scheduling/.meta/template.j2 b/exercises/practice/swift-scheduling/.meta/template.j2
index 5e3766a4..c247aabb 100644
--- a/exercises/practice/swift-scheduling/.meta/template.j2
+++ b/exercises/practice/swift-scheduling/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["description"] }}" "{{ case["input"]["meetingStart"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["description"] }}" "{{ case["input"]["meetingStart"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/swift-scheduling/swift_scheduling.bats b/exercises/practice/swift-scheduling/swift_scheduling.bats
index e55f9648..6740183c 100644
--- a/exercises/practice/swift-scheduling/swift_scheduling.bats
+++ b/exercises/practice/swift-scheduling/swift_scheduling.bats
@@ -1,124 +1,124 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-07-18T06:41:40+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "NOW translates to two hours later" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "NOW" "2012-02-13T09:00:00"
-  assert_success
-  assert_output "2012-02-13T11:00:00"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "NOW" "2012-02-13T09:00:00"
+    assert_success
+    assert_output "2012-02-13T11:00:00"
 }
 
 @test "ASAP before one in the afternoon translates to today at five in the afternoon" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "ASAP" "1999-06-03T09:45:00"
-  assert_success
-  assert_output "1999-06-03T17:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "ASAP" "1999-06-03T09:45:00"
+    assert_success
+    assert_output "1999-06-03T17:00:00"
 }
 
 @test "ASAP at one in the afternoon translates to tomorrow at one in the afternoon" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "ASAP" "2008-12-21T13:00:00"
-  assert_success
-  assert_output "2008-12-22T13:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "ASAP" "2008-12-21T13:00:00"
+    assert_success
+    assert_output "2008-12-22T13:00:00"
 }
 
 @test "ASAP after one in the afternoon translates to tomorrow at one in the afternoon" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "ASAP" "2008-12-21T14:50:00"
-  assert_success
-  assert_output "2008-12-22T13:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "ASAP" "2008-12-21T14:50:00"
+    assert_success
+    assert_output "2008-12-22T13:00:00"
 }
 
 @test "EOW on Monday translates to Friday at five in the afternoon" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "EOW" "2025-02-03T16:00:00"
-  assert_success
-  assert_output "2025-02-07T17:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "EOW" "2025-02-03T16:00:00"
+    assert_success
+    assert_output "2025-02-07T17:00:00"
 }
 
 @test "EOW on Tuesday translates to Friday at five in the afternoon" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "EOW" "1997-04-29T10:50:00"
-  assert_success
-  assert_output "1997-05-02T17:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "EOW" "1997-04-29T10:50:00"
+    assert_success
+    assert_output "1997-05-02T17:00:00"
 }
 
 @test "EOW on Wednesday translates to Friday at five in the afternoon" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "EOW" "2005-09-14T11:00:00"
-  assert_success
-  assert_output "2005-09-16T17:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "EOW" "2005-09-14T11:00:00"
+    assert_success
+    assert_output "2005-09-16T17:00:00"
 }
 
 @test "EOW on Thursday translates to Sunday at eight in the evening" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "EOW" "2011-05-19T08:30:00"
-  assert_success
-  assert_output "2011-05-22T20:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "EOW" "2011-05-19T08:30:00"
+    assert_success
+    assert_output "2011-05-22T20:00:00"
 }
 
 @test "EOW on Friday translates to Sunday at eight in the evening" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "EOW" "2022-08-05T14:00:00"
-  assert_success
-  assert_output "2022-08-07T20:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "EOW" "2022-08-05T14:00:00"
+    assert_success
+    assert_output "2022-08-07T20:00:00"
 }
 
 @test "EOW translates to leap day" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "EOW" "2008-02-25T10:30:00"
-  assert_success
-  assert_output "2008-02-29T17:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "EOW" "2008-02-25T10:30:00"
+    assert_success
+    assert_output "2008-02-29T17:00:00"
 }
 
 @test "2M before the second month of this year translates to the first workday of the second month of this year" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "2M" "2007-01-02T14:15:00"
-  assert_success
-  assert_output "2007-02-01T08:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "2M" "2007-01-02T14:15:00"
+    assert_success
+    assert_output "2007-02-01T08:00:00"
 }
 
 @test "11M in the eleventh month translates to the first workday of the eleventh month of next year" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "11M" "2013-11-21T15:30:00"
-  assert_success
-  assert_output "2014-11-03T08:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "11M" "2013-11-21T15:30:00"
+    assert_success
+    assert_output "2014-11-03T08:00:00"
 }
 
 @test "4M in the ninth month translates to the first workday of the fourth month of next year" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "4M" "2019-11-18T15:15:00"
-  assert_success
-  assert_output "2020-04-01T08:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "4M" "2019-11-18T15:15:00"
+    assert_success
+    assert_output "2020-04-01T08:00:00"
 }
 
 @test "Q1 in the first quarter translates to the last workday of the first quarter of this year" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "Q1" "2003-01-01T10:45:00"
-  assert_success
-  assert_output "2003-03-31T08:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "Q1" "2003-01-01T10:45:00"
+    assert_success
+    assert_output "2003-03-31T08:00:00"
 }
 
 @test "Q4 in the second quarter translates to the last workday of the fourth quarter of this year" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "Q4" "2001-04-09T09:00:00"
-  assert_success
-  assert_output "2001-12-31T08:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "Q4" "2001-04-09T09:00:00"
+    assert_success
+    assert_output "2001-12-31T08:00:00"
 }
 
 @test "Q3 in the fourth quarter translates to the last workday of the third quarter of next year" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "Q3" "2022-10-06T11:00:00"
-  assert_success
-  assert_output "2023-09-29T08:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "Q3" "2022-10-06T11:00:00"
+    assert_success
+    assert_output "2023-09-29T08:00:00"
 }
 
 @test "Q2 starting in the last month of the second quarter translates to the last workday of the second quarter of this year" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash swift_scheduling.sh "Q2" "2019-06-15T09:50:00"
-  assert_success
-  assert_output "2019-06-28T08:00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash swift_scheduling.sh "Q2" "2019-06-15T09:50:00"
+    assert_success
+    assert_output "2019-06-28T08:00:00"
 }
 
diff --git a/exercises/practice/triangle/.meta/template.j2 b/exercises/practice/triangle/.meta/template.j2
index a8508688..385e5185 100644
--- a/exercises/practice/triangle/.meta/template.j2
+++ b/exercises/practice/triangle/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["descriptions"] | join(": ") }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} {{ case["property"] }} {{ case["input"]["sides"] | join(" ") }}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} {{ case["property"] }} {{ case["input"]["sides"] | join(" ") }}
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/triangle/triangle.bats b/exercises/practice/triangle/triangle.bats
index 38dd3fe4..1169bcf3 100644
--- a/exercises/practice/triangle/triangle.bats
+++ b/exercises/practice/triangle/triangle.bats
@@ -1,151 +1,152 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:25+00:00
+# generated on 2026-08-14T05:27:24+00:00
 
 @test "equilateral triangle: all sides are equal" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh equilateral 2 2 2
-  assert_success
-  assert_output "true"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh equilateral 2 2 2
+    assert_success
+    assert_output "true"
 }
 
 @test "equilateral triangle: any side is unequal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh equilateral 2 3 2
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh equilateral 2 3 2
+    assert_success
+    assert_output "false"
 }
 
 @test "equilateral triangle: no sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh equilateral 5 4 6
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh equilateral 5 4 6
+    assert_success
+    assert_output "false"
 }
 
 @test "equilateral triangle: all zero sides is not a triangle" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh equilateral 0 0 0
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh equilateral 0 0 0
+    assert_success
+    assert_output "false"
 }
 
 @test "equilateral triangle: sides may be floats" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh equilateral 0.5 0.5 0.5
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh equilateral 0.5 0.5 0.5
+    assert_success
+    assert_output "true"
 }
 
 @test "isosceles triangle: last two sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 3 4 4
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 3 4 4
+    assert_success
+    assert_output "true"
 }
 
 @test "isosceles triangle: first two sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 4 4 3
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 4 4 3
+    assert_success
+    assert_output "true"
 }
 
 @test "isosceles triangle: first and last sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 4 3 4
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 4 3 4
+    assert_success
+    assert_output "true"
 }
 
 @test "isosceles triangle: equilateral triangles are also isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 4 4 4
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 4 4 4
+    assert_success
+    assert_output "true"
 }
 
 @test "isosceles triangle: no sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 2 3 4
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 2 3 4
+    assert_success
+    assert_output "false"
 }
 
 @test "isosceles triangle: first triangle inequality violation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 1 1 3
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 1 1 3
+    assert_success
+    assert_output "false"
 }
 
 @test "isosceles triangle: second triangle inequality violation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 1 3 1
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 1 3 1
+    assert_success
+    assert_output "false"
 }
 
 @test "isosceles triangle: third triangle inequality violation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 3 1 1
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 3 1 1
+    assert_success
+    assert_output "false"
 }
 
 @test "isosceles triangle: sides may be floats" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh isosceles 0.5 0.4 0.5
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh isosceles 0.5 0.4 0.5
+    assert_success
+    assert_output "true"
 }
 
 @test "scalene triangle: no sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh scalene 5 4 6
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh scalene 5 4 6
+    assert_success
+    assert_output "true"
 }
 
 @test "scalene triangle: all sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh scalene 4 4 4
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh scalene 4 4 4
+    assert_success
+    assert_output "false"
 }
 
 @test "scalene triangle: first and second sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh scalene 4 4 3
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh scalene 4 4 3
+    assert_success
+    assert_output "false"
 }
 
 @test "scalene triangle: first and third sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh scalene 3 4 3
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh scalene 3 4 3
+    assert_success
+    assert_output "false"
 }
 
 @test "scalene triangle: second and third sides are equal" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh scalene 4 3 3
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh scalene 4 3 3
+    assert_success
+    assert_output "false"
 }
 
 @test "scalene triangle: may not violate triangle inequality" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh scalene 7 3 2
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh scalene 7 3 2
+    assert_success
+    assert_output "false"
 }
 
 @test "scalene triangle: sides may be floats" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash triangle.sh scalene 0.5 0.4 0.6
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash triangle.sh scalene 0.5 0.4 0.6
+    assert_success
+    assert_output "true"
 }
+
diff --git a/exercises/practice/two-fer/.meta/template.j2 b/exercises/practice/two-fer/.meta/template.j2
index fbc92935..0c03c7c2 100644
--- a/exercises/practice/two-fer/.meta/template.j2
+++ b/exercises/practice/two-fer/.meta/template.j2
@@ -2,30 +2,30 @@
 {% for case in cases %}
 @test "{{ case["description"] }}" {
 {%- if loop.first %}
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
 
-  # The above line controls whether to skip the test.
-  # Normally, we skip every test except for the first one
-  # (the first one is always commented out).  This allows for
-  # a person to focus on solving a test at a time: you can
-  # comment out or delete the
-  # `[[ $BATS_RUN_SKIPPED == "true" ]] || skip`
-  # line to run the test when you are ready.
-  #
-  # You can also run all the tests by setting the
-  # `$BATS_RUN_SKIPPED` environment variable, like this:
-  #
-  #     $ BATS_RUN_SKIPPED=true bats two_fer.bats
+    # The above line controls whether to skip the test.
+    # Normally, we skip every test except for the first one
+    # (the first one is always commented out).  This allows for
+    # a person to focus on solving a test at a time: you can
+    # comment out or delete the
+    # `[[ $BATS_RUN_SKIPPED == "true" ]] || skip`
+    # line to run the test when you are ready.
+    #
+    # You can also run all the tests by setting the
+    # `$BATS_RUN_SKIPPED` environment variable, like this:
+    #
+    #     $ BATS_RUN_SKIPPED=true bats two_fer.bats
 {% else %}
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
 {%- endif %}
 {%- if case["input"]["name"] %}
-  run bash {{ solution }} "{{ case["input"]["name"] }}"
+    run bash {{ solution }} "{{ case["input"]["name"] }}"
 {%- else %}
-  run bash {{ solution }}
+    run bash {{ solution }}
 {%- endif %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
 # bash-specific test: Focus the student's attention on the effects of
@@ -33,15 +33,15 @@
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
 @test "handle arg with spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash two_fer.sh "John Smith" "Mary Ann"
-  assert_success
-  assert_output "One for John Smith, one for me."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash two_fer.sh "John Smith" "Mary Ann"
+    assert_success
+    assert_output "One for John Smith, one for me."
 }
 
 @test "handle arg with glob char" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash two_fer.sh "* "
-  assert_success
-  assert_output "One for * , one for me."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash two_fer.sh "* "
+    assert_success
+    assert_output "One for * , one for me."
 }
diff --git a/exercises/practice/two-fer/two_fer.bats b/exercises/practice/two-fer/two_fer.bats
index 2ef0ccc2..ac8f54eb 100644
--- a/exercises/practice/two-fer/two_fer.bats
+++ b/exercises/practice/two-fer/two_fer.bats
@@ -1,41 +1,41 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:25+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "no name given" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-
-  # The above line controls whether to skip the test.
-  # Normally, we skip every test except for the first one
-  # (the first one is always commented out).  This allows for
-  # a person to focus on solving a test at a time: you can
-  # comment out or delete the
-  # `[[ $BATS_RUN_SKIPPED == "true" ]] || skip`
-  # line to run the test when you are ready.
-  #
-  # You can also run all the tests by setting the
-  # `$BATS_RUN_SKIPPED` environment variable, like this:
-  #
-  #     $ BATS_RUN_SKIPPED=true bats two_fer.bats
-
-  run bash two_fer.sh
-  assert_success
-  assert_output "One for you, one for me."
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+
+    # The above line controls whether to skip the test.
+    # Normally, we skip every test except for the first one
+    # (the first one is always commented out).  This allows for
+    # a person to focus on solving a test at a time: you can
+    # comment out or delete the
+    # `[[ $BATS_RUN_SKIPPED == "true" ]] || skip`
+    # line to run the test when you are ready.
+    #
+    # You can also run all the tests by setting the
+    # `$BATS_RUN_SKIPPED` environment variable, like this:
+    #
+    #     $ BATS_RUN_SKIPPED=true bats two_fer.bats
+
+    run bash two_fer.sh
+    assert_success
+    assert_output "One for you, one for me."
 }
 
 @test "a name given" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash two_fer.sh "Alice"
-  assert_success
-  assert_output "One for Alice, one for me."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash two_fer.sh "Alice"
+    assert_success
+    assert_output "One for Alice, one for me."
 }
 
 @test "another name given" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash two_fer.sh "Bob"
-  assert_success
-  assert_output "One for Bob, one for me."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash two_fer.sh "Bob"
+    assert_success
+    assert_output "One for Bob, one for me."
 }
 
 # bash-specific test: Focus the student's attention on the effects of
@@ -43,15 +43,15 @@ load bats-extra
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
 @test "handle arg with spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash two_fer.sh "John Smith" "Mary Ann"
-  assert_success
-  assert_output "One for John Smith, one for me."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash two_fer.sh "John Smith" "Mary Ann"
+    assert_success
+    assert_output "One for John Smith, one for me."
 }
 
 @test "handle arg with glob char" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash two_fer.sh "* "
-  assert_success
-  assert_output "One for * , one for me."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash two_fer.sh "* "
+    assert_success
+    assert_output "One for * , one for me."
 }
diff --git a/exercises/practice/word-count/.meta/template.j2 b/exercises/practice/word-count/.meta/template.j2
index 5f0dd7f6..c706f039 100644
--- a/exercises/practice/word-count/.meta/template.j2
+++ b/exercises/practice/word-count/.meta/template.j2
@@ -1,13 +1,13 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "{{ case["input"]["sentence"] }}"
-  assert_success
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "{{ case["input"]["sentence"] }}"
+    assert_success
 {%- for word, count in case["expected"].items() %}
-  assert_line "{{ word }}: {{ count }}"
+    assert_line "{{ word }}: {{ count }}"
 {%- endfor %}
-  assert_equal "${{ "{" }}#lines[@]}" {{ case["expected"] | length }}
+    assert_equal "${{ "{" }}#lines[@]}" {{ case["expected"] | length }}
 }
 {% endfor %}
 # bash-specific test: Focus the student's attention on the effects of 
@@ -15,10 +15,10 @@
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
 @test "contains shell globbing character" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash {{ solution }} "two * words"
-  assert_success
-  assert_line "two: 1"
-  assert_line "words: 1"
-  assert_equal "${{ "{" }}#lines[@]}" 2
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash {{ solution }} "two * words"
+    assert_success
+    assert_line "two: 1"
+    assert_line "words: 1"
+    assert_equal "${{ "{" }}#lines[@]}" 2
 }
diff --git a/exercises/practice/word-count/word_count.bats b/exercises/practice/word-count/word_count.bats
index 866ec5ea..c0c33586 100644
--- a/exercises/practice/word-count/word_count.bats
+++ b/exercises/practice/word-count/word_count.bats
@@ -1,163 +1,163 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:25+00:00
+# generated on 2026-08-14T05:27:25+00:00
 
 @test "count one word" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "word"
-  assert_success
-  assert_line "word: 1"
-  assert_equal "${#lines[@]}" 1
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "word"
+    assert_success
+    assert_line "word: 1"
+    assert_equal "${#lines[@]}" 1
 }
 
 @test "count one of each word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "one of each"
-  assert_success
-  assert_line "one: 1"
-  assert_line "of: 1"
-  assert_line "each: 1"
-  assert_equal "${#lines[@]}" 3
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "one of each"
+    assert_success
+    assert_line "one: 1"
+    assert_line "of: 1"
+    assert_line "each: 1"
+    assert_equal "${#lines[@]}" 3
 }
 
 @test "multiple occurrences of a word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "one fish two fish red fish blue fish"
-  assert_success
-  assert_line "one: 1"
-  assert_line "fish: 4"
-  assert_line "two: 1"
-  assert_line "red: 1"
-  assert_line "blue: 1"
-  assert_equal "${#lines[@]}" 5
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "one fish two fish red fish blue fish"
+    assert_success
+    assert_line "one: 1"
+    assert_line "fish: 4"
+    assert_line "two: 1"
+    assert_line "red: 1"
+    assert_line "blue: 1"
+    assert_equal "${#lines[@]}" 5
 }
 
 @test "handles cramped lists" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "one,two,three"
-  assert_success
-  assert_line "one: 1"
-  assert_line "two: 1"
-  assert_line "three: 1"
-  assert_equal "${#lines[@]}" 3
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "one,two,three"
+    assert_success
+    assert_line "one: 1"
+    assert_line "two: 1"
+    assert_line "three: 1"
+    assert_equal "${#lines[@]}" 3
 }
 
 @test "handles expanded lists" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "one,
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "one,
 two,
 three"
-  assert_success
-  assert_line "one: 1"
-  assert_line "two: 1"
-  assert_line "three: 1"
-  assert_equal "${#lines[@]}" 3
+    assert_success
+    assert_line "one: 1"
+    assert_line "two: 1"
+    assert_line "three: 1"
+    assert_equal "${#lines[@]}" 3
 }
 
 @test "ignore punctuation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "car: carpet as java: javascript!!&@$%^&"
-  assert_success
-  assert_line "car: 1"
-  assert_line "carpet: 1"
-  assert_line "as: 1"
-  assert_line "java: 1"
-  assert_line "javascript: 1"
-  assert_equal "${#lines[@]}" 5
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "car: carpet as java: javascript!!&@$%^&"
+    assert_success
+    assert_line "car: 1"
+    assert_line "carpet: 1"
+    assert_line "as: 1"
+    assert_line "java: 1"
+    assert_line "javascript: 1"
+    assert_equal "${#lines[@]}" 5
 }
 
 @test "include numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "testing, 1, 2 testing"
-  assert_success
-  assert_line "testing: 2"
-  assert_line "1: 1"
-  assert_line "2: 1"
-  assert_equal "${#lines[@]}" 3
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "testing, 1, 2 testing"
+    assert_success
+    assert_line "testing: 2"
+    assert_line "1: 1"
+    assert_line "2: 1"
+    assert_equal "${#lines[@]}" 3
 }
 
 @test "normalize case" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "go Go GO Stop stop"
-  assert_success
-  assert_line "go: 3"
-  assert_line "stop: 2"
-  assert_equal "${#lines[@]}" 2
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "go Go GO Stop stop"
+    assert_success
+    assert_line "go: 3"
+    assert_line "stop: 2"
+    assert_equal "${#lines[@]}" 2
 }
 
 @test "with apostrophes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "'First: don't laugh. Then: don't cry. You're getting it.'"
-  assert_success
-  assert_line "first: 1"
-  assert_line "don't: 2"
-  assert_line "laugh: 1"
-  assert_line "then: 1"
-  assert_line "cry: 1"
-  assert_line "you're: 1"
-  assert_line "getting: 1"
-  assert_line "it: 1"
-  assert_equal "${#lines[@]}" 8
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "'First: don't laugh. Then: don't cry. You're getting it.'"
+    assert_success
+    assert_line "first: 1"
+    assert_line "don't: 2"
+    assert_line "laugh: 1"
+    assert_line "then: 1"
+    assert_line "cry: 1"
+    assert_line "you're: 1"
+    assert_line "getting: 1"
+    assert_line "it: 1"
+    assert_equal "${#lines[@]}" 8
 }
 
 @test "with quotations" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "Joe can't tell between 'large' and large."
-  assert_success
-  assert_line "joe: 1"
-  assert_line "can't: 1"
-  assert_line "tell: 1"
-  assert_line "between: 1"
-  assert_line "large: 2"
-  assert_line "and: 1"
-  assert_equal "${#lines[@]}" 6
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "Joe can't tell between 'large' and large."
+    assert_success
+    assert_line "joe: 1"
+    assert_line "can't: 1"
+    assert_line "tell: 1"
+    assert_line "between: 1"
+    assert_line "large: 2"
+    assert_line "and: 1"
+    assert_equal "${#lines[@]}" 6
 }
 
 @test "substrings from the beginning" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "Joe can't tell between app, apple and a."
-  assert_success
-  assert_line "joe: 1"
-  assert_line "can't: 1"
-  assert_line "tell: 1"
-  assert_line "between: 1"
-  assert_line "app: 1"
-  assert_line "apple: 1"
-  assert_line "and: 1"
-  assert_line "a: 1"
-  assert_equal "${#lines[@]}" 8
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "Joe can't tell between app, apple and a."
+    assert_success
+    assert_line "joe: 1"
+    assert_line "can't: 1"
+    assert_line "tell: 1"
+    assert_line "between: 1"
+    assert_line "app: 1"
+    assert_line "apple: 1"
+    assert_line "and: 1"
+    assert_line "a: 1"
+    assert_equal "${#lines[@]}" 8
 }
 
 @test "multiple spaces not detected as a word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh " multiple   whitespaces"
-  assert_success
-  assert_line "multiple: 1"
-  assert_line "whitespaces: 1"
-  assert_equal "${#lines[@]}" 2
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh " multiple   whitespaces"
+    assert_success
+    assert_line "multiple: 1"
+    assert_line "whitespaces: 1"
+    assert_equal "${#lines[@]}" 2
 }
 
 @test "alternating word separators not detected as a word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh ",
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh ",
 ,one,
  ,two 
  'three'"
-  assert_success
-  assert_line "one: 1"
-  assert_line "two: 1"
-  assert_line "three: 1"
-  assert_equal "${#lines[@]}" 3
+    assert_success
+    assert_line "one: 1"
+    assert_line "two: 1"
+    assert_line "three: 1"
+    assert_equal "${#lines[@]}" 3
 }
 
 @test "quotation for word with apostrophe" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "can, can't, 'can't'"
-  assert_success
-  assert_line "can: 1"
-  assert_line "can't: 2"
-  assert_equal "${#lines[@]}" 2
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "can, can't, 'can't'"
+    assert_success
+    assert_line "can: 1"
+    assert_line "can't: 2"
+    assert_equal "${#lines[@]}" 2
 }
 
 # bash-specific test: Focus the student's attention on the effects of 
@@ -165,10 +165,10 @@ three"
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
 @test "contains shell globbing character" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run bash word_count.sh "two * words"
-  assert_success
-  assert_line "two: 1"
-  assert_line "words: 1"
-  assert_equal "${#lines[@]}" 2
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run bash word_count.sh "two * words"
+    assert_success
+    assert_line "two: 1"
+    assert_line "words: 1"
+    assert_equal "${#lines[@]}" 2
 }