whatnext 3.3.2__tar.gz → 3.4__tar.gz

{whatnext-3.3.2 → whatnext-3.4}/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Changelog
 
 
+## [v3.4] - 2026-04-17
+
+**Added:**
+- Task muting: temporarily hide tasks matching patterns from output by
+  using `whatnext --mute [time] [match]`.
+
+
 ## [v3.3.2] - 2026-04-17
 
 **Fixes:** `@after` with a directory waits on all tasks under that dir.
@@ -62,12 +69,14 @@ Previously `whatnext` assumed a flat hierarchy of unique filenames.
   the file; the first phase is always visible, and subsequent phases
   will only show when all previous phases are complete.
 
+## [v2.1.1] - 2026-02-10
+
 **Fixes:**
 - `@after` referencing a file excluded by `--ignore` no longer warns about
   the file not existing, instead treating the dependency as complete.
 
 
-## [v2.0] - 2026-02-09
+## [v2.1] - 2026-02-09
 
 Added `@queue` directive show only one task at a time, for simple sequential
 work that doesn't need to be split across files using `@after`.

{whatnext-3.3.2 → whatnext-3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whatnext
-Version: 3.3.2
+Version: 3.4
 Summary: A lister of tasks found in Markdown files
 Project-URL: Homepage, https://github.com/norm/whatnext
 Project-URL: Repository, https://github.com/norm/whatnext

{whatnext-3.3.2 → whatnext-3.4}/docs/usage.md

@@ -232,6 +232,11 @@ To show a random selection of tasks rather than by priority, use `5r`.
 
 -   `--ignore-all` — ignore all deferral constraints (`@after`, `@phase`, `@queue`).
 
+-   `--ignore-mute` — ignore mute settings.
+
+-   `--mute [time] [match]` — for the next 'time' period (formatted `4d`, `2w`, `1m2d`)
+    mute any tasks with 'match' in the text, header, or filename.
+
 -   `-o` / `--open` — show only open tasks.
 
 -   `-p` / `--partial` — show only in progress tasks.

whatnext-3.4/tasks/muting.md

@@ -0,0 +1,18 @@
+There is a difference between the _truth_ of the tasks as captured in the
+files, where dependencies are declared, and the _availability_ of what can or
+will be done by an individual on a team, so the person running `whatnext`
+should be able to temporarily or permanently ignore a task or group of tasks
+from showing up as available for them to work on.
+
+- [X] `.whatnext.mute` merges with `.whatnext` to populate the 'mute' key in
+      the config
+        - contains a list, each entry being a timestamp and a match pattern
+        - if the timestamp is now in the past, the entry is removed
+- [X] listing tasks uses the mute list
+        - anything matching a pattern is excluded from output
+        - `--ignore-mute`, `--ignore-all`, `--all` bypasses this
+        - show a count of muted tasks at the end
+- [X] `whatnext --mute 'period' 'pattern'` creates the entry
+        - period is formatted like 1d, 2d, 1w, 1m, 2m3w
+        - pattern cannot be empty
+- [ ] if `whatnext [...]` produces no tasks, try again without the mute list

{whatnext-3.3.2 → whatnext-3.4}/tests/config.bats

@@ -82,3 +82,13 @@ function setup {
     diff -u <(echo "$expected_output") <(echo "$output")
     [ $status -eq 0 ]
 }
+
+@test "expired mute entries removed from file" {
+    cp -r "$BATS_TEST_DIRNAME/mute/." "$BATS_TEST_TMPDIR"
+
+    run --separate-stderr \
+        whatnext --dir "$BATS_TEST_TMPDIR"
+
+    diff -u "$BATS_TEST_DIRNAME/mute/.whatnext.mute.expected" "$BATS_TEST_TMPDIR/.whatnext.mute"
+    [ $status -eq 0 ]
+}

whatnext-3.4/tests/mute/.whatnext.mute

@@ -0,0 +1,4 @@
+[[mute]]
+until = 2099-12-31T23:59:59
+pattern = "future"
+

whatnext-3.4/tests/mute/.whatnext.mute.expected

@@ -0,0 +1,4 @@
+[[mute]]
+until = 2099-12-31T23:59:59
+pattern = "future"
+

whatnext-3.4/tests/mute/tasks.md

@@ -0,0 +1,7 @@
+# Shopping
+- [ ] buy apples
+- [ ] buy oranges
+
+# Gardening
+- [ ] plant seeds
+- [ ] water plants

whatnext-3.4/tests/mute-fixture/tasks.md

@@ -0,0 +1,7 @@
+# Shopping
+- [ ] buy apples
+- [ ] buy oranges
+
+# Gardening
+- [ ] plant seeds
+- [ ] water plants

whatnext-3.4/tests/mute.bats

@@ -0,0 +1,180 @@
+bats_require_minimum_version 1.5.0
+
+@test "--mute creates mute entry" {
+    run whatnext --config "$BATS_TEST_TMPDIR/.whatnext" --mute 1d "apples"
+
+    # check pattern is in file (until timestamp varies)
+    diff -u <(echo 'pattern = "apples"') <(grep 'pattern' "$BATS_TEST_TMPDIR/.whatnext.mute")
+    [ $status -eq 0 ]
+}
+
+@test "--mute appends to existing file" {
+    sed -e 's/^        //' > "$BATS_TEST_TMPDIR/.whatnext.mute" <<-EOF
+        [[mute]]
+        until = 2099-12-31T23:59:59
+        pattern = "existing"
+	EOF
+
+    run whatnext --config "$BATS_TEST_TMPDIR/.whatnext" --mute 1w "new"
+
+    expected=$(sed -e 's/^        //' <<-EOF
+        pattern = "existing"
+        pattern = "new"
+	EOF
+    )
+    diff -u <(echo "$expected") <(grep 'pattern' "$BATS_TEST_TMPDIR/.whatnext.mute")
+    [ $status -eq 0 ]
+}
+
+@test "--mute rejects empty pattern" {
+    run --separate-stderr \
+        whatnext --config "$BATS_TEST_TMPDIR/.whatnext" --mute 1d ""
+
+    diff -u <(echo "ERROR: pattern cannot be empty") <(echo "$stderr")
+    [ $status -eq 1 ]
+}
+
+@test "--mute rejects invalid period" {
+    run --separate-stderr \
+        whatnext --config "$BATS_TEST_TMPDIR/.whatnext" --mute "abc" "pattern"
+
+    diff -u <(echo "ERROR: invalid period 'abc'") <(echo "$stderr")
+    [ $status -eq 1 ]
+}
+
+@test "muted tasks are excluded from output" {
+    sed -e 's/^        //' > "$BATS_TEST_TMPDIR/.whatnext.mute" <<-EOF
+        [[mute]]
+        until = 2099-12-31T23:59:59
+        pattern = "apples"
+	EOF
+
+    expected_output=$(sed -e 's/^        //' <<-EOF
+        tasks.md:
+            # Shopping
+            - [ ] buy oranges
+            # Gardening
+            - [ ] plant seeds
+            - [ ] water plants
+
+        (1 task muted)
+	EOF
+    )
+
+    run --separate-stderr \
+        whatnext --config "$BATS_TEST_TMPDIR/.whatnext" tests/mute
+
+    diff -u <(echo "$expected_output") <(echo "$output")
+    [[ $status -eq 0 ]]
+}
+
+@test "muting matches heading" {
+    sed -e 's/^        //' > "$BATS_TEST_TMPDIR/.whatnext.mute" <<-EOF
+        [[mute]]
+        until = 2099-12-31T23:59:59
+        pattern = "shopping"
+	EOF
+
+    expected_output=$(sed -e 's/^        //' <<-EOF
+        tasks.md:
+            # Gardening
+            - [ ] plant seeds
+            - [ ] water plants
+
+        (2 tasks muted)
+	EOF
+    )
+
+    run --separate-stderr \
+        whatnext --config "$BATS_TEST_TMPDIR/.whatnext" tests/mute
+
+    diff -u <(echo "$expected_output") <(echo "$output")
+    [[ $status -eq 0 ]]
+}
+
+@test "muting matches filename" {
+    sed -e 's/^        //' > "$BATS_TEST_TMPDIR/.whatnext.mute" <<-EOF
+        [[mute]]
+        until = 2099-12-31T23:59:59
+        pattern = "tasks"
+	EOF
+
+    expected_output=$(sed -e 's/^        //' <<-EOF
+        Only muted tasks remain:
+
+        tasks.md:
+            # Shopping
+            - [ ] buy apples
+            - [ ] buy oranges
+            # Gardening
+            - [ ] plant seeds
+            - [ ] water plants
+	EOF
+    )
+
+    run --separate-stderr \
+        whatnext --config "$BATS_TEST_TMPDIR/.whatnext" tests/mute
+
+    diff -u <(echo "$expected_output") <(echo "$output")
+    [[ $status -eq 0 ]]
+}
+
+@test "multiple patterns exclude multiple tasks" {
+    sed -e 's/^        //' > "$BATS_TEST_TMPDIR/.whatnext.mute" <<-EOF
+        [[mute]]
+        until = 2099-12-31T23:59:59
+        pattern = "apples"
+
+        [[mute]]
+        until = 2099-12-31T23:59:59
+        pattern = "seeds"
+	EOF
+
+    expected_output=$(sed -e 's/^        //' <<-EOF
+        tasks.md:
+            # Shopping
+            - [ ] buy oranges
+            # Gardening
+            - [ ] water plants
+
+        (2 tasks muted)
+	EOF
+    )
+
+    run --separate-stderr \
+        whatnext --config "$BATS_TEST_TMPDIR/.whatnext" tests/mute
+
+    diff -u <(echo "$expected_output") <(echo "$output")
+    [[ $status -eq 0 ]]
+}
+
+@test "options bypass mute filtering" {
+    sed -e 's/^        //' > "$BATS_TEST_TMPDIR/.whatnext.mute" <<-EOF
+        [[mute]]
+        until = 2099-12-31T23:59:59
+        pattern = "apples"
+	EOF
+
+    # no count when nothing muted
+    expected_output=$(sed -e 's/^        //' <<-EOF
+        tasks.md:
+            # Shopping
+            - [ ] buy apples
+            - [ ] buy oranges
+            # Gardening
+            - [ ] plant seeds
+            - [ ] water plants
+	EOF
+    )
+
+    for flag in --ignore-mute --all --ignore-all; do
+        run --separate-stderr \
+            whatnext \
+                --config "$BATS_TEST_TMPDIR/.whatnext" \
+                "$flag" \
+                    tests/mute
+
+        diff -u <(echo "$expected_output") <(echo "$output")
+        [[ $status -eq 0 ]]
+    done
+}

whatnext-3.4/tests/test_config.py

@@ -0,0 +1,43 @@
+import shutil
+from datetime import timedelta
+
+import pytest
+
+from whatnext.whatnext import load_config, parse_period, resolve_config_path
+
+
+class TestParsePeriod:
+    def test_days(self):
+        assert parse_period("1d") == timedelta(days=1)
+        assert parse_period("5d") == timedelta(days=5)
+
+    def test_weeks(self):
+        assert parse_period("1w") == timedelta(weeks=1)
+        assert parse_period("2w") == timedelta(weeks=2)
+
+    def test_months(self):
+        assert parse_period("1m") == timedelta(days=30)
+        assert parse_period("2m") == timedelta(days=60)
+
+    def test_combined(self):
+        assert parse_period("2m3w") == timedelta(days=60 + 21)
+        assert parse_period("1m2w3d") == timedelta(days=30 + 14 + 3)
+
+    def test_invalid_format_raises(self):
+        with pytest.raises(ValueError):
+            parse_period("")
+        with pytest.raises(ValueError):
+            parse_period("abc")
+        with pytest.raises(ValueError):
+            parse_period("1x")
+
+
+class TestMuteLoading:
+    def test_expired_mutes_filtered_from_config(self, tmp_path):
+        shutil.copytree("tests/mute", tmp_path / "mute")
+        config_path = resolve_config_path(None, str(tmp_path / "mute"))
+        config = load_config(config_path, extensions=["mute"])
+
+        patterns = [entry["pattern"] for entry in config["mute"]]
+        assert "future" in patterns
+        assert "old" not in patterns

whatnext-3.4/tests/test_mute.py

@@ -0,0 +1,115 @@
+from datetime import date
+from textwrap import dedent
+
+from whatnext.models import MarkdownFile
+from whatnext.whatnext import filter_muted
+
+
+def make_data(source_string):
+    file = MarkdownFile(source_string=source_string, today=date(2025, 1, 1))
+    return [(file, file.tasks)]
+
+
+class TestFilterMuted:
+    def test_empty_mute_list_returns_all_tasks(self):
+        data = make_data(dedent("""\
+            - [ ] first task
+            - [ ] second task
+        """))
+
+        filtered, count = filter_muted(data, [])
+
+        assert len(filtered[0][1]) == 2
+        assert count == 0
+
+    def test_pattern_matches_task_text(self):
+        data = make_data(dedent("""\
+            - [ ] buy apples
+            - [ ] buy oranges
+        """))
+
+        filtered, count = filter_muted(data, ["apples"])
+
+        assert len(filtered[0][1]) == 1
+        assert filtered[0][1][0].text == "buy oranges"
+        assert count == 1
+
+    def test_pattern_matches_heading(self):
+        data = make_data(dedent("""\
+            # Shopping
+            - [ ] buy apples
+            # Gardening
+            - [ ] plant seeds
+        """))
+
+        filtered, count = filter_muted(data, ["shopping"])
+
+        assert len(filtered[0][1]) == 1
+        assert filtered[0][1][0].text == "plant seeds"
+        assert count == 1
+
+    def test_matching_is_case_insensitive(self):
+        data = make_data(dedent("""\
+            - [ ] Buy APPLES
+            - [ ] buy oranges
+        """))
+
+        filtered, count = filter_muted(data, ["apples"])
+
+        assert len(filtered[0][1]) == 1
+        assert filtered[0][1][0].text == "buy oranges"
+        assert count == 1
+
+    def test_multiple_patterns_any_match_excludes(self):
+        data = make_data(dedent("""\
+            - [ ] buy apples
+            - [ ] buy oranges
+            - [ ] buy bananas
+        """))
+
+        filtered, count = filter_muted(data, ["apples", "oranges"])
+
+        assert len(filtered[0][1]) == 1
+        assert filtered[0][1][0].text == "buy bananas"
+        assert count == 2
+
+    def test_no_match_includes_task(self):
+        data = make_data(dedent("""\
+            - [ ] buy apples
+            - [ ] buy oranges
+        """))
+
+        filtered, count = filter_muted(data, ["bananas"])
+
+        assert len(filtered[0][1]) == 2
+        assert count == 0
+
+    def test_counts_across_multiple_files(self):
+        file1 = MarkdownFile(
+            source_string="- [ ] buy apples\n- [ ] buy oranges\n",
+            today=date(2025, 1, 1),
+        )
+        file2 = MarkdownFile(
+            source_string="- [ ] plant apples\n- [ ] plant oranges\n",
+            today=date(2025, 1, 1),
+        )
+        data = [(file1, file1.tasks), (file2, file2.tasks)]
+
+        filtered, count = filter_muted(data, ["apples"])
+
+        assert len(filtered[0][1]) == 1
+        assert len(filtered[1][1]) == 1
+        assert count == 2
+
+    def test_pattern_matches_filename(self):
+        file = MarkdownFile(
+            source_string="- [ ] first task\n- [ ] second task\n",
+            path="shopping.md",
+            today=date(2025, 1, 1),
+        )
+        data = [(file, file.tasks)]
+
+        filtered, count = filter_muted(data, ["shopping"])
+
+        assert len(filtered[0][1]) == 0
+        assert count == 2

{whatnext-3.3.2 → whatnext-3.4}/tests/usage.bats

@@ -8,9 +8,10 @@ bats_require_minimum_version 1.5.0
     expected_output=$(sed -e 's/^        //' <<"        EOF"
         Usage: whatnext [-h] [--help] [--version] [--guide] [--dir DIR] [-s] [-e]
                         [--relative] [-a] [--ignore-after] [--ignore-queue]
-                        [--ignore-phase] [--ignore-all] [--config CONFIG]
-                        [--ignore PATTERN] [-q] [-o] [-p] [-b] [-d] [-c]
-                        [--priority LEVEL] [--color | --no-color]
+                        [--ignore-phase] [--ignore-all] [--ignore-mute]
+                        [--mute TIME MATCH] [--config CONFIG] [--ignore PATTERN] [-q]
+                        [-o] [-p] [-b] [-d] [-c] [--priority LEVEL]
+                        [--color | --no-color]
                         [match ...]
         EOF
     )
@@ -26,9 +27,10 @@ bats_require_minimum_version 1.5.0
     expected_output=$(sed -e 's/^        //' <<"        EOF"
         Usage: whatnext [-h] [--help] [--version] [--guide] [--dir DIR] [-s] [-e]
                         [--relative] [-a] [--ignore-after] [--ignore-queue]
-                        [--ignore-phase] [--ignore-all] [--config CONFIG]
-                        [--ignore PATTERN] [-q] [-o] [-p] [-b] [-d] [-c]
-                        [--priority LEVEL] [--color | --no-color]
+                        [--ignore-phase] [--ignore-all] [--ignore-mute]
+                        [--mute TIME MATCH] [--config CONFIG] [--ignore PATTERN] [-q]
+                        [-o] [-p] [-b] [-d] [-c] [--priority LEVEL]
+                        [--color | --no-color]
                         [match ...]
 
         List tasks found in Markdown files
@@ -58,6 +60,9 @@ bats_require_minimum_version 1.5.0
           --ignore-phase       Ignore @phase constraints
           --ignore-all         Ignore all deferral constraints (@after, @phase,
                                @queue)
+          --ignore-mute        Ignore mute settings
+          --mute TIME MATCH    Mute tasks matching pattern for period (e.g. 1d, 2w,
+                               1m)
           --config CONFIG      Path to config file (default: WHATNEXT_CONFIG, or
                                '.whatnext' in --dir)
           --ignore PATTERN     Ignore files matching pattern (can be specified

{whatnext-3.3.2 → whatnext-3.4}/whatnext/next.py

@@ -7,7 +7,7 @@ import sys
 import textwrap
 
 from whatnext.models import MarkdownFile
-from whatnext.whatnext import load_config
+from whatnext.whatnext import load_config, resolve_config_path
 
 
 def rewind_insertion_point(lines, position, min_position):
@@ -63,7 +63,9 @@ def get_wrap_width(lines, tasks_file, config_path):
     if env_width:
         default_width = int(env_width)
     else:
-        config = load_config(config_path, os.path.dirname(tasks_file) or ".")
+        directory = os.path.dirname(tasks_file) or "."
+        resolved_path = resolve_config_path(config_path, directory)
+        config = load_config(resolved_path)
         default_width = config.get("wrap_width", 80)
     file_width = detect_task_width(lines)
     return max(file_width, default_width)

{whatnext-3.3.2 → whatnext-3.4}/whatnext/whatnext.py

@@ -1,5 +1,5 @@
 import argparse
-from datetime import date
+from datetime import date, datetime, timedelta
 import fnmatch
 import importlib.metadata
 import importlib.resources
@@ -29,6 +29,28 @@ PRIORITY_COLOURS = {
 ACTIVE_STATES = {State.OPEN, State.IN_PROGRESS, State.BLOCKED}
 COMPLETE_STATES = {State.COMPLETE, State.CANCELLED}
 
+PERIOD_PATTERN = re.compile(r'(\d+)([dwm])')
+
+
+def parse_period(period_str):
+    matches = PERIOD_PATTERN.findall(period_str)
+    if not matches:
+        raise ValueError(f"invalid period '{period_str}'")
+    # verify the entire string was consumed
+    reconstructed = ''.join(f"{n}{u}" for n, u in matches)
+    if reconstructed != period_str:
+        raise ValueError(f"invalid period '{period_str}'")
+    total_days = 0
+    for amount, unit in matches:
+        amount = int(amount)
+        if unit == 'd':
+            total_days += amount
+        elif unit == 'w':
+            total_days += amount * 7
+        elif unit == 'm':
+            total_days += amount * 30
+    return timedelta(days=total_days)
+
 
 class CircularDependencyError(Exception):
     pass
@@ -226,6 +248,35 @@ def filter_phases(data):
     return result
 
 
+def filter_muted(data, mute_patterns):
+    if not mute_patterns:
+        return data, 0
+
+    muted_count = 0
+    result = []
+    for file, tasks in data:
+        file_lower = file.display_path.lower()
+        filtered_tasks = []
+        for task in tasks:
+            heading_lower = ""
+            if task.heading:
+                heading_lower = task.heading.lower()
+            text_lower = task.text.lower()
+            is_muted = any(
+                pattern in file_lower
+                or pattern in heading_lower
+                or pattern in text_lower
+                for pattern in mute_patterns
+            )
+            if is_muted:
+                muted_count += 1
+            else:
+                filtered_tasks.append(task)
+        result.append((file, filtered_tasks))
+
+    return result, muted_count
+
+
 def get_terminal_width():
     columns_env = os.environ.get("COLUMNS")
     if columns_env:
@@ -244,15 +295,45 @@ def get_editor():
     return "vi"
 
 
-def load_config(config_path=None, directory="."):
+def resolve_config_path(config_path, directory):
     if config_path is None:
-        config_path = os.path.join(directory, ".whatnext")
-    elif not (config_path.startswith("./") or os.path.isabs(config_path)):
-        config_path = os.path.join(directory, config_path)
+        return os.path.join(directory, ".whatnext")
+    if config_path.startswith("./") or os.path.isabs(config_path):
+        return config_path
+    return os.path.join(directory, config_path)
+
+
+def write_mute_config(config_path, mutes):
+    mute_path = config_path + ".mute"
+    with open(mute_path, "w") as handle:
+        toml.dump({"mute": mutes}, handle)
+
+
+def load_config(config_path, extensions=None):
     if os.path.exists(config_path):
         with open(config_path) as handle:
-            return toml.load(handle)
-    return {}
+            config = toml.load(handle)
+    else:
+        config = {}
+
+    if extensions:
+        for ext in extensions:
+            ext_path = config_path + "." + ext
+            if os.path.exists(ext_path):
+                with open(ext_path) as handle:
+                    config[ext] = toml.load(handle).get(ext, [])
+
+    if "mute" in config:
+        now = datetime.now()
+        original = config["mute"]
+        config["mute"] = [
+            entry for entry in original
+            if entry["until"] > now
+        ]
+        if len(config["mute"]) != len(original):
+            write_mute_config(config_path, config["mute"])
+
+    return config
 
 
 def is_ignored(filepath, ignore_patterns):
@@ -522,6 +603,17 @@ def main():
         action="store_true",
         help="Ignore all deferral constraints (@after, @phase, @queue)",
     )
+    parser.add_argument(
+        "--ignore-mute",
+        action="store_true",
+        help="Ignore mute settings",
+    )
+    parser.add_argument(
+        "--mute",
+        nargs=2,
+        metavar=("TIME", "MATCH"),
+        help="Mute tasks matching pattern for period (e.g. 1d, 2w, 1m)",
+    )
     parser.add_argument(
         "--config",
         default=os.environ.get("WHATNEXT_CONFIG"),
@@ -593,6 +685,24 @@ def main():
              "    [n]r       - limit to n results, selected at random",
     )
     args = parser.parse_args()
+    config_path = resolve_config_path(args.config, args.dir)
+
+    if args.mute:
+        period_str, pattern = args.mute
+        if not pattern:
+            print("ERROR: pattern cannot be empty", file=sys.stderr)
+            sys.exit(1)
+        try:
+            period = parse_period(period_str)
+        except ValueError as e:
+            print(f"ERROR: {e}", file=sys.stderr)
+            sys.exit(1)
+        until = datetime.now() + period
+        config = load_config(config_path, extensions=["mute"])
+        mutes = config.get("mute", [])
+        mutes.append({"until": until, "pattern": pattern})
+        write_mute_config(config_path, mutes)
+        return
 
     # build the search space
     paths = []
@@ -613,8 +723,12 @@ def main():
     if not paths:
         paths = [args.dir]
 
-    config = load_config(args.config, args.dir)
+    config = load_config(config_path, extensions=["mute"])
     ignore_patterns = config.get("ignore", []) + args.ignore
+    mute_patterns = [
+        entry["pattern"].lower()
+        for entry in config.get("mute", [])
+    ]
     quiet = args.quiet
 
     if "WHATNEXT_TODAY" in os.environ:
@@ -687,6 +801,12 @@ def main():
     ):
         filtered_data = filter_queue(filtered_data)
 
+    muted_count = 0
+    pre_mute_data = None
+    if not args.all and not args.ignore_all and not args.ignore_mute:
+        pre_mute_data = filtered_data
+        filtered_data, muted_count = filter_muted(filtered_data, mute_patterns)
+
     if args.summary:
         output = format_summary(
             filtered_data,
@@ -701,6 +821,10 @@ def main():
         )
     else:
         tasks = flatten_by_priority(filtered_data)
+        all_muted = False
+        if not tasks and muted_count > 0:
+            tasks = flatten_by_priority(pre_mute_data)
+            all_muted = True
         if randomise:
             random.shuffle(tasks)
         if limit:
@@ -716,6 +840,10 @@ def main():
             for line, filepath in files_to_edit:
                 subprocess.run([editor, f"+{line}", filepath])
 
+        if all_muted:
+            print("Only muted tasks remain:\n")
+            muted_count = 0
+
         output = format_tasks(
             tasks,
             get_terminal_width(),
@@ -723,3 +851,9 @@ def main():
         )
 
     print(output)
+
+    if muted_count > 0:
+        noun = "tasks"
+        if muted_count == 1:
+            noun = "task"
+        print(f"\n({muted_count} {noun} muted)")