Requires CMake >= 3.14 and a C++17 compiler. SQLite is taken from the system if installed; otherwise CMake downloads the amalgamation (needs network once).

# optional, system SQLite:
#   Debian/Ubuntu: sudo apt install libsqlite3-dev
#   Fedora:        sudo dnf install sqlite-devel
#   Arch:          sudo pacman -S sqlite

cmake -S . -B build
cmake --build build
./build/lls [database-file]      # default: tasks.db

This builds three things: the prompt (lls), the C API as a shared library (liblls_api.so / lls_api.dll, header include/lls_api.h) and a C example (lls_example).

Commands

acc add <name>              tsk add <name> [acc] [status]
acc del <name>              tsk del <name>
acc rename <name> <new>     tsk rename <name> <new>
acc wait <name> <time>      tsk reacc <name> <new|->
acc unwait <name>           tsk restat <name> <new>
acc ls                      tsk notes <name>      (opens your editor)
                            tsk ls

disp tsk (hide|show)
disp tsk level (hide|show) (prompt|limit-reset|testing|wait|uploading|frozen|done|all)
disp acc (hide|show)
disp acc level (hide|show) (busy|taken|free|all)
disp                        (show current settings)

db save | db backup [file] | db restore <file>
editor [command | default]  (show / set the editor used by tsk notes)
help | quit

Names containing spaces go in double quotes: tsk add "Breeze A" Acrux testing.

Statuses and times

prompt (free to accept prompts), limit-reset, testing, wait <time>, uploading, frozen, done. limit-reset is normally computed: a wait task shows as Limit reset once its time has passed (it can also be set by hand; limit reset with a space works too). Old databases that say available are converted to prompt on load.

Times may be 24-hour or 12-hour: wait 16:30, wait 4:30pm, wait 4 pm, wait 12:05am. Without am/pm the time is read as 24-hour (6:40 = 06:40). A time that has already passed today is stored as tomorrow.

Prompt keys

Up/Down history (saved between sessions), Left/Right/Home/End editing, Ctrl-Left/Right word jump, Tab completion (commands, task and account names, statuses, levels, editors, file paths; press Tab twice-ish to list options), Ctrl-A/E, Ctrl-U/K/W, Ctrl-L clear, Ctrl-C cancel line, Ctrl-D quit. Pressing Enter on an empty line redraws the panels (waits expire with time).

Editor

tsk notes <name> opens the notes in an external editor. Use editor nvim (or vim, vi, nano, code --wait, ...) to choose one; editor default goes back to $VISUAL / $EDITOR / nano / vim / vi. The choice is stored in ~/.config/task_tracker/config (history is in the same folder).

How it works

Data lives in an in-memory SQLite database. db save writes it to the file, db backup writes a copy, db restore loads a file. On quit you are asked to save if there are unsaved changes (y save, n discard, c cancel the exit); any other answer asks again, so a mistyped key never loses data.
The stored status is not always what is shown: a wait task displays as Wait HH:MM until its account's wait ends, then as Limit reset. Tasks are sorted by computed status (Limit reset, Testing, Prompt, Wait, Uploading, Frozen, Done); Wait and Limit reset tasks then sort by time (earliest first: when the wait ends / ended), then account A-Z (unassigned last), then name. The panels are cleared and redrawn after changes.
Account panel: the RESET column is when the account's wait ends (16:30, tomorrow 06:40, or a full date); - if it has none. One row per account, judged by its tasks: Busy if any is Testing, Limit reset or Wait; else Taken if any is Prompt; else Free (only Done, Frozen or Uploading tasks, or no tasks). The TASKS column lists the tasks at that level, so a Free account shows its Uploading, Frozen and Done tasks (- if it has none). Rows are sorted most free first: Free, Taken, Busy; within Taken and Busy fewer tasks first, ties by name (see levelOf in Display.cpp and StatusUtil::isBusy / isTaken to change the rules).
Waits: an account hits its limit until a time (acc wait <name> <time>). A task that is set to wait is waiting for that: tsk restat <task> wait <time> sets its account's wait to the time and marks the task Wait (several waiting tasks share the account's time), and tsk restat <task> wait with no time marks it Wait while the account is already waiting (otherwise a time is required). Tasks without an account keep their own wait time.
When the time passes the account stops waiting by itself, and every task that was Wait now shows Limit reset: the conversation can be continued. Those tasks stay Limit reset until you set them to something else. acc unwait <name> ends the wait early, with the same result.
Prompt and Testing tasks are not waiting: they show as they are, with (account-waiting) added while their account waits, e.g. Testing (account-waiting). The account row shows when the wait ends in the RESET column, and stays Busy while it waits; if none of its tasks is set to Wait (e.g. you deleted them) its TASKS column lists (wait).
Old databases with per-task waits are converted on load.
Deleting an account leaves its tasks unassigned (-).
Names are case-insensitive; the original spelling is kept.
Notes live in the database (SQLite TEXT, binary-safe, SQLite's default limit is ~1 GB). The task table shows - when a task has no notes, otherwise the number of lines (e.g. 3 lines); open them with tsk notes <name>.

C API and Python

include/lls_api.h is a plain C API over the same database and the same rules as the prompt (it is built on the same Tracker class), so a program written against it behaves exactly like typing the commands. Build it with the project (liblls_api.so), link against it from C/C++, or load it from Python.

#include "lls_api.h"

lls_db* db;
if (lls_open("tasks.db", &db) != LLS_OK) { /* lls_last_error(NULL) */ }

lls_account_add(db, "Acrux");
lls_task_add(db, "Breeze A", "Acrux", "testing");
lls_task_add(db, "Breeze B", "Acrux", "wait 4:30pm"); /* Acrux hit its limit; Breeze B waits for it */

lls_task_list* tasks;
lls_tasks(db, &tasks);                           /* display order */
for (int i = 0; i < lls_task_list_count(tasks); ++i) {
    const lls_task_info* t = lls_task_list_get(tasks, i);
    printf("%s %s\n", t->name, t->status_label);  /* "Breeze A Testing (account-waiting)" ... */
}
lls_task_list_free(tasks);

lls_save(db);                                    /* nothing is saved automatically */
lls_close(db);

Every call that can fail returns LLS_OK or an error code (LLS_E_INVALID, LLS_E_NOT_FOUND, LLS_E_EXISTS, LLS_E_DATABASE) with the message in lls_last_error(db). No C++ exception crosses the API.
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)... A task set to wait waits for its account; when the time passes the account stops waiting by itself and those tasks show Limit reset. Prompt / Testing tasks keep their status, with (account-waiting) in status_label (and account_waiting = 1) while the account waits.
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.
lls_set_clock(db, unix_seconds) pretends it is another time, handy for tests and simulations; 0 goes back to the real clock.
A lls_db must not be shared between threads without your own locking.

python/lls.py is a ctypes binding (no compiler needed):

import lls                       # python/ is on sys.path; LLS_LIBRARY=build/liblls_api.so

with lls.Database("tasks.db") as db:
    db.add_account("Acrux")
    db.add_task("Breeze A", account="Acrux", status="testing")
    db.add_task("Breeze B", account="Acrux", status="wait 4:30pm")   # sets Acrux's wait
    for task in db.tasks():
        print(task.name, task.account, task.status_label, task.until)
    for account in db.accounts():
        print(account.name, account.level.name, account.tasks)
    print(db.messages)
    db.save()

Errors are exceptions (lls.NotFound, lls.AlreadyExists, lls.InvalidArgument, lls.DatabaseError, all lls.LLSError). The library is found through the LLS_LIBRARY environment variable, ../build next to the module, or the current directory's build. Run the tests with

LLS_LIBRARY=build/liblls_api.so python3 python/test_lls.py -v

Layout

include/    headers (declarations only, no inline definitions); lls_api.h is the public C header
src/        implementations
examples/   example.c - the C API from C
python/     lls.py (ctypes binding) and test_lls.py

Core (static library, shared by the prompt and the C API):
  Database    SQLite storage            Tracker   all the rules; the only thing that changes data
  Status      statuses, times           Views     computed task / account views and their order
Prompt only:  Repl, LineEditor, Completer, Display, Table, Config, ExternalEditor...
C API:        capi.cpp (wraps Tracker + Views)