taskcheck 1.3.1__tar.gz → 1.4.1__tar.gz

{taskcheck-1.3.1/taskcheck.egg-info → taskcheck-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskcheck
-Version: 1.3.1
+Version: 1.4.1
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -33,6 +33,7 @@ Use it if you want to:
 - 🧭 Support complex working-hour maps
 - ⏱️ Consider urgency, due dates, and dependencies
 - 🧪 Dry-run mode to preview changes
+- ↩️ Undo the latest schedule update
 - 🧠 Auto-adjust urgency when deadlines cannot be met
 - 🔄 Force-refresh iCal calendars
 - 📊 Custom reports for planned and unplanned tasks
@@ -46,6 +47,7 @@ Use it if you want to:
 3. add `estimated` + `time_map` UDAs
 4. edit `~/.config/task/taskcheck.toml` (see [Reference](#Reference))
 5. `taskcheck --schedule`
+6. `taskcheck --undo` restores the scheduling fields changed by the latest run
 
 ## How it works
 
@@ -88,11 +90,10 @@ In short:
 - it installs required Taskwarrior settings if you confirm the first prompt
 - it installs optional urgency/report tuning if you confirm the second prompt
 - it can also create the default config file if you confirm the third prompt
-- it does **not** schedule tasks or fetch calendars
 - scheduling happens with `taskcheck --schedule`
 - all flags/config keys/settings are documented in `REFERENCE.md`
 
-## Algorithm
+## They say it's an AI
 
 The algorithm simulates a workday one chunk at a time.
 
@@ -104,7 +105,9 @@ For `today`, taskcheck skips past hours.
 
 The default work chunk is 2 hours (or less if the task is shorter); you can tune it with the Taskwarrior UDA `min_block`.
 
-If a task would finish after its `due_date`, taskcheck retries. It keeps that task's current non-due urgency weight, then lowers the weight by 0.1 only for tasks that have not missed a deadline. Due urgency is never reduced. Retries stop when deadlines are respected or unflagged tasks reach a weight of 0.
+Before writing a schedule, taskcheck backs up the affected tasks' `scheduled`, `completion_date`, and `scheduling` fields under the Taskwarrior data directory. `taskcheck --undo` restores and consumes the newest backup. The `[scheduler]` option `n_undos` controls retention and defaults to `1`; set it to `0` to disable backups.
+
+If a task would finish after its due date, taskcheck retries with a total-urgency override. Each retry moves the task immediately above the task with the smallest greater urgency by adding `urgency_epsilon` (default: `0.1`). At rank 1, it adds epsilon for up to `max_top_urgency_rounds` retries (default: `10`), then tries once at urgency `1000`. If the task is still late, taskcheck stops raising it and optimizes the other overdue tasks.
 
 ## Tips and Tricks
 

{taskcheck-1.3.1 → taskcheck-1.4.1}/README.md

@@ -18,6 +18,7 @@ Use it if you want to:
 - 🧭 Support complex working-hour maps
 - ⏱️ Consider urgency, due dates, and dependencies
 - 🧪 Dry-run mode to preview changes
+- ↩️ Undo the latest schedule update
 - 🧠 Auto-adjust urgency when deadlines cannot be met
 - 🔄 Force-refresh iCal calendars
 - 📊 Custom reports for planned and unplanned tasks
@@ -31,6 +32,7 @@ Use it if you want to:
 3. add `estimated` + `time_map` UDAs
 4. edit `~/.config/task/taskcheck.toml` (see [Reference](#Reference))
 5. `taskcheck --schedule`
+6. `taskcheck --undo` restores the scheduling fields changed by the latest run
 
 ## How it works
 
@@ -73,11 +75,10 @@ In short:
 - it installs required Taskwarrior settings if you confirm the first prompt
 - it installs optional urgency/report tuning if you confirm the second prompt
 - it can also create the default config file if you confirm the third prompt
-- it does **not** schedule tasks or fetch calendars
 - scheduling happens with `taskcheck --schedule`
 - all flags/config keys/settings are documented in `REFERENCE.md`
 
-## Algorithm
+## They say it's an AI
 
 The algorithm simulates a workday one chunk at a time.
 
@@ -89,7 +90,9 @@ For `today`, taskcheck skips past hours.
 
 The default work chunk is 2 hours (or less if the task is shorter); you can tune it with the Taskwarrior UDA `min_block`.
 
-If a task would finish after its `due_date`, taskcheck retries. It keeps that task's current non-due urgency weight, then lowers the weight by 0.1 only for tasks that have not missed a deadline. Due urgency is never reduced. Retries stop when deadlines are respected or unflagged tasks reach a weight of 0.
+Before writing a schedule, taskcheck backs up the affected tasks' `scheduled`, `completion_date`, and `scheduling` fields under the Taskwarrior data directory. `taskcheck --undo` restores and consumes the newest backup. The `[scheduler]` option `n_undos` controls retention and defaults to `1`; set it to `0` to disable backups.
+
+If a task would finish after its due date, taskcheck retries with a total-urgency override. Each retry moves the task immediately above the task with the smallest greater urgency by adding `urgency_epsilon` (default: `0.1`). At rank 1, it adds epsilon for up to `max_top_urgency_rounds` retries (default: `10`), then tries once at urgency `1000`. If the task is still late, taskcheck stops raising it and optimizes the other overdue tasks.
 
 ## Tips and Tricks
 

{taskcheck-1.3.1 → taskcheck-1.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taskcheck"
-version = "1.3.1"
+version = "1.4.1"
 description = "Automatic scheduler for taskwarrior"
 readme = "README.md"
 requires-python = ">=3.11"

{taskcheck-1.3.1 → taskcheck-1.4.1}/taskcheck/__main__.py

@@ -28,6 +28,11 @@ arg_parser.add_argument(
     action="store_true",
     help="Perform the scheduling algorithm, giving a schedule and a scheduling UDA and alerting for not completable tasks.",
 )
+arg_parser.add_argument(
+    "--undo",
+    action="store_true",
+    help="Restore task scheduling fields from the most recent backup.",
+)
 arg_parser.add_argument(
     "-f",
     "--force-update",
@@ -107,6 +112,12 @@ def main():
         install()
         return
 
+    if getattr(args, "undo", False) is True:
+        from taskcheck.undo import restore_latest_backup
+
+        restore_latest_backup(taskrc=args.taskrc)
+        return
+
     if getattr(args, "add_google_calendar", False) is True:
         from taskcheck.google_calendar import add_google_calendar
 

{taskcheck-1.3.1 → taskcheck-1.4.1}/taskcheck/install.py

@@ -14,6 +14,9 @@ friday = [[9, 12.30], [14, 17]]
 [scheduler]
 days_ahead = 365
 weight_urgency = 1.0
+urgency_epsilon = 0.1
+max_top_urgency_rounds = 10
+n_undos = 1
 
 [report]
 include_unplanned = true

{taskcheck-1.3.1 → taskcheck-1.4.1}/taskcheck/parallel.py

@@ -4,6 +4,9 @@ import subprocess
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 
+from rich.table import Table
+
+from taskcheck.undo import create_undo_backup
 from taskcheck.common import (
     AVOID_STATUS,
     console,
@@ -27,6 +30,58 @@ class UrgencyCoefficients:
     urgency_age: float
 
 
+def advance_urgency_override(
+    tasks_overdue,
+    task_info,
+    urgency_overrides,
+    adjustment_states,
+    epsilon,
+    max_top_rounds,
+):
+    def effective_urgency(task_uuid):
+        return urgency_overrides.get(
+            task_uuid,
+            float(
+                task_info[task_uuid]["task"].get(
+                    "urgency", task_info[task_uuid]["urgency"]
+                )
+            ),
+        )
+
+    overdue_uuids = sorted(
+        (task["uuid"] for task in tasks_overdue),
+        key=effective_urgency,
+        reverse=True,
+    )
+    for task_uuid in overdue_uuids:
+        state = adjustment_states.setdefault(
+            task_uuid,
+            {"top_rounds": 0, "fallback_used": False, "exhausted": False},
+        )
+        if state["exhausted"]:
+            continue
+        if state["fallback_used"]:
+            state["exhausted"] = True
+            continue
+
+        current_urgency = effective_urgency(task_uuid)
+        greater_urgencies = [
+            effective_urgency(uuid)
+            for uuid in task_info
+            if uuid != task_uuid and effective_urgency(uuid) > current_urgency
+        ]
+        if greater_urgencies:
+            urgency_overrides[task_uuid] = min(greater_urgencies) + epsilon
+        elif state["top_rounds"] < max_top_rounds:
+            urgency_overrides[task_uuid] = current_urgency + epsilon
+            state["top_rounds"] += 1
+        else:
+            urgency_overrides[task_uuid] = 1000.0
+            state["fallback_used"] = True
+        return task_uuid
+    return None
+
+
 def get_urgency_coefficients(taskrc=None):
     """
     Retrieves urgency coefficients from Taskwarrior configurations.
@@ -110,21 +165,22 @@ def check_tasks_parallel(
     calendars = get_calendars(config, verbose=verbose, force_update=force_update)
     urgency_coefficients = get_urgency_coefficients(taskrc=taskrc)
 
-    current_weight = initial_weight_urgency
-    frozen_weights = {}
+    urgency_epsilon = float(config["scheduler"].get("urgency_epsilon", 0.1))
+    max_top_rounds = int(config["scheduler"].get("max_top_urgency_rounds", 10))
+    if urgency_epsilon <= 0:
+        raise ValueError("scheduler.urgency_epsilon must be greater than 0")
+    if max_top_rounds < 0:
+        raise ValueError("scheduler.max_top_urgency_rounds must be at least 0")
 
-    # Always re-initialize task_info inside the loop to avoid mutated state
+    urgency_overrides = {}
+    adjustment_states = {}
+    adjusted = False
     task_info_original = initialize_task_info(
         tasks, time_maps, days_ahead, urgency_coefficients, calendars
     )
     task_info = copy.deepcopy(task_info_original)
     tasks_overdue = []
-    while current_weight >= 0.0:
-        if verbose and auto_adjust_urgency and current_weight < initial_weight_urgency:
-            console.print(
-                f"[yellow]Retrying with urgency weight: {current_weight:.1f}[/yellow]"
-            )
-
+    while True:
         task_info = copy.deepcopy(task_info_original)
         for day_offset in range(days_ahead):
             allocate_time_for_day(
@@ -132,60 +188,86 @@ def check_tasks_parallel(
                 day_offset,
                 urgency_coefficients,
                 verbose,
-                current_weight,
-                frozen_weights,
+                initial_weight_urgency,
+                urgency_overrides,
             )
 
-        # Check if any tasks cannot be completed on time
         tasks_overdue = []
         for info in task_info.values():
             task = info["task"]
             due = task.get("due")
+            if due is None:
+                continue
 
-            if due is not None:
-                due_dt = datetime.strptime(due, "%Y%m%dT%H%M%SZ")
-
-                # Case 1: Task has no scheduling at all and has remaining hours
-                if not info["scheduling"] and info["remaining_hours"] > 0:
+            due_dt = datetime.strptime(due, "%Y%m%dT%H%M%SZ")
+            if not info["scheduling"] and info["remaining_hours"] > 0:
+                tasks_overdue.append(task)
+            elif info["scheduling"]:
+                end_date = max(info["scheduling"])
+                end_date_dt = datetime.strptime(end_date, "%Y-%m-%d")
+                if end_date_dt > due_dt:
                     tasks_overdue.append(task)
-                # Case 2: Task is scheduled but completion date is after due date
-                elif info["scheduling"]:
-                    scheduled_dates = sorted(info["scheduling"].keys())
-                    if scheduled_dates:
-                        end_date = scheduled_dates[-1]
-                        end_date_dt = datetime.strptime(end_date, "%Y-%m-%d")
-                        if end_date_dt > due_dt:
-                            tasks_overdue.append(task)
-
-        # If no tasks are overdue or auto-adjust is disabled, break the loop
+
         if not tasks_overdue or not auto_adjust_urgency:
             break
 
-        for task in tasks_overdue:
-            frozen_weights.setdefault(task["uuid"], current_weight)
-
         if verbose:
             console.print(
                 f"[red]{len(tasks_overdue)} task(s) cannot be completed on time[/red]"
             )
 
-        current_weight = round(current_weight - 0.1, 1)
-
-        if current_weight < 0.0:
+        adjusted_uuid = advance_urgency_override(
+            tasks_overdue,
+            task_info,
+            urgency_overrides,
+            adjustment_states,
+            urgency_epsilon,
+            max_top_rounds,
+        )
+        if adjusted_uuid is None:
             break
+        adjusted = True
+        if verbose:
+            console.print(
+                f"[yellow]Retrying task {task_info[adjusted_uuid]['task']['id']} "
+                f"with total urgency {urgency_overrides[adjusted_uuid]:.2f}[/yellow]"
+            )
 
-    # After loop completes, check if we still have overdue tasks
-    if auto_adjust_urgency and current_weight < initial_weight_urgency:
+    if adjusted:
+        changed_tasks = []
+        for uuid, override in urgency_overrides.items():
+            original = task_info_original[uuid]["urgency"]
+            if override != original:
+                changed_tasks.append((uuid, override - original, original, override))
         if tasks_overdue:
-            # We tried to adjust but still have overdue tasks
             console.print(
                 "[red]Warning: cannot find a solution after per-task urgency adjustment[/red]"
             )
         else:
-            # We successfully resolved overdue tasks by adjusting weight
             console.print(
-                f"[green]Resolved deadlines with per-task urgency adjustment[/green]"
+                "[green]Resolved deadlines with per-task urgency adjustment[/green]"
+            )
+        if changed_tasks:
+            console.print(
+                "[yellow]Scheduling priority was increased for these tasks. "
+                "Difference is final overridden urgency minus original urgency.[/yellow]"
             )
+            table = Table(header_style="bold yellow", style="yellow")
+            table.add_column("Task")
+            table.add_column("Original urgency", justify="right")
+            table.add_column("Overridden urgency", justify="right")
+            table.add_column("Difference", justify="right")
+            for uuid, delta, original, override in sorted(
+                changed_tasks, key=lambda item: item[1], reverse=True
+            ):
+                task = task_info_original[uuid]["task"]
+                table.add_row(
+                    f"#{task['id']} {task['description']}",
+                    f"{original:.2f}",
+                    f"{override:.2f}",
+                    f"+{delta:.2f}",
+                )
+            console.print(table)
 
     if dry_run:
         # Generate JSON output instead of updating tasks
@@ -232,7 +314,9 @@ def check_tasks_parallel(
 
         return scheduling_results
     else:
-        # Normal operation - update tasks in Taskwarrior
+        create_undo_backup(
+            task_info, config["scheduler"].get("n_undos", 1), taskrc
+        )
         update_tasks_with_scheduling_info(task_info, verbose, taskrc)
 
         return None
@@ -279,7 +363,7 @@ def allocate_time_for_day(
     urgency_coefficients,
     verbose,
     weight_urgency,
-    frozen_weights=None,
+    urgency_overrides=None,
 ):
     date = datetime.today().date() + timedelta(days=day_offset)
     total_available_hours = compute_total_available_hours(task_info, day_offset)
@@ -297,7 +381,7 @@ def allocate_time_for_day(
             urgency_coefficients,
             date,
             weight_urgency,
-            frozen_weights,
+            urgency_overrides,
         )
         sorted_task_ids = sorted(
             tasks_remaining.keys(),
@@ -435,10 +519,10 @@ def update_urgency(info, urgency_key, urgency_compute_fn, urgency_coefficients,
 
 
 def recompute_urgencies(
-    tasks_remaining, urgency_coefficients, date, weight_urgency, frozen_weights=None
+    tasks_remaining, urgency_coefficients, date, weight_urgency, urgency_overrides=None
 ):
     """Recompute urgency simulating that today is `date`."""
-    frozen_weights = frozen_weights or {}
+    urgency_overrides = urgency_overrides or {}
     # Recompute estimated urgencies as before
     for info in tasks_remaining.values():
         # Update estimated urgency
@@ -452,8 +536,7 @@ def recompute_urgencies(
 
         # Apply weights to create a combined score
         base_urgency = info["urgency"] - info["due_urgency"]
-        task_weight = frozen_weights.get(info["task"]["uuid"], weight_urgency)
-        base_urgency *= task_weight
+        base_urgency *= weight_urgency
         # Always add due_urgency, only weight estimated and age
         weighted_urgency = base_urgency + info["due_urgency"]
         info["urgency"] = weighted_urgency
@@ -497,6 +580,10 @@ def recompute_urgencies(
             max_urgency = get_max_urgency(info, visited)
             info["urgency"] = max_urgency  # Update the task's urgency
 
+    for task_uuid, urgency in urgency_overrides.items():
+        if task_uuid in tasks_remaining:
+            tasks_remaining[task_uuid]["urgency"] = urgency
+
 
 def allocate_time_to_task(info, day_offset, day_remaining_hours):
     if day_offset >= len(info["task_time_map"]):

{taskcheck-1.3.1 → taskcheck-1.4.1}/taskcheck/report.py

@@ -182,7 +182,7 @@ def get_tasks(config, tasks, year, month, day):
     regex = re.compile(rf"{year:04d}-{month:02d}-{day:02d} - ([PDTHM0-9]+)")
     valid_tasks = []
     for task in tasks:
-        for line in task["scheduling"].split("\n"):
+        for line in task.get("scheduling", "").split("\n"):
             m = regex.match(line)
             if m:
                 due = task.get("due", "")

taskcheck-1.4.1/taskcheck/undo.py

@@ -0,0 +1,84 @@
+import json
+import subprocess
+import time
+from pathlib import Path
+
+from taskcheck.common import get_task_env
+
+
+MANAGED_FIELDS = ("scheduled", "completion_date", "scheduling")
+
+
+def get_task_data_dir(taskrc=None):
+    result = subprocess.run(
+        ["task", "_get", "rc.data.location"],
+        capture_output=True,
+        text=True,
+        env=get_task_env(taskrc),
+        check=False,
+    )
+    location = result.stdout.strip()
+    if not location:
+        raise RuntimeError("Taskwarrior data location is not configured")
+    return Path(location).expanduser()
+
+
+def get_undo_dir(taskrc=None):
+    return get_task_data_dir(taskrc) / "taskcheck" / "undos"
+
+
+def create_undo_backup(task_info, n_undos, taskrc=None):
+    n_undos = int(n_undos)
+    if n_undos <= 0:
+        return None
+
+    tasks = []
+    for info in task_info.values():
+        if not info["scheduling"]:
+            continue
+        task = info["task"]
+        snapshot = {"uuid": task["uuid"]}
+        snapshot.update({field: task.get(field) for field in MANAGED_FIELDS})
+        tasks.append(snapshot)
+    if not tasks:
+        return None
+
+    undo_dir = get_undo_dir(taskrc)
+    undo_dir.mkdir(parents=True, exist_ok=True)
+    backup = undo_dir / f"undo-{time.time_ns()}.json"
+    temporary = backup.with_suffix(".tmp")
+    temporary.write_text(json.dumps({"tasks": tasks}, indent=2) + "\n")
+    temporary.replace(backup)
+
+    backups = sorted(undo_dir.glob("undo-*.json"))
+    for expired in backups[:-n_undos]:
+        expired.unlink()
+    return backup
+
+
+def restore_latest_backup(taskrc=None):
+    undo_dir = get_undo_dir(taskrc)
+    backups = sorted(undo_dir.glob("undo-*.json")) if undo_dir.exists() else []
+    if not backups:
+        print(
+            "No undo backup found. Set [scheduler] n_undos to at least 1 and run "
+            "taskcheck --schedule before using --undo."
+        )
+        return False
+
+    backup = backups[-1]
+    snapshot = json.loads(backup.read_text())
+    env = get_task_env(taskrc)
+    for task in snapshot["tasks"]:
+        fields = [f"{field}:{task.get(field) or ''}" for field in MANAGED_FIELDS]
+        subprocess.run(
+            ["task", task["uuid"], "modify", *fields],
+            capture_output=True,
+            text=True,
+            env=env,
+            check=True,
+        )
+
+    backup.unlink()
+    print(f"Restored {len(snapshot['tasks'])} task(s) from the latest backup.")
+    return True

{taskcheck-1.3.1 → taskcheck-1.4.1/taskcheck.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskcheck
-Version: 1.3.1
+Version: 1.4.1
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -33,6 +33,7 @@ Use it if you want to:
 - 🧭 Support complex working-hour maps
 - ⏱️ Consider urgency, due dates, and dependencies
 - 🧪 Dry-run mode to preview changes
+- ↩️ Undo the latest schedule update
 - 🧠 Auto-adjust urgency when deadlines cannot be met
 - 🔄 Force-refresh iCal calendars
 - 📊 Custom reports for planned and unplanned tasks
@@ -46,6 +47,7 @@ Use it if you want to:
 3. add `estimated` + `time_map` UDAs
 4. edit `~/.config/task/taskcheck.toml` (see [Reference](#Reference))
 5. `taskcheck --schedule`
+6. `taskcheck --undo` restores the scheduling fields changed by the latest run
 
 ## How it works
 
@@ -88,11 +90,10 @@ In short:
 - it installs required Taskwarrior settings if you confirm the first prompt
 - it installs optional urgency/report tuning if you confirm the second prompt
 - it can also create the default config file if you confirm the third prompt
-- it does **not** schedule tasks or fetch calendars
 - scheduling happens with `taskcheck --schedule`
 - all flags/config keys/settings are documented in `REFERENCE.md`
 
-## Algorithm
+## They say it's an AI
 
 The algorithm simulates a workday one chunk at a time.
 
@@ -104,7 +105,9 @@ For `today`, taskcheck skips past hours.
 
 The default work chunk is 2 hours (or less if the task is shorter); you can tune it with the Taskwarrior UDA `min_block`.
 
-If a task would finish after its `due_date`, taskcheck retries. It keeps that task's current non-due urgency weight, then lowers the weight by 0.1 only for tasks that have not missed a deadline. Due urgency is never reduced. Retries stop when deadlines are respected or unflagged tasks reach a weight of 0.
+Before writing a schedule, taskcheck backs up the affected tasks' `scheduled`, `completion_date`, and `scheduling` fields under the Taskwarrior data directory. `taskcheck --undo` restores and consumes the newest backup. The `[scheduler]` option `n_undos` controls retention and defaults to `1`; set it to `0` to disable backups.
+
+If a task would finish after its due date, taskcheck retries with a total-urgency override. Each retry moves the task immediately above the task with the smallest greater urgency by adding `urgency_epsilon` (default: `0.1`). At rank 1, it adds epsilon for up to `max_top_urgency_rounds` retries (default: `10`), then tries once at urgency `1000`. If the task is still late, taskcheck stops raising it and optimizes the other overdue tasks.
 
 ## Tips and Tricks
 

{taskcheck-1.3.1 → taskcheck-1.4.1}/taskcheck.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ taskcheck/ical.py
 taskcheck/install.py
 taskcheck/parallel.py
 taskcheck/report.py
+taskcheck/undo.py
 taskcheck.egg-info/PKG-INFO
 taskcheck.egg-info/SOURCES.txt
 taskcheck.egg-info/dependency_links.txt
@@ -20,4 +21,5 @@ tests/test_ical.py
 tests/test_install.py
 tests/test_main.py
 tests/test_parallel.py
-tests/test_report.py
+tests/test_report.py
+tests/test_undo.py

{taskcheck-1.3.1 → taskcheck-1.4.1}/tests/test_install.py

@@ -52,8 +52,9 @@ class TestIntegration:
     
     @patch('taskcheck.parallel.get_calendars')
     @patch('taskcheck.parallel.get_tasks') 
+    @patch('taskcheck.parallel.create_undo_backup')
     @patch('subprocess.run')
-    def test_full_scheduling_workflow(self, mock_run, mock_tasks, mock_calendars, sample_config, sample_tasks):
+    def test_full_scheduling_workflow(self, mock_run, mock_backup, mock_tasks, mock_calendars, sample_config, sample_tasks):
         """Test the complete scheduling workflow."""
         mock_tasks.return_value = sample_tasks
         mock_calendars.return_value = []

{taskcheck-1.3.1 → taskcheck-1.4.1}/tests/test_main.py

@@ -15,6 +15,7 @@ class TestArgumentParsing:
         assert args.install is False
         assert args.report is None
         assert args.schedule is False
+        assert args.undo is False
         assert args.force_update is False
         assert args.taskrc is None
         assert args.urgency_weight is None
@@ -30,6 +31,7 @@ class TestArgumentParsing:
                 "-r",
                 "today",
                 "-s",
+                "--undo",
                 "-f",
                 "--taskrc",
                 "/custom/path",
@@ -42,6 +44,7 @@ class TestArgumentParsing:
         assert args.install is True
         assert args.report == "today"
         assert args.schedule is True
+        assert args.undo is True
         assert args.force_update is True
         assert args.taskrc == "/custom/path"
         assert args.urgency_weight == 0.7
@@ -108,6 +111,11 @@ class TestArgumentParsing:
         assert capsys.readouterr().out == f"taskcheck {version('taskcheck')}\n"
 
 
+    def test_undo_argument(self):
+        args = arg_parser.parse_args(["--undo"])
+        assert args.undo is True
+
+
 class TestConfigLoading:
     @patch(
         "builtins.open",
@@ -175,6 +183,16 @@ class TestMainFunction:
 
                 mock_install.assert_called_once()
 
+    @patch("taskcheck.undo.restore_latest_backup")
+    def test_main_undo_returns_before_scheduling(self, mock_restore):
+        with patch(
+            "sys.argv",
+            ["taskcheck", "--undo", "--schedule", "--taskrc", "/custom/task"],
+        ):
+            main()
+
+        mock_restore.assert_called_once_with(taskrc="/custom/task")
+
     @patch("taskcheck.__main__.load_config")
     @patch("taskcheck.__main__.check_tasks_parallel")
     def test_main_schedule_command(

{taskcheck-1.3.1 → taskcheck-1.4.1}/tests/test_parallel.py

@@ -1,6 +1,8 @@
 from datetime import datetime, timedelta
 from unittest.mock import patch
 
+import pytest
+
 from taskcheck.parallel import (
     get_urgency_coefficients,
     check_tasks_parallel,
@@ -10,10 +12,17 @@ from taskcheck.parallel import (
     urgency_age,
     urgency_estimated,
     recompute_urgencies,
+    advance_urgency_override,
     UrgencyCoefficients,
 )
 
 
+@pytest.fixture(autouse=True)
+def mock_undo_backup():
+    with patch("taskcheck.parallel.create_undo_backup") as mock_backup:
+        yield mock_backup
+
+
 class TestUrgencyCoefficients:
     def test_get_urgency_coefficients(self, mock_task_export_with_taskrc, test_taskrc):
         coeffs = get_urgency_coefficients(taskrc=test_taskrc)
@@ -287,10 +296,10 @@ class TestWeightConfiguration:
         recompute_urgencies(tasks_remaining, coeffs, date, 0.7)
         assert tasks_remaining["task-1"]["urgency"] >= tasks_remaining["task-1"]["due_urgency"]
 
-    def test_recompute_urgencies_uses_frozen_weight_per_task(self):
+    def test_recompute_urgencies_applies_total_urgency_override(self):
         tasks_remaining = {
-            uuid: {
-                "task": {"uuid": uuid, "id": index, "entry": "20240101T000000Z"},
+            "overridden": {
+                "task": {"uuid": "overridden", "id": 1, "entry": "20240101T000000Z"},
                 "urgency": 10.0,
                 "estimated_urgency": 5.0,
                 "due_urgency": 0.0,
@@ -298,7 +307,6 @@ class TestWeightConfiguration:
                 "remaining_hours": 2.0,
                 "started": False,
             }
-            for index, uuid in enumerate(("frozen", "unfrozen"), start=1)
         }
         coeffs = UrgencyCoefficients({"P2H": 5.0}, False, 0, 365, 0, 0)
 
@@ -307,11 +315,10 @@ class TestWeightConfiguration:
             coeffs,
             datetime(2024, 1, 1).date(),
             0.2,
-            frozen_weights={"frozen": 0.7},
+            urgency_overrides={"overridden": 42.1},
         )
 
-        assert tasks_remaining["frozen"]["urgency"] == 7.0
-        assert tasks_remaining["unfrozen"]["urgency"] == 2.0
+        assert tasks_remaining["overridden"]["urgency"] == 42.1
 
     def test_recompute_urgencies_inherit_and_cycle(self):
         tasks_remaining = {
@@ -328,8 +335,10 @@ class TestMainSchedulingFunction:
     @patch("taskcheck.parallel.get_tasks")
     @patch("taskcheck.parallel.get_urgency_coefficients")
     @patch("taskcheck.parallel.update_tasks_with_scheduling_info")
+    @patch("taskcheck.parallel.create_undo_backup")
     def test_check_tasks_parallel(
         self,
+        mock_backup,
         mock_update,
         mock_coeffs,
         mock_tasks,
@@ -343,16 +352,76 @@ class TestMainSchedulingFunction:
             {"P1H": 5.0, "P2H": 8.0, "P3H": 10.0}, False, 4.0, 365, 12, 2
         )
         mock_calendars.return_value = []
+        writes = []
+        mock_backup.side_effect = lambda *args: writes.append("backup")
+        mock_update.side_effect = lambda *args: writes.append("update")
 
         check_tasks_parallel(sample_config, verbose=True, taskrc=test_taskrc)
 
         mock_tasks.assert_called_once_with(taskrc=test_taskrc)
         mock_coeffs.assert_called_once_with(taskrc=test_taskrc)
         mock_calendars.assert_called_once()
+        mock_backup.assert_called_once()
+        assert mock_backup.call_args.args[1:] == (1, test_taskrc)
         mock_update.assert_called_once()
+        assert writes == ["backup", "update"]
 
 
 class TestAutoAdjustUrgency:
+    def test_urgency_override_moves_up_one_rank_then_uses_bounded_top_rounds(self):
+        task_info = {
+            "t1": {"task": {"uuid": "t1"}, "urgency": 1.0},
+            "t2": {"task": {"uuid": "t2"}, "urgency": 2.0},
+            "t3": {"task": {"uuid": "t3"}, "urgency": 3.0},
+        }
+        overdue = [task_info["t1"]["task"]]
+        overrides = {}
+        states = {}
+        values = []
+
+        for _ in range(5):
+            adjusted_uuid = advance_urgency_override(
+                overdue, task_info, overrides, states, epsilon=0.1, max_top_rounds=2
+            )
+            values.append(overrides["t1"])
+            task_info["t1"]["urgency"] = overrides["t1"]
+
+        assert adjusted_uuid == "t1"
+        assert values == pytest.approx([2.1, 3.1, 3.2, 3.3, 1000.0])
+        assert (
+            advance_urgency_override(
+                overdue, task_info, overrides, states, epsilon=0.1, max_top_rounds=2
+            )
+            is None
+        )
+
+    def test_exhausted_task_does_not_block_other_overdue_tasks(self):
+        task_info = {
+            "t1": {"task": {"uuid": "t1"}, "urgency": 1000.0},
+            "t2": {"task": {"uuid": "t2"}, "urgency": 1.0},
+            "t3": {"task": {"uuid": "t3"}, "urgency": 2.0},
+        }
+        overrides = {"t1": 1000.0}
+        states = {}
+        overdue = [task_info["t1"]["task"], task_info["t2"]["task"]]
+
+        for _ in range(3):
+            advance_urgency_override(
+                [task_info["t1"]["task"]],
+                task_info,
+                overrides,
+                states,
+                epsilon=0.1,
+                max_top_rounds=1,
+            )
+
+        adjusted_uuid = advance_urgency_override(
+            overdue, task_info, overrides, states, epsilon=0.1, max_top_rounds=1
+        )
+
+        assert adjusted_uuid == "t2"
+        assert overrides["t2"] == 2.1
+
     @patch("taskcheck.parallel.get_calendars")
     @patch("taskcheck.parallel.get_tasks")
     @patch("taskcheck.parallel.get_urgency_coefficients")
@@ -366,7 +435,7 @@ class TestAutoAdjustUrgency:
         sample_config,
         test_taskrc,
     ):
-        """Test that auto-adjust reduces urgency weight when tasks are overdue."""
+        """Test that auto-adjust retries when tasks are overdue."""
         # Create tasks with tight deadlines that will cause conflicts
         overdue_tasks = [
             {
@@ -437,7 +506,7 @@ class TestAutoAdjustUrgency:
     @patch("taskcheck.parallel.get_urgency_coefficients")
     @patch("taskcheck.parallel.get_long_range_time_map")
     @patch("taskcheck.parallel.update_tasks_with_scheduling_info")
-    def test_auto_adjust_urgency_weight_reduction(
+    def test_auto_adjust_urgency_stops_after_fallback(
         self,
         mock_update,
         mock_long_range,
@@ -447,7 +516,7 @@ class TestAutoAdjustUrgency:
         sample_config,
         test_taskrc,
     ):
-        """Test that auto_adjust_urgency reduces the urgency weight and stops at 0.0."""
+        """Test that auto-adjust stops after bounded rank-1 and fallback retries."""
         # Use relative dates based on current date
         from datetime import datetime, timedelta
 
@@ -476,10 +545,9 @@ class TestAutoAdjustUrgency:
             {"P24H": 10.0}, False, 4.0, 365, 12, 2
         )
         mock_calendars.return_value = []
-        # Mock no available time at all to make it truly impossible
         mock_long_range.return_value = ([0.0] * 365, 0.0)
+        sample_config["scheduler"]["max_top_urgency_rounds"] = 2
 
-        # Patch the console.print to capture output
         with patch("taskcheck.parallel.console.print") as mock_console_print:
             check_tasks_parallel(
                 sample_config,
@@ -488,25 +556,21 @@ class TestAutoAdjustUrgency:
                 auto_adjust_urgency=True,
             )
 
-            # Should print a warning about not finding a solution
-            # Print all captured calls for debugging if the assertion fails
-            found_warning = any(
-                "cannot find a solution"
-                in " ".join(str(arg).lower() for arg in call.args)
+            messages = [
+                " ".join(str(arg).lower() for arg in call.args)
                 for call in mock_console_print.call_args_list
-            )
-            if not found_warning:
-                print("Captured console.print calls for debug:")
-                for call in mock_console_print.call_args_list:
-                    print(str(call))
-            assert found_warning
+            ]
+            retries = [message for message in messages if "retrying task" in message]
+            assert len(retries) == 3
+            assert "1000.00" in retries[-1]
+            assert any("cannot find a solution" in message for message in messages)
 
     @patch("taskcheck.parallel.get_calendars")
     @patch("taskcheck.parallel.get_tasks")
     @patch("taskcheck.parallel.get_urgency_coefficients")
     @patch("taskcheck.parallel.get_long_range_time_map")
     @patch("taskcheck.parallel.update_tasks_with_scheduling_info")
-    def test_auto_adjust_urgency_final_weight_message(
+    def test_auto_adjust_urgency_final_message(
         self,
         mock_update,
         mock_long_range,
@@ -528,8 +592,28 @@ class TestAutoAdjustUrgency:
         mock_long_range.return_value = ([4.0] * 7, 0.0)
         with patch("taskcheck.parallel.console.print") as mock_console_print:
             check_tasks_parallel(sample_config, verbose=True, taskrc=test_taskrc, auto_adjust_urgency=True)
-            messages = [" ".join(str(arg).lower() for arg in call.args) for call in mock_console_print.call_args_list]
-            assert any("per-task urgency adjustment" in msg for msg in messages)
+            calls = mock_console_print.call_args_list
+            messages = [" ".join(str(arg).lower() for arg in call.args) for call in calls]
+            warning_index = next(
+                index
+                for index, message in enumerate(messages)
+                if "per-task urgency adjustment" in message
+            )
+            intro_index = next(
+                index
+                for index, message in enumerate(messages)
+                if "difference is final overridden urgency" in message
+            )
+            table = calls[intro_index + 1].args[0]
+            assert warning_index < intro_index
+            assert [column.header for column in table.columns] == [
+                "Task",
+                "Original urgency",
+                "Overridden urgency",
+                "Difference",
+            ]
+            differences = [float(value) for value in table.columns[-1]._cells]
+            assert differences == sorted(differences, reverse=True)
 
     @patch("taskcheck.parallel.get_calendars")
     @patch("taskcheck.parallel.get_tasks")
@@ -543,6 +627,7 @@ class TestAutoAdjustUrgency:
         mock_calendars,
         sample_config,
         test_taskrc,
+        mock_undo_backup,
     ):
         now = datetime.now()
         due = (now + timedelta(days=1)).strftime("%Y%m%dT%H%M%SZ")
@@ -555,6 +640,7 @@ class TestAutoAdjustUrgency:
         assert isinstance(result, list)
         assert result
         assert any("warning" in " ".join(str(a).lower() for a in call.args) for call in mock_print.call_args_list)
+        mock_undo_backup.assert_not_called()
 
     def test_update_tasks_with_scheduling_info_warns_when_late(self):
         task_info = {

{taskcheck-1.3.1 → taskcheck-1.4.1}/tests/test_report.py

@@ -89,6 +89,17 @@ class TestTaskFiltering:
         
         assert len(result) == 2
         assert result[0]["urgency"] >= result[1]["urgency"]  # Sorted by urgency
+
+    def test_get_tasks_ignores_tasks_without_scheduling(self, sample_config):
+        result = get_tasks(
+            sample_config["report"],
+            [{"id": 1, "description": "Unplanned task", "urgency": 10.0}],
+            2023,
+            12,
+            5,
+        )
+
+        assert result == []
         
     @patch('subprocess.run')
     def test_get_unplanned_tasks(self, mock_run, sample_config, test_taskrc):

taskcheck-1.4.1/tests/test_undo.py

@@ -0,0 +1,130 @@
+import json
+import subprocess
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+
+from taskcheck.undo import create_undo_backup, restore_latest_backup
+
+
+def task_info(scheduled=None, completion_date=None, scheduling=None):
+    task = {"uuid": "task-uuid", "id": 1}
+    if scheduled is not None:
+        task["scheduled"] = scheduled
+    if completion_date is not None:
+        task["completion_date"] = completion_date
+    if scheduling is not None:
+        task["scheduling"] = scheduling
+    return {"task-uuid": {"task": task, "scheduling": {"2025-01-02": 2.0}}}
+
+
+def test_create_backup_saves_managed_fields_and_keeps_only_latest(tmp_path):
+    with patch("taskcheck.undo.get_task_data_dir", return_value=tmp_path):
+        first = create_undo_backup(
+            task_info("20250101T000000Z", "20250102T000000Z", "old"), 1
+        )
+        second = create_undo_backup(task_info(), 1)
+
+    backups = list((tmp_path / "taskcheck" / "undos").glob("*.json"))
+    assert backups == [second]
+    assert not first.exists()
+    assert json.loads(second.read_text())["tasks"] == [
+        {
+            "uuid": "task-uuid",
+            "scheduled": None,
+            "completion_date": None,
+            "scheduling": None,
+        }
+    ]
+
+
+def test_create_backup_skips_tasks_without_scheduling_and_disabled_retention(tmp_path):
+    info = task_info()
+    info["task-uuid"]["scheduling"] = {}
+
+    with patch("taskcheck.undo.get_task_data_dir", return_value=tmp_path):
+        assert create_undo_backup(info, 1) is None
+        assert create_undo_backup(task_info(), 0) is None
+
+    assert not (tmp_path / "taskcheck" / "undos").exists()
+
+
+def test_restore_latest_backup_restores_fields_and_consumes_file(tmp_path):
+    backup_dir = tmp_path / "taskcheck" / "undos"
+    backup_dir.mkdir(parents=True)
+    older = backup_dir / "undo-1000000000000000000.json"
+    older.write_text(json.dumps({"tasks": [{"uuid": "older-task"}]}))
+    backup = backup_dir / "undo-2000000000000000000.json"
+    backup.write_text(
+        json.dumps(
+            {
+                "tasks": [
+                    {
+                        "uuid": "task-uuid",
+                        "scheduled": "20250101T000000Z",
+                        "completion_date": None,
+                        "scheduling": "old schedule",
+                    }
+                ]
+            }
+        )
+    )
+
+    with patch("taskcheck.undo.get_task_data_dir", return_value=tmp_path), patch(
+        "taskcheck.undo.subprocess.run"
+    ) as mock_run:
+        assert restore_latest_backup(taskrc="/custom/task") is True
+
+    command = mock_run.call_args.args[0]
+    kwargs = mock_run.call_args.kwargs
+    assert command == [
+        "task",
+        "task-uuid",
+        "modify",
+        "scheduled:20250101T000000Z",
+        "completion_date:",
+        "scheduling:old schedule",
+    ]
+    assert kwargs["env"]["TASKRC"] == "/custom/task"
+    assert kwargs["env"]["TASKDATA"] == "/custom/task"
+    assert kwargs["check"] is True
+    assert not backup.exists()
+    assert older.exists()
+
+
+def test_restore_without_backup_tells_user_to_enable_n_undos(tmp_path, capsys):
+    with patch("taskcheck.undo.get_task_data_dir", return_value=tmp_path):
+        assert restore_latest_backup() is False
+
+    assert "n_undos" in capsys.readouterr().out
+
+
+def test_failed_restore_keeps_backup(tmp_path):
+    backup_dir = tmp_path / "taskcheck" / "undos"
+    backup_dir.mkdir(parents=True)
+    backup = backup_dir / "undo-1.json"
+    backup.write_text(json.dumps({"tasks": [{"uuid": "task-uuid"}]}))
+
+    with patch("taskcheck.undo.get_task_data_dir", return_value=tmp_path), patch(
+        "taskcheck.undo.subprocess.run",
+        side_effect=subprocess.CalledProcessError(1, ["task"]),
+    ), pytest.raises(subprocess.CalledProcessError):
+        restore_latest_backup()
+
+    assert backup.exists()
+
+
+def test_get_task_data_dir_uses_taskwarrior_configuration():
+    result = Mock(stdout="/data/tasks\n")
+    with patch("taskcheck.undo.subprocess.run", return_value=result) as mock_run:
+        from taskcheck.undo import get_task_data_dir
+
+        assert get_task_data_dir("/custom/task") == Path("/data/tasks")
+
+    command = mock_run.call_args.args[0]
+    kwargs = mock_run.call_args.kwargs
+    assert command == ["task", "_get", "rc.data.location"]
+    assert kwargs["env"]["TASKRC"] == "/custom/task"
+    assert kwargs["env"]["TASKDATA"] == "/custom/task"
+    assert kwargs["check"] is False