From 33567db5a391bcfebd328e7f6191b1da1394032c Mon Sep 17 00:00:00 2001
From: Acrux Development <acruxstudios.dev@gmail.com>
Date: Wed, 28 Oct 2026 13:11:54 -0300
Subject: [PATCH] Better account-based wait status

---
 README.md                              |  29 +++++----
 include/Database.h                     |   2 +
 include/Models.h                       |   1 +
 include/Tracker.h                      |   3 +-
 include/Views.h                        |   3 +
 include/lls_api.h                      |   7 +-
 python/__pycache__/lls.cpython-312.pyc | Bin 26287 -> 26436 bytes
 python/lls.py                          |   3 +
 python/test_lls.py                     |  87 ++++++++++++++++++++++++-
 src/Database.cpp                       |  26 +++++++-
 src/Repl.cpp                           |   2 +-
 src/Tracker.cpp                        |  73 +++++++++++----------
 src/Views.cpp                          |   3 +-
 src/capi.cpp                           |   1 +
 14 files changed, 183 insertions(+), 57 deletions(-)

diff --git a/README.md b/README.md
index 4dd563e..0df3604 100644
--- a/README.md
+++ b/README.md
@@ -91,17 +91,22 @@ goes back to `$VISUAL` / `$EDITOR` / nano / vim / vi. The choice is stored in
 * Waits belong to the account: `acc wait <name> <time>` (or `tsk restat <task> wait
   <time>`, which sets its account's wait). Until the time the account's Prompt
   and Testing tasks show `Wait HH:MM`; after it they show `Limit reset`, until
-  you run `acc unwait <name>`, which also clears a stale one. Uploading, Frozen
-  and Done tasks are not affected, and the tasks keep their own stored status
-  underneath. A wait that no task shows (no tasks, or only Done / Frozen /
-  Uploading ones) is listed in the account row as `(wait HH:MM)` or
-  `(limit reset)` and keeps the account Busy. Tasks without an account keep
-  their own wait.
+  you run `acc unwait <name>`. Uploading, Frozen and Done tasks are not
+  affected, and the tasks keep their own stored status underneath. A wait that
+  no task shows (no tasks, or only Done / Frozen / Uploading ones) is listed in
+  the account row as `(wait)` or `(limit reset)` and keeps the account Busy.
+  Tasks without an account keep their own wait.
+* A task you set explicitly to `testing` or `prompt` (`tsk restat <task>
+  testing`, `tsk add <task> <acc> testing`) shows that status, even while its
+  account is waiting: that task ignores the wait, and the account's other tasks
+  keep following it. `tsk restat <task> wait` (no time) makes it follow the
+  wait again, and a new `acc wait` or `acc unwait` applies to every task again.
+  Adding a task without a status leaves it following the account.
 * Auto unwait: once an account's limit has reset (its tasks show `Limit reset`),
-  explicitly setting a task on it to `testing` or `prompt` (`tsk add <task> <acc>
-  testing`, `tsk restat <task> testing`) clears that finished wait, because the
-  account is in use again. Adding a task without a status does not, and a wait
-  that is still running is never cleared automatically (use `acc unwait`).
+  setting a task on it explicitly to `testing` or `prompt` clears that finished
+  wait, because the account is in use again, and its tasks go back to their own
+  status. A wait that is still running is never cleared automatically (use
+  `acc unwait`).
 * A time is only optional while the account is already waiting: then
   `tsk restat <task> wait` (or `tsk add <task> <acc> wait`) just makes the task
   follow that wait. Otherwise (no account, or its wait is over) a time is
@@ -143,7 +148,9 @@ against it behaves exactly like typing the commands. Build it with the project
 * After a change, `lls_last_messages(db)` holds what the prompt would have
   printed ("Account 'A' is back in use: ..."). Queries do not reset it.
 * Statuses are the text you would type: `"prompt"`, `"testing"`, `"wait 4:30pm"`,
-  `"wait"` (only while the account is waiting)... Waits belong to the account.
+  `"wait"` (only while the account is waiting)... Waits belong to the account;
+  a task set to `"testing"` / `"prompt"` while it waits ignores the wait
+  (`overrides_wait` is 1) and `"wait"` makes it follow the account again.
 * `lls_tasks` / `lls_accounts` return lists in the order of the panels, with the
   computed status (`status`, `status_label`, `until`) and the stored one underneath
   (`stored_status`). Strings in a list are valid until `lls_task_list_free`.
diff --git a/include/Database.h b/include/Database.h
index 69b858d..ca444b5 100644
--- a/include/Database.h
+++ b/include/Database.h
@@ -46,6 +46,8 @@ public:
     void setTaskAccount(const std::string& name, const std::optional<std::string>& account);
     void setTaskStatus(const std::string& name, const std::string& status);
     void setTaskNotes(const std::string& name, const std::string& notes);
+    void setTaskWaitOverride(const std::string& name, bool value);
+    void clearWaitOverrides(const std::string& account);  // every task of the account follows its wait again
 
 private:
     using Param = std::optional<std::string>;
diff --git a/include/Models.h b/include/Models.h
index 0c1245d..067717d 100644
--- a/include/Models.h
+++ b/include/Models.h
@@ -8,6 +8,7 @@ struct TaskRow {
     std::optional<std::string> account;
     std::string status;  // serialized, see StatusUtil::serialize
     std::string notes;   // free text, any length (stored as SQLite TEXT)
+    bool waitOverride = false;  // set to Testing / Prompt while its account waits: ignores that wait
 };
 
 struct AccountRow {
diff --git a/include/Tracker.h b/include/Tracker.h
index af97b0a..47c713b 100644
--- a/include/Tracker.h
+++ b/include/Tracker.h
@@ -72,9 +72,8 @@ private:
     std::string existingAccount(const std::string& name) const;
     TaskRow existingTask(const std::string& name) const;
     std::optional<std::time_t> runningWait(const std::string& account) const;
-    void resumeAccount(const std::string& account);
+    void taskInUse(const std::string& taskName, const std::string& accountName);
     void makeTaskFollowAccount(const TaskRow& task);
-    void noteAccountWait(const std::string& taskName);
     void note(const std::string& message);
 
     Database& db_;
diff --git a/include/Views.h b/include/Views.h
index a040014..1e36315 100644
--- a/include/Views.h
+++ b/include/Views.h
@@ -28,6 +28,9 @@ struct TaskInfo {
     Status storedStatus;  // what is saved underneath
     std::string notes;
     std::size_t noteLines = 0;
+    // Set to Testing / Prompt while its account waits: it shows its own status
+    // and ignores the wait, while the account's other tasks keep following it.
+    bool overridesWait = false;
 };
 
 struct AccountInfo {
diff --git a/include/lls_api.h b/include/lls_api.h
index a7e9656..39f8cc5 100644
--- a/include/lls_api.h
+++ b/include/lls_api.h
@@ -16,7 +16,11 @@
  *     or just "wait" (only while the task's account is already waiting).
  *   - A wait belongs to the account: setting a task to "wait <time>" sets its
  *     account's wait, and the account's Prompt / Testing tasks then show Wait
- *     until that time and Limit reset after it (see the README).
+ *     until that time and Limit reset after it. A task you explicitly set to
+ *     "testing" or "prompt" while the wait is running shows that status instead
+ *     (overrides_wait = 1) and the other tasks keep waiting; "wait" makes it follow
+ *     the account again. If the wait is already over (Limit reset), setting a task
+ *     to testing / prompt clears it: the account is in use again (see the README).
  *   - Times are Unix seconds (UTC); clock-time text like "4:30pm" is read in the
  *     local time zone, and a time that has passed today means tomorrow.
  *
@@ -88,6 +92,7 @@ typedef struct lls_task_info {
     int64_t until;             /* for Wait / Limit reset: when the wait ends (ended); else 0 */
     const char* notes;         /* the full text, "" if none (any length) */
     int notes_lines;           /* number of lines in the notes */
+    int overrides_wait;        /* 1 if its account waits but this task ignores it (set to Testing / Prompt) */
 } lls_task_info;
 
 /* An account with its computed state. */
diff --git a/python/__pycache__/lls.cpython-312.pyc b/python/__pycache__/lls.cpython-312.pyc
index 70b73c9735025f324e9185d49cadc99bd2cbf70b..df97e2c22456b6c78ca905c40278f9a919e6e5b5 100644
GIT binary patch
delta 2734
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
ao008{%;I^ejDl56jINBI7{C;`5eER34BZX@

delta 2661
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

diff --git a/python/lls.py b/python/lls.py
index b7f6b54..776999a 100644
--- a/python/lls.py
+++ b/python/lls.py
@@ -98,6 +98,7 @@ class Task:
     until: Optional[datetime]    # for Wait / Limit reset: when the wait ends (ended)
     notes: str
     notes_lines: int
+    overrides_wait: bool         # its account waits, but this task (set to Testing / Prompt) ignores it
 
 
 @dataclass(frozen=True)
@@ -123,6 +124,7 @@ class _TaskInfo(ctypes.Structure):
         ("until", ctypes.c_int64),
         ("notes", ctypes.c_char_p),
         ("notes_lines", ctypes.c_int),
+        ("overrides_wait", ctypes.c_int),
     ]
 
 
@@ -400,6 +402,7 @@ class Database:
                     until=_when(info.until),
                     notes=_dec(info.notes),
                     notes_lines=info.notes_lines,
+                    overrides_wait=bool(info.overrides_wait),
                 ))
             return result
         finally:
diff --git a/python/test_lls.py b/python/test_lls.py
index 69afcc9..3e49554 100644
--- a/python/test_lls.py
+++ b/python/test_lls.py
@@ -215,11 +215,92 @@ class WaitTests(Base):
         self.assertEqual(self.db.task("a-prompt").status, lls.Status.PROMPT)
         self.assertTrue(any("back in use" in m for m in self.db.messages))
 
-    def test_a_running_wait_is_never_cleared_automatically(self):
+    def test_explicit_testing_or_prompt_shows_that_status_while_waiting(self):
+        self.db.set_account_wait("A", "6pm")
+        self.db.set_task_status("a-testing", "testing")        # explicit
+        task = self.db.task("a-testing")
+        self.assertEqual((task.status, task.status_label, task.overrides_wait), (lls.Status.TESTING, "Testing", True))
+        self.assertTrue(any("ignores it" in m for m in self.db.messages))
+
+        self.db.set_task_status("a-prompt", "prompt")
+        self.assertEqual(self.db.task("a-prompt").status_label, "Prompt")
+        self.db.add_task("n1", "A", "testing")
+        self.assertEqual(self.db.task("n1").status, lls.Status.TESTING)
+        self.db.add_task("n2", "A")                             # no status given: follows the wait
+        self.assertEqual(self.db.task("n2").status, lls.Status.WAIT)
+        self.assertFalse(self.db.task("n2").overrides_wait)
+
+        # the account itself is still waiting, nothing was cleared
+        self.assertEqual(self.db.account("A").wait_state, lls.WaitState.WAITING)
+
+    def test_other_tasks_keep_waiting_and_wait_makes_a_task_follow_again(self):
+        self.db.set_account_wait("A", "6pm")
+        self.db.add_task("a-other", "A")
+        self.db.set_task_status("a-testing", "testing")
+        self.assertEqual(self.db.task("a-other").status, lls.Status.WAIT)
+        self.assertEqual(self.db.task("a-prompt").status, lls.Status.WAIT)
+
+        self.db.set_task_status("a-testing", "wait")            # no time: follow the running wait again
+        task = self.db.task("a-testing")
+        self.assertEqual((task.status, task.overrides_wait), (lls.Status.WAIT, False))
+        self.assertIn("now follows account 'A'", self.db.messages[0])
+
+    def test_a_new_wait_applies_to_every_task_again(self):
         self.db.set_account_wait("A", "6pm")
         self.db.set_task_status("a-testing", "testing")
-        self.assertEqual(self.db.account("A").wait_state, lls.WaitState.WAITING)
-        self.assertEqual(self.db.task("a-testing").status, lls.Status.WAIT)
+        self.db.set_account_wait("A", "7pm")                    # the account hit its limit again
+        task = self.db.task("a-testing")
+        self.assertEqual((task.status_label, task.overrides_wait), ("Wait 19:00", False))
+
+    def test_unwait_clears_the_overrides_too(self):
+        self.db.set_account_wait("A", "6pm")
+        self.db.set_task_status("a-testing", "testing")
+        self.assertTrue(self.db.clear_account_wait("A"))
+        self.assertFalse(self.db.task("a-testing").overrides_wait)
+        self.db.set_account_wait("A", "8pm")
+        self.assertEqual(self.db.task("a-testing").status_label, "Wait 20:00")
+
+    def test_an_override_survives_the_wait_ending(self):
+        self.db.set_account_wait("A", "1pm")
+        self.at(12, 30)
+        self.db.set_task_status("a-testing", "testing")         # pinned while the wait runs
+        self.at(14)                                             # the wait is over
+        self.assertEqual(self.db.task("a-testing").status, lls.Status.TESTING)
+        self.assertEqual(self.db.task("a-prompt").status, lls.Status.LIMIT_RESET)
+        self.assertEqual(self.db.account("A").wait_state, lls.WaitState.LIMIT_RESET)
+        # resuming another task after the reset clears the finished wait for everyone
+        self.db.set_task_status("a-prompt", "prompt")
+        self.assertEqual(self.db.account("A").wait_state, lls.WaitState.NONE)
+        self.assertEqual(self.db.task("a-testing").status, lls.Status.TESTING)
+        self.assertEqual(self.db.task("a-prompt").status, lls.Status.PROMPT)
+
+    def test_the_override_ends_when_the_status_changes_or_the_task_moves(self):
+        self.db.set_account_wait("A", "6pm")
+        self.db.set_task_status("a-testing", "testing")
+        self.db.set_task_status("a-testing", "uploading")
+        self.assertFalse(self.db.task("a-testing").overrides_wait)
+        self.db.set_task_status("a-testing", "testing")
+        self.assertTrue(self.db.task("a-testing").overrides_wait)
+        self.db.set_task_account("a-testing", "B")              # B is not waiting
+        task = self.db.task("a-testing")
+        self.assertEqual((task.account, task.status, task.overrides_wait), ("B", lls.Status.TESTING, False))
+
+    def test_a_wait_no_task_shows_when_every_task_ignores_it(self):
+        self.db.set_account_wait("A", "6pm")
+        self.db.set_task_status("a-testing", "testing")
+        self.db.set_task_status("a-prompt", "prompt")           # a-done is Done
+        account = self.db.account("A")
+        self.assertEqual((account.level, account.wait_state, account.wait_listed),
+                         (lls.Level.BUSY, lls.WaitState.WAITING, True))
+
+    def test_overrides_are_saved(self):
+        self.db.set_account_wait("A", "6pm")
+        self.db.set_task_status("a-testing", "testing")
+        self.db.save()
+        with lls.Database(self.path) as other:
+            other.set_clock(NOON)
+            self.assertTrue(other.task("a-testing").overrides_wait)
+            self.assertEqual(other.task("a-prompt").status, lls.Status.WAIT)
 
     def test_account_wait_nothing_shows(self):
         self.db.add_account("Empty")
diff --git a/src/Database.cpp b/src/Database.cpp
index 9d43a28..0344dad 100644
--- a/src/Database.cpp
+++ b/src/Database.cpp
@@ -20,7 +20,8 @@ const char* const kSchema =
     "  id TEXT NOT NULL PRIMARY KEY COLLATE NOCASE,"
     "  account TEXT COLLATE NOCASE REFERENCES Account(id) ON UPDATE CASCADE ON DELETE SET NULL,"
     "  status TEXT NOT NULL DEFAULT 'prompt',"
-    "  notes TEXT NOT NULL DEFAULT ''"
+    "  notes TEXT NOT NULL DEFAULT '',"
+    "  wait_override INTEGER NOT NULL DEFAULT 0"
     ");"
     "CREATE INDEX IF NOT EXISTS idx_task_account ON Task(account);";
 
@@ -108,6 +109,15 @@ void Database::createSchema() {
         exec("ALTER TABLE Account ADD COLUMN cooldown TEXT;");
     }
 
+    // Files from before a task could ignore its account's wait have no such column.
+    bool hasOverride = false;
+    for (const Row& row : query("PRAGMA table_info(Task)")) {
+        hasOverride = hasOverride || (row.size() > 1 && row[1] && *row[1] == "wait_override");
+    }
+    if (!hasOverride) {
+        exec("ALTER TABLE Task ADD COLUMN wait_override INTEGER NOT NULL DEFAULT 0;");
+    }
+
     // Waits used to be set on each task. They belong to the account now: move
     // them over (the latest one wins) and let those tasks follow the account.
     exec(
@@ -288,7 +298,7 @@ std::optional<std::string> Database::findTask(const std::string& name) const {
 }
 
 std::optional<TaskRow> Database::getTask(const std::string& name) const {
-    std::vector<Row> rows = query("SELECT id, account, status, notes FROM Task WHERE id = ?1", {name});
+    std::vector<Row> rows = query("SELECT id, account, status, notes, wait_override FROM Task WHERE id = ?1", {name});
     if (rows.empty()) {
         return std::nullopt;
     }
@@ -297,17 +307,19 @@ std::optional<TaskRow> Database::getTask(const std::string& name) const {
     task.account = rows[0][1];
     task.status = *rows[0][2];
     task.notes = *rows[0][3];
+    task.waitOverride = rows[0][4] && *rows[0][4] != "0";
     return task;
 }
 
 std::vector<TaskRow> Database::listTasks() const {
     std::vector<TaskRow> tasks;
-    for (const Row& row : query("SELECT id, account, status, notes FROM Task ORDER BY id")) {
+    for (const Row& row : query("SELECT id, account, status, notes, wait_override FROM Task ORDER BY id")) {
         TaskRow task;
         task.id = *row[0];
         task.account = row[1];
         task.status = *row[2];
         task.notes = *row[3];
+        task.waitOverride = row[4] && *row[4] != "0";
         tasks.push_back(task);
     }
     return tasks;
@@ -334,6 +346,14 @@ void Database::setTaskStatus(const std::string& name, const std::string& status)
     run("UPDATE Task SET status = ?2 WHERE id = ?1", {name, status});
 }
 
+void Database::setTaskWaitOverride(const std::string& name, bool value) {
+    run("UPDATE Task SET wait_override = ?2 WHERE id = ?1", {name, std::string(value ? "1" : "0")});
+}
+
+void Database::clearWaitOverrides(const std::string& account) {
+    run("UPDATE Task SET wait_override = 0 WHERE account = ?1", {account});
+}
+
 void Database::setTaskNotes(const std::string& name, const std::string& notes) {
     run("UPDATE Task SET notes = ?2 WHERE id = ?1", {name, notes});
 }
diff --git a/src/Repl.cpp b/src/Repl.cpp
index 505de3b..9ce1b2c 100644
--- a/src/Repl.cpp
+++ b/src/Repl.cpp
@@ -73,7 +73,7 @@ void Repl::registerCommands() {
         {ArgKind::Task, ArgKind::None}, &Repl::cmdTskRename);
     add("tsk reacc", "tsk reacc <name> <new>", "move a task to another account ('-' = none)", 2, 2,
         {ArgKind::Task, ArgKind::AccountOrDash}, &Repl::cmdTskReacc);
-    add("tsk restat", "tsk restat <name> <new>", "change a task's status (plain 'wait' works while its account is waiting)", 2, kUnlimited,
+    add("tsk restat", "tsk restat <name> <new>", "change a task's status (testing/prompt ignore the account's wait; plain 'wait' follows it again)", 2, kUnlimited,
         {ArgKind::Task, ArgKind::Status}, &Repl::cmdTskRestat);
     add("tsk notes", "tsk notes <name>", "edit a task's notes in your editor (see 'editor')", 1, 1,
         {ArgKind::Task}, &Repl::cmdTskNotes);
diff --git a/src/Tracker.cpp b/src/Tracker.cpp
index 58f3076..05b65de 100644
--- a/src/Tracker.cpp
+++ b/src/Tracker.cpp
@@ -78,20 +78,28 @@ std::optional<std::time_t> Tracker::runningWait(const std::string& account) cons
     return std::nullopt;
 }
 
-// Setting a task to Testing or Prompt after its account's limit has reset means the
-// account is in use again, so the finished wait is cleared (its Limit reset tasks
-// go back to their own status). A wait that is still running is left alone.
-void Tracker::resumeAccount(const std::string& account) {
-    std::optional<AccountRow> row = db_.getAccount(account);
-    if (!row || !row->cooldown) {
+// A task was explicitly set to Testing or Prompt. If its account's limit has reset
+// (a Limit reset), the account is in use again: the finished wait is cleared and
+// the account's tasks go back to their own status. If the wait is still running,
+// only this task ignores it (it shows the status you gave it); the account's other
+// tasks keep following the wait.
+void Tracker::taskInUse(const std::string& taskName, const std::string& accountName) {
+    std::optional<AccountRow> account = db_.getAccount(accountName);
+    if (!account || !account->cooldown) {
         return;
     }
-    const std::optional<std::time_t> until = StatusUtil::timeFromText(*row->cooldown);
+
+    const std::optional<std::time_t> until = StatusUtil::timeFromText(*account->cooldown);
     if (until && *until > now()) {
+        db_.setTaskWaitOverride(taskName, true);
+        note("Account '" + account->id + "' is waiting until " + StatusUtil::clockLabel(*until) + "; '" + taskName +
+             "' ignores it (tsk restat " + taskName + " wait to follow it again).");
         return;
     }
-    db_.setAccountCooldown(row->id, std::nullopt);
-    note("Account '" + row->id + "' is back in use: its finished wait (Limit reset) was cleared.");
+
+    db_.setAccountCooldown(account->id, std::nullopt);
+    db_.clearWaitOverrides(account->id);
+    note("Account '" + account->id + "' is back in use: its finished wait (Limit reset) was cleared.");
 }
 
 // Prompt and Testing tasks follow their account's wait; anything else becomes Prompt.
@@ -100,19 +108,8 @@ void Tracker::makeTaskFollowAccount(const TaskRow& task) {
     if (!current || !StatusUtil::followsAccountWait(current->kind)) {
         db_.setTaskStatus(task.id, StatusUtil::serialize(StatusUtil::make(StatusKind::Prompt)));
     }
-}
-
-// Tells the user when a task's own status is hidden by its account's wait.
-void Tracker::noteAccountWait(const std::string& taskName) {
-    std::optional<TaskRow> task = db_.getTask(taskName);
-    std::optional<Status> stored = task ? StatusUtil::deserialize(task->status) : std::nullopt;
-    if (!task || !task->account || !stored || !StatusUtil::followsAccountWait(stored->kind)) {
-        return;
-    }
-    std::optional<AccountRow> account = db_.getAccount(*task->account);
-    if (account && account->cooldown) {
-        note("It shows as Wait / Limit reset because account '" + account->id + "' is waiting (acc unwait " +
-             account->id + " to clear).");
+    if (task.waitOverride) {
+        db_.setTaskWaitOverride(task.id, false);
     }
 }
 
@@ -146,6 +143,7 @@ void Tracker::renameAccount(const std::string& name, const std::string& newName)
 void Tracker::setAccountWait(const std::string& name, std::time_t until) {
     const std::string account = existingAccount(name);
     db_.setAccountCooldown(account, StatusUtil::timeToText(until));
+    db_.clearWaitOverrides(account);  // a new limit applies to every task of the account
     note("Account '" + account + "' waits until " + StatusUtil::clockLabel(until) +
          ": its Prompt and Testing tasks show Wait, then Limit reset (acc unwait " + account + " to clear).");
 }
@@ -169,6 +167,7 @@ bool Tracker::clearAccountWait(const std::string& name) {
         return false;
     }
     db_.setAccountCooldown(account->id, std::nullopt);
+    db_.clearWaitOverrides(account->id);
     note("Wait cleared on '" + account->id + "'.");
     return true;
 }
@@ -188,8 +187,9 @@ void Tracker::addTask(const std::string& name, const std::optional<std::string>&
     }
 
     Status status = StatusUtil::make(StatusKind::Prompt);
+    const bool bareWait = statusText && StatusUtil::isBareWait(*statusText);
     if (statusText) {
-        if (StatusUtil::isBareWait(*statusText)) {
+        if (bareWait) {
             // "wait" without a time: only while the account is already waiting.
             if (!account || !runningWait(*account)) {
                 throw TrackerError(ErrorCode::Invalid,
@@ -209,11 +209,8 @@ void Tracker::addTask(const std::string& name, const std::optional<std::string>&
     note("Task '" + name + "' added.");
     if (accountWait) {
         setAccountWait(*account, status.waitUntil);
-    } else {
-        if (statusText && account && (status.kind == StatusKind::Testing || status.kind == StatusKind::Prompt)) {
-            resumeAccount(*account);
-        }
-        noteAccountWait(name);
+    } else if (statusText && !bareWait && account && StatusUtil::followsAccountWait(status.kind)) {
+        taskInUse(name, *account);  // an explicit Testing / Prompt
     }
 }
 
@@ -240,6 +237,9 @@ void Tracker::setTaskAccount(const std::string& name, const std::optional<std::s
         account = existingAccount(*accountName);
     }
     db_.setTaskAccount(task.id, account);
+    if (task.waitOverride) {
+        db_.setTaskWaitOverride(task.id, false);
+    }
     note("Task '" + task.id + "' now on account " + (account ? "'" + *account + "'" : std::string("(none)")) + ".");
 }
 
@@ -247,16 +247,17 @@ void Tracker::setTaskStatus(const std::string& name, const std::string& statusTe
     const TaskRow task = existingTask(name);
 
     if (StatusUtil::isBareWait(statusText)) {
-        // "wait" without a time: the task follows its account's running wait.
-        if (!task.account || !runningWait(*task.account)) {
+        // "wait" without a time: the task follows its account's running wait again.
+        const std::optional<std::time_t> until = task.account ? runningWait(*task.account) : std::nullopt;
+        if (!until) {
             throw TrackerError(
                 ErrorCode::Invalid,
                 task.account ? "Account '" + *task.account + "' is not waiting, so a time is required: wait <time>"
                              : "Task '" + task.id + "' has no account, so a time is required: wait <time>");
         }
         makeTaskFollowAccount(task);
-        note("Task '" + task.id + "' now follows account '" + *task.account + "'.");
-        noteAccountWait(task.id);
+        note("Task '" + task.id + "' now follows account '" + *task.account + "' (waiting until " +
+             StatusUtil::clockLabel(*until) + ").");
         return;
     }
 
@@ -271,11 +272,13 @@ void Tracker::setTaskStatus(const std::string& name, const std::string& statusTe
     }
 
     db_.setTaskStatus(task.id, StatusUtil::serialize(status));
+    if (task.waitOverride) {
+        db_.setTaskWaitOverride(task.id, false);
+    }
     note("Task '" + task.id + "' set to " + StatusUtil::label(status) + ".");
-    if (task.account && (status.kind == StatusKind::Testing || status.kind == StatusKind::Prompt)) {
-        resumeAccount(*task.account);
+    if (task.account && StatusUtil::followsAccountWait(status.kind)) {
+        taskInUse(task.id, *task.account);  // an explicit Testing / Prompt
     }
-    noteAccountWait(task.id);
 }
 
 bool Tracker::setTaskNotes(const std::string& name, const std::string& notes) {
diff --git a/src/Views.cpp b/src/Views.cpp
index c4b4d48..cd40662 100644
--- a/src/Views.cpp
+++ b/src/Views.cpp
@@ -96,7 +96,8 @@ std::vector<TaskInfo> buildTasks(const Database& db, std::time_t now) {
                 accountWait = found->second;
             }
         }
-        info.status = StatusUtil::resolve(info.storedStatus, accountWait, now);
+        info.overridesWait = row.waitOverride && accountWait && StatusUtil::followsAccountWait(info.storedStatus.kind);
+        info.status = StatusUtil::resolve(info.storedStatus, info.overridesWait ? std::nullopt : accountWait, now);
         tasks.push_back(info);
     }
 
diff --git a/src/capi.cpp b/src/capi.cpp
index a394da2..e5cc82e 100644
--- a/src/capi.cpp
+++ b/src/capi.cpp
@@ -326,6 +326,7 @@ int lls_tasks(lls_db* db, lls_task_list** out_list) {
             info.until = timed ? static_cast<int64_t>(task.status.waitUntil) : 0;
             info.notes = task.notes.c_str();
             info.notes_lines = static_cast<int>(task.noteLines);
+            info.overrides_wait = task.overridesWait ? 1 : 0;
         }
         *out_list = list.release();
     }, true);