fix(lik-ui): re-base a schedule's next run when its cadence changes

Editing a scheduled run's cadence left next_run_at untouched, so shortening
it (e.g. weekly -> daily) still waited out the old interval. The next due
time is now recomputed from the last completed run, and lands in the past —
i.e. due now — when the new cadence has already elapsed.

The due time is still left alone when the cadence is unchanged, when the row
has never completed a run (already due), and while a run is in flight, where
complete_run recomputes from the new cadence.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: yoomlam

lik-ui/src/lik_ui/db.py

@@ -429,21 +429,40 @@ def update_scheduled_run(
     ) -> bool:
         """Edit an existing schedule in place (owner-scoped). Writes only the user-editable fields
         plus the derived ``max_runtime_s`` (re-materialized from the possibly-changed agent's roster
-        value, same source as ``create_scheduled_run``). Deliberately leaves ``next_run_at``,
-        ``paused``, ``started_at``, and every ``last_*`` column untouched: editing the message or
-        agent must not change *when* the schedule next fires, and a cadence change takes full effect
-        after the next completion (``complete_run`` recomputes ``next_run_at`` from ``run_interval``).
-        Leaving ``started_at`` alone preserves the scanner's double-run invariant. Returns whether a
-        row matched (False when the row isn't the caller's or doesn't exist)."""
+        value, same source as ``create_scheduled_run``).
+
+        Changing the cadence re-bases the next due time on the last completed run
+        (``completed_at + <new interval>``), so a shortened cadence takes effect right away instead
+        of waiting out the old one; if that lands in the past the row simply becomes due now. The
+        next due time is left alone when the cadence is unchanged (editing the message or agent must
+        not change *when* the schedule next fires), when the row has never completed a run (it is
+        already due immediately), and while a run is in flight (``completed_at`` is NULL then, and
+        ``complete_run`` will recompute from the new cadence).
+
+        ``paused``, ``started_at``, and every ``last_*`` column are untouched; leaving ``started_at``
+        alone preserves the scanner's double-run invariant. Returns whether a row matched (False when
+        the row isn't the caller's or doesn't exist)."""
         with self.db.connection() as conn:
             row = conn.execute(
                 """
                 UPDATE scheduled_runs
-                SET agent_name = %s, prompt = %s, run_interval = %s, max_runtime_s = %s
-                WHERE id = %s AND user_id = %s
+                SET agent_name = %(agent_name)s, prompt = %(prompt)s,
+                    run_interval = %(run_interval)s, max_runtime_s = %(max_runtime_s)s,
+                    next_run_at = CASE
+                        WHEN %(run_interval)s IS DISTINCT FROM run_interval AND completed_at IS NOT NULL
+                        THEN completed_at + %(run_interval)s
+                        ELSE next_run_at END
+                WHERE id = %(run_id)s AND user_id = %(user_id)s
                 RETURNING id
                 """,
-                (agent_name, prompt, run_interval, max_runtime_s, run_id, user_id),
+                {
+                    "agent_name": agent_name,
+                    "prompt": prompt,
+                    "run_interval": run_interval,
+                    "max_runtime_s": max_runtime_s,
+                    "run_id": run_id,
+                    "user_id": user_id,
+                },
             ).fetchone()
             conn.commit()
             return row is not None

lik-ui/tests/test_db.py

@@ -213,13 +213,47 @@ def test_update_scheduled_run_preserves_schedule_state(store):
     before = store.list_scheduled_runs(a["id"])[0]
     store.update_scheduled_run(run["id"], a["id"], "agent", "edited", timedelta(days=3), max_runtime_s=1800)
     after = store.list_scheduled_runs(a["id"])[0]
-    # Editing must not touch when the schedule next fires or its run/pause state.
+    # A schedule that has never completed a run is already due now, so even a cadence change
+    # leaves the due time alone — as does the run/pause state.
     assert after["next_run_at"] == before["next_run_at"]
     assert after["paused"] == before["paused"]
     assert after["started_at"] == before["started_at"]
     assert after["last_status"] == before["last_status"]
 
 
+def test_update_scheduled_run_rebases_next_run_on_cadence_change(store):
+    a = store.upsert_user("a@navapbc.com")
+    run = store.create_scheduled_run(a["id"], "agent", "go", timedelta(days=7))
+    completed = datetime.now(timezone.utc) - timedelta(days=1)
+    _set_run(store.db, run["id"], completed_at=completed, next_run_at=completed + timedelta(days=7))
+    # Shortening the cadence must take effect from the last run, not wait out the old one.
+    store.update_scheduled_run(run["id"], a["id"], "agent", "go", timedelta(days=2), max_runtime_s=1800)
+    assert store.list_scheduled_runs(a["id"])[0]["next_run_at"] == completed + timedelta(days=2)
+
+
+def test_update_scheduled_run_keeps_next_run_when_cadence_unchanged(store):
+    a = store.upsert_user("a@navapbc.com")
+    run = store.create_scheduled_run(a["id"], "agent", "go", timedelta(days=7))
+    completed = datetime.now(timezone.utc) - timedelta(days=1)
+    due = completed + timedelta(days=3)  # deliberately not completed_at + run_interval
+    _set_run(store.db, run["id"], completed_at=completed, next_run_at=due)
+    # Editing only the message/agent must not move the due time.
+    store.update_scheduled_run(run["id"], a["id"], "other", "edited", timedelta(days=7), max_runtime_s=1800)
+    assert store.list_scheduled_runs(a["id"])[0]["next_run_at"] == due
+
+
+def test_update_scheduled_run_leaves_in_flight_row_due_time(store):
+    a = store.upsert_user("a@navapbc.com")
+    run = store.create_scheduled_run(a["id"], "agent", "go", timedelta(days=7))
+    store.claim_due_runs()  # in flight: started_at set, completed_at cleared
+    before = store.list_scheduled_runs(a["id"])[0]
+    store.update_scheduled_run(run["id"], a["id"], "agent", "go", timedelta(days=2), max_runtime_s=1800)
+    after = store.list_scheduled_runs(a["id"])[0]
+    # complete_run recomputes from the new cadence, so the edit leaves the due time alone.
+    assert after["next_run_at"] == before["next_run_at"]
+    assert after["started_at"] == before["started_at"]
+
+
 def test_update_scheduled_run_is_owner_scoped(store):
     a = store.upsert_user("a@navapbc.com")
     b = store.upsert_user("b@navapbc.com")