org.nvim

Clocking and effort

<prefix>xiClock in on the current entry. Any running clock is stopped first, and clock.in_switch_to_state can change the TODO state. A count picks a task from the clock history (d default task, i the interrupted task, c the current one, 1-9 A-Z recent tasks); 16 also marks the entry as the default task; 64 starts where the last clock stopped.
<prefix>xoClock out (global). clock.out_switch_to_state changes the TODO state; with a count, you are asked for the state.
<prefix>xqCancel the running clock (global).
<prefix>xjJump to the clocked entry (global), else to the last clocked one. With a count, pick from the history.
<prefix>xeSet effort.
<prefix>xESet effort to the next value of Effort_ALL.
<prefix>xmChange the effort of the clocked task (or the entry at the cursor); +0:15 / -10 add or subtract.
<prefix>xzResolve open clocks (with a count: only dangling ones, not the running clock). See org-clock-resolve.
<prefix>xdShow the time clocked in each subtree next to its headline, for clock.display_default_range (this year). Count: 4 = today, 16 = ask for a range, 64 = only the total. Editing the buffer, <C-c><C-c> or calling it again hides the sums. Like Emacs, a sum covers the tags and also shows on folded headlines; the times line up on the displayed title.
<prefix>xrInsert a clock report (#+BEGIN: clocktable) for the entry at the cursor (:scope subtree), or the file before the first headline; update it when on one. With a count, update the first clock table of the buffer. A new block gets clock.clocktable_default_properties. The total and file time cells use clock.total_time_cell_format / clock.file_time_cell_format ("*%s*"). clock.clocktable_formatter replaces the table writer: function(tables, params) gets { { file, time, entries = { { level, headline, tags, timestamp, time (minutes), properties } } } } and the block parameters, and returns the lines of the block (org-clock-clocktable-formatter).
<C-c><C-c>On a CLOCK line: recompute its duration.
<C-S-Up/Down>On a CLOCK line: shift both timestamps by the part under the cursor, keeping the duration.
<M-K> / <M-J>On a CLOCK timestamp (Emacs S-M-Up/Down): change it and move the touching timestamp of the previous (on a clock-in) or next (on a clock-out) task in the clock history by the same amount.
<S-arrows>On a #+BEGIN: clocktable line: shift its :block (today -> today-1, 2026-W39 -> 2026-W40, ...).
:Org clock_in_lastClock in the last clocked entry again (count: pick from the history; 16 = from the last clock-out; 64 = ask for the TODO state).
:Org clock_mark_default_taskMark the entry as the default task.
:Org clock_toggle_auto_clockoutTurn auto clock-out on/off for this session.

Clock lines go into the LOGBOOK drawer:

:LOGBOOK:
CLOCK: [2026-09-23 Wed 10:00]--[2026-09-23 Wed 11:30] =>  1:30
:END:

As in Emacs, a clock line has nothing after its duration (CLOCK: in any case); a line with text after it is a paragraph and its time is not counted. A naked CLOCK: => 2:00 adds two hours to the entry's clock sums, whatever their time range. A clock whose start has no time ([2026-09-23 Wed]--...) counts for nothing, and an end without a time takes the start's (org-clock-sum).

The drawer comes from the inherited CLOCK_INTO_DRAWER property (nil for none, a number N for "once there are N clock lines"), then clock.into_drawer, then the log drawer. With log_note_clock_out (or #+STARTUP: lognoteclock-out), clocking out asks for a note that goes below the CLOCK line. clock.continuously starts a new clock where the last one stopped, clock.rounding_minutes rounds clock times like Emacs (org-current-time): clocking out takes the nearest multiple, a tie going to the even one (with 10, 10:25 is 10:20); clocking in never starts in the future (with 10, 10:27 is 10:20). clock.in_resume continues an entry's open CLOCK line.

Marking a clocked task done clocks it out (clock.out_when_done: true or a list of states). A running clock is restored after restarting Neovim (clock.persist: true, "clock" or "history"), after asking (clock.persist_query_resume). Quitting with a running clock asks whether to clock out and save first (clock.ask_before_exiting). Clocks of 0:00 are kept unless clock.out_remove_zero_time is set.

The statusline shows [clocked/effort] (Task), where the clocked time includes the task's earlier clocks (clock.mode_line_total or the CLOCK_MODELINE_TOTAL property: current, today, repeat, all, auto = since LAST_REPEAT for repeated tasks). Once it reaches the Effort you are notified once (clock.notify_effort, clock.sound, clock.notification_handler) and clock.task_overrun_text is prepended.

User autocmds: OrgClockInPrepare (before the CLOCK line is written, e.g. to set an effort), OrgClockIn, OrgClockOut, OrgClockCancel, OrgClockGoto.

Resolving clocks

An open CLOCK line that isn't the running clock is dangling (e.g. after a crash). Clocking in resolves them first (clock.auto_clock_resolution), and after clock.idle_time idle minutes you are asked about the running clock (the system idle time is used on macOS and with xprintidle). Keys:

k / Kkeep N of the minutes (default all) and stay clocked in / out
t / Tkeep the time until a given time
g / Gyou got back N minutes ago: clock out when you left, clock in again from then (G: stay out)
s / Ssubtract the idle time: clock in again now (S: stay out; the next clock in offers to start from the subtracted time)
Ccancel the clock
j / Jjump to the clock (J: clock it out first)
i / qignore

clock.auto_clockout_timer clocks out after that many idle seconds.

Durations

A duration is numbers with units, optionally ending in H:MM or H:MM:SS: 3:12, 1:23:45, 1y 3d 3h 4min, 1d3h5min, 3d 13:35, 2.35h; a bare number is minutes. The units and their minutes come from duration_units (Emacs org-duration-units):

duration_units = { min = 1, h = 60, d = 1440, w = 10080, m = 43200, y = 525960 }

Setting d = 480, w = 2400 makes 1d an 8-hour work day in efforts and column sums; new units can be added (wd = 480). Ages ({@min} ...) keep the standard min/h/d.

Durations in clock tables, clock sums, the clock mode line, effort changes and column summaries are written with duration_format (Emacs org-duration-format):

"d h:mm"1d 2:30 from one day on, else 2:30 (the default, Emacs (("d" . nil) (special . h:mm)))
"h:mm"26:30
"h:mm:ss"26:30:00
a list

of { unit, required } entries, { "special", mode } and "compact": units with a zero value are dropped unless required; mode "h:mm" / "h:mm:ss" writes the time below the smallest unit above an hour as H:MM(:SS); a number of decimals writes one unit with a fraction (the first required unit or one not larger than the duration); "compact" drops the spaces. Examples: { { "d" }, { "h", true }, { "min", true } } 1d 2h 30min

{ { "d" }, { "h" }, { "special", 2 } }1.10d
{ { "h", true }, { "special", 2 } }26.50h
{ { "w" }, { "special", "h:mm" }, "compact" }1w32:00

A dict form works too: { d = false, special = "h:mm" }.

Use org-api require("org").statusline() in your statusline.