Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Clocking, Effort and Timers

Planning tells you what you intend to do; a record of time tells you what actually happened. Org can measure the time you spend on each task, store the measurements in the task itself, and summarize them in reports. Combined with effort estimates (the expected duration of a task), these records let you compare plans with reality and improve your estimates over time.

This chapter covers 3 related tools. Clocking records intervals of work on a headline (the title line of an entry, starting with stars). The clock table turns those records into reports. Timers measure time without attaching it to a task, which is useful for meeting notes or for a focused work session.

The timestamps used throughout are those introduced in Dates and Times. The outputs in this chapter were produced by Org 9.8.13 in Emacs batch mode, with the clock set to Thursday, 19 November 2026.

How clocking works

When you clock in on a task, Org writes a CLOCK: line with an inactive timestamp into that task. When you clock out, it completes the line with the end time and the duration. Each completed line is a clock entry, and the collection of clock entries in a subtree (a heading together with everything below it) is all the information Org needs to compute totals.

Here is a task before clocking:

* TODO Fresh task

After C-c C-x C-i (org-clock-in) at 09:00:

* TODO Fresh task
:LOGBOOK:
CLOCK: [2026-11-19 Thu 09:00]
:END:

After C-c C-x C-o (org-clock-out) at 10:47:

* TODO Fresh task
:LOGBOOK:
CLOCK: [2026-11-19 Thu 09:00]--[2026-11-19 Thu 10:47] =>  1:47
:END:

The clock lines are kept in a drawer, a named block between :NAME: and :END: that Org folds away by default. The clock uses the LOGBOOK drawer. With the default value of org-clock-into-drawer (t), even the first clock line goes into the drawer, as above. You can choose a different drawer name or a threshold number of lines through this variable, and override it for a subtree with the CLOCK_INTO_DRAWER or LOG_INTO_DRAWER property (a property is a key-value pair stored in the PROPERTIES drawer of an entry). State-change notes go into the same drawer when org-log-into-drawer is set (see TODO Items).

New clock lines are added at the top of the drawer, so the most recent work comes first. After a second session on the same task, the drawer looks like this:

* TODO Write the migration script
  :LOGBOOK:
  CLOCK: [2026-11-19 Thu 09:00]--[2026-11-19 Thu 10:47] =>  1:47
  CLOCK: [2026-11-18 Wed 14:00]--[2026-11-18 Wed 15:30] =>  1:30
  :END:

Only one clock at a time

Org runs a single clock. If you clock in on a second task while the first is running, Org clocks out of the first task at that moment. This makes switching tasks a one-key operation and guarantees that no time is counted twice. In the following run, the review was clocked in at 09:00, the ticket at 09:40 (which stopped the review), and the clock was stopped at 10:05:

* TODO Review pull request 418
:LOGBOOK:
CLOCK: [2026-11-19 Thu 09:00]--[2026-11-19 Thu 09:40] =>  0:40
:END:
* TODO Answer support ticket
:LOGBOOK:
CLOCK: [2026-11-19 Thu 09:40]--[2026-11-19 Thu 10:05] =>  0:25
:END:

Org also remembers which task was interrupted. Capture uses this to resume the previous clock after you have filed a quick note (see Capture, Refile, Archive and Attachments).

Marking the clocked task as done with C-c C-t stops the clock as well, provided org-clock-out-when-done keeps its default value t.

Totals are computed, not stored

Org never stores a total. Whenever a total is needed, it adds up the clock entries in a subtree, so a parent heading’s total always includes the time of all its children. This design has a practical consequence: you can correct a clock line by hand, move subtrees around, or archive finished tasks, and every report computed afterwards reflects the change.

flowchart LR
  K["C-c C-x C-i / C-o"] -->|"writes CLOCK lines"| L["LOGBOOK drawer"]
  L -->|"summed per subtree"| S["Clock sums"]
  S -->|"current task total"| M["Mode line"]
  S -->|"C-c C-x C-d"| O["Overlays on headlines"]
  S -->|"C-c C-c on BEGIN line"| T["Clocktable block"]
  S -->|"R in the agenda"| A["Agenda clock report"]
  S -->|"CLOCKSUM column"| C["Column view"]

Figure 11.1: Clock lines are the only stored data; every display of clocked time is computed from them on demand.

The clocking commands

The commands below are available in any Org buffer. The most important ones, clocking in and out, are worth binding globally if you clock often.

KeyCommandPurpose
C-c C-x C-iorg-clock-inStart the clock on the current entry.
C-c C-x C-oorg-clock-outStop the clock.
C-c C-x C-xorg-clock-in-lastClock in again on the last clocked task.
C-c C-x C-qorg-clock-cancelRemove the running clock line, for a clock started by mistake.
C-c C-x C-jorg-clock-gotoJump to the task that is being clocked.
C-c C-x C-dorg-clock-displayShow the total time of each subtree as overlays.
C-c C-x C-zorg-resolve-clocksLook for open clocks and resolve them.
C-c C-x C-eorg-clock-modify-effort-estimateChange the effort of the clocked task.

Clocking in

org-clock-in accepts prefix arguments that change where it clocks in:

  • C-u C-c C-x C-i offers a menu of recently clocked tasks. The number of tasks remembered is org-clock-history-length (5 by default).
  • C-u C-u C-c C-x C-i clocks in on the current task and marks it as the default task. The default task is always available under the key d in the selection menu, which makes it a convenient place for general time, such as “Email and admin”.
  • C-u C-u C-u C-c C-x C-i starts the clock at the moment the previous clock stopped, so that the gap between the 2 tasks is attributed to the new one. This is called continuous clocking.

While the clock runs, the mode line shows the task and the time spent on it. If the task has an effort estimate, the mode line shows the clocked time against that estimate. What counts as “the time spent” is set by org-clock-mode-line-total: current (only this session), today, repeat (since the last repetition of a repeating task), all, or auto, the default, which uses repeat for repeating tasks and all otherwise. The CLOCK_MODELINE_TOTAL property overrides the variable for one task.

The variable org-clock-in-switch-to-state changes the TODO state of a task when you clock in, for example from TODO to STARTED. Its value is a state name or a function that receives the current state and returns the new one.

(setq org-clock-in-switch-to-state "STARTED")

If you use this setting, make sure that STARTED is one of your TODO keywords (see TODO Items).

Clocking out and correcting entries

org-clock-out completes the running clock line and computes the duration. If you want to record what you achieved, set org-log-note-clock-out to t (or use #+STARTUP: lognoteclock-out), and Org will ask for a short note. Very short sessions can be discarded automatically with org-clock-out-remove-zero-time-clocks.

Clock lines are ordinary text. When you notice that you forgot to clock out before lunch, open the drawer and change the end time. If you edit a timestamp by typing, press C-c C-c (or C-c C-y) on the line to recompute the duration; if you change it with S-UP and S-DOWN, the duration updates by itself. Another 2 keys help with adjacent entries:

  • C-S-UP and C-S-DOWN (org-clock-timestamps-up, org-clock-timestamps-down) shift both timestamps of a clock line, keeping its duration.
  • S-M-UP and S-M-DOWN change the timestamp at point and also the touching timestamp of the previous or next clock line, so that 2 consecutive sessions stay contiguous. This only applies to clock lines created in the current Emacs session.

Keeping the clock across Emacs sessions

By default, Org forgets the clock history and any running clock when Emacs exits. The following configuration saves both and restores them at the next start:

(setq org-clock-persist t)
(org-clock-persistence-insinuate)

With the value history, only the list of recent tasks is saved; with clock, only the running clock. When a clock is restored, Org treats the interval while Emacs was closed as time to be resolved, as described below.

Resolving idle and lost time

A clock measures wall time, not attention. If you clock in and then leave your desk for an hour, the record is wrong. Org offers 3 mechanisms to keep the record honest.

Idle detection

Set org-clock-idle-time to a number of minutes. When you return after being idle for longer than that while a clock is running, Org asks what to do with the idle period:

KeyEffect
kKeep some or all of the idle minutes and continue clocking.
KKeep the minutes you specify, then clock out.
sSubtract the idle time and continue clocking from now.
SSubtract the idle time and clock out at the moment you became idle.
CCancel the clock entirely.

The uppercase variants always leave you clocked out. If you subtract time and then immediately clock in on another task, Org offers to assign the subtracted minutes to that task, which is exactly what you want when an interruption turned out to be work on something else.

How Org measures idleness depends on the system. On macOS, it uses the real user idle time. On X11, it can use an external program configured in org-clock-x11idle-program-name (such as xprintidle). Elsewhere, it measures only how long Emacs itself has been idle.

(setq org-clock-idle-time 15)

Dangling clocks

If Emacs crashes or is killed while a clock runs, the task is left with an open CLOCK: line. The next time you clock in, Org notices this dangling clock and asks how to resolve the time since it started, with the same choices as for idle time. You can also check all agenda files for open clocks at any moment with C-c C-x C-z (org-resolve-clocks).

Automatic clock-out

If you often forget to clock out before you leave, let Org do it. Set org-clock-auto-clockout-timer to a number of seconds and activate the feature:

(setq org-clock-auto-clockout-timer 1800)
(org-clock-auto-clockout-insinuate)

After 30 minutes of Emacs idle time, the clock stops. M-x org-clock-toggle-auto-clockout switches the feature on and off for the current session.

stateDiagram-v2
  [*] --> Stopped
  Stopped --> Running: clock in
  Running --> Running: clock in elsewhere (old clock closed)
  Running --> Stopped: clock out, DONE, cancel
  Running --> Resolving: idle longer than org-clock-idle-time
  Resolving --> Running: k or s
  Resolving --> Stopped: K, S or C
  Running --> Stopped: auto clock-out timer

Figure 11.2: A running clock leaves its state only through an explicit command, a state change to DONE, or one of the idle mechanisms.

Clock tables

A clock table is a report of clocked time, written into the buffer as an Org table. It is a dynamic block: a region between #+BEGIN: and #+END: whose content Org regenerates from the parameters on the #+BEGIN: line. Dynamic blocks in general are introduced in Tags, Properties and Column View.

Inserting and updating

Use C-c C-x x (org-dynamic-block-insert-dblock) and choose clocktable, or call M-x org-clock-report directly. Org inserts a block and fills it:

#+BEGIN: clocktable :maxlevel 2 :scope file
#+END:

To refresh the report, put point on the #+BEGIN: line and press C-c C-c or C-c C-x C-u (org-dblock-update). C-u C-c C-x C-u updates every dynamic block in the buffer. With point on the #+BEGIN: line, S-LEFT and S-RIGHT (org-clocktable-try-shift) move a :block period backwards or forwards, for example from today to today-1, and update the table.

A sample project

The following file records a week of work on a website. Its clock lines will be used for all reports in this section.

#+TITLE: Website relaunch

* Design
** DONE Wireframes
   :PROPERTIES:
   :Effort:   3:00
   :END:
   :LOGBOOK:
   CLOCK: [2026-11-16 Mon 09:00]--[2026-11-16 Mon 11:30] =>  2:30
   CLOCK: [2026-11-17 Tue 13:00]--[2026-11-17 Tue 14:15] =>  1:15
   :END:
** TODO Color palette                                               :client:
   :PROPERTIES:
   :Effort:   1:00
   :END:
   :LOGBOOK:
   CLOCK: [2026-11-18 Wed 10:00]--[2026-11-18 Wed 10:40] =>  0:40
   :END:
* Development
** TODO Content API
   :PROPERTIES:
   :Effort:   6:00
   :END:
   :LOGBOOK:
   CLOCK: [2026-11-17 Tue 09:00]--[2026-11-17 Tue 12:00] =>  3:00
   CLOCK: [2026-11-18 Wed 13:00]--[2026-11-18 Wed 16:30] =>  3:30
   :END:
** TODO Deployment pipeline
   :PROPERTIES:
   :Effort:   2:00
   :END:
   :LOGBOOK:
   CLOCK: [2026-11-19 Thu 08:00]--[2026-11-19 Thu 09:00] =>  1:00
   :END:

A basic report of the whole file, 2 levels deep:

#+BEGIN: clocktable :scope file :maxlevel 2
#+CAPTION: Clock summary at [2026-11-19 Thu 09:27]
| Headline                |    Time |      |
|-------------------------+---------+------|
| *Total time*            | *11:55* |      |
|-------------------------+---------+------|
| Design                  |    4:25 |      |
| \_  Wireframes          |         | 3:45 |
| \_  Color palette       |         | 0:40 |
| Development             |    7:30 |      |
| \_  Content API         |         | 6:30 |
| \_  Deployment pipeline |         | 1:00 |
#+END:

Each level has its own time column, so you can read the level 1 totals at a glance and the details on the right. TODO keywords are removed from the headlines. Clocks below :maxlevel are not lost; they are added to their nearest ancestor that is shown.

Choosing what to count

The parameters on the #+BEGIN: line fall into 2 groups: those that select clock entries and those that shape the table. Defaults for all of them can be set in org-clocktable-defaults.

flowchart LR
  F["Org files"] -->|":scope"| E["Entries in scope"]
  E -->|":match tag/property query"| E2["Matching entries"]
  E2 -->|":block or :tstart/:tend"| C["Clock entries in the period"]
  C -->|":step"| P["One table per day, week, ..."]
  C --> T["Table layout: :maxlevel, :properties, :tags, :formula"]
  P --> T
  T -->|":formatter"| OUT["Inserted table"]

Figure 11.3: A clock table first narrows files, entries and time, then formats what remains.

:scope decides which text is examined:

ValueScope
nilThe current buffer, respecting narrowing.
fileThe whole current buffer.
subtreeThe subtree that contains the clock table.
tree or treeNThe surrounding level 1 tree, or level N tree.
agendaAll agenda files.
("a.org" "b.org")An explicit list of files.
file-with-archives, agenda-with-archivesAs above, plus the archive files.

A function that returns a list of files is also accepted. Including archives matters if you archive finished tasks before writing a monthly report: archived clock lines still count, but only when the scope includes the archive files (see Capture, Refile, Archive and Attachments).

:block selects a period by name. Absolute forms are 2026-11-19, 2026-11, 2026-W47, 2026-Q4 and 2026. Relative forms are today, yesterday, thisweek, lastweek, thismonth, lastmonth, thisyear, lastyear, the numbered variants such as today-2 or thisweek-1, and untilnow. For an arbitrary interval, use :tstart and :tend with timestamps or relative expressions such as "<-1w>" and "<now>". Without either option, Org uses org-clock-display-default-range, which is the current year by default.

The following report covers 18 November, with an explicit start and end:

#+BEGIN: clocktable :scope file :maxlevel 2 :tstart "<2026-11-18 Wed>" :tend "<2026-11-19 Thu>"
#+CAPTION: Clock summary at [2026-11-19 Thu 09:33]
| Headline          |   Time |      |
|-------------------+--------+------|
| *Total time*      | *4:10* |      |
|-------------------+--------+------|
| Design            |   0:40 |      |
| \_  Color palette |        | 0:40 |
| Development       |   3:30 |      |
| \_  Content API   |        | 3:30 |
#+END:

:match restricts the report to entries that satisfy a query on tags (short labels at the end of a headline, such as :client:) and properties, using the syntax described in Tags, Properties and Column View. This is how you bill a client for the work tagged with their name:

#+BEGIN: clocktable :scope file :maxlevel 2 :match "client"
#+CAPTION: Clock summary at [2026-11-19 Thu 09:27]
| Headline          | Time   |      |
|-------------------+--------+------|
| *Total time*      | *0:40* |      |
|-------------------+--------+------|
| Design            | 0:40   |      |
| \_  Color palette |        | 0:40 |
#+END:

Splitting a period into steps

:step divides the period into days, weeks, semimonths, months, quarters or years and produces one table per step. It requires :block or :tstart and :tend. :stepskip0 omits empty steps, and :wstart and :mstart set the first day of a week (1 is Monday) and of a month. This is a convenient timesheet:

#+BEGIN: clocktable :scope file :maxlevel 1 :block thisweek :step day :stepskip0 t

Daily report: [2026-11-16 Mon]
| Headline     | Time   |
|--------------+--------|
| *Total time* | *2:30* |
|--------------+--------|
| Design       | 2:30   |

Daily report: [2026-11-17 Tue]
| Headline     |   Time |
|--------------+--------|
| *Total time* | *4:15* |
|--------------+--------|
| Design       |   1:15 |
| Development  |   3:00 |

Daily report: [2026-11-18 Wed]
| Headline     |   Time |
|--------------+--------|
| *Total time* | *4:10* |
|--------------+--------|
| Design       |   0:40 |
| Development  |   3:30 |

Daily report: [2026-11-19 Thu]
| Headline     | Time   |
|--------------+--------|
| *Total time* | *1:00* |
|--------------+--------|
| Development  | 1:00   |

#+END:

Shaping the table

The remaining parameters control the layout. These are the most useful ones:

ParameterEffect
:maxlevelDeepest heading level listed.
:linkTurn headlines into links to their entries.
:tagsAdd a column with the tags of each headline.
:propertiesAdd one column per listed property, for example ("Effort").
:inherit-propsUse inherited values for :properties.
:timestampAdd the entry’s scheduled, deadline or other timestamp.
:level, :indentShow a level column, or indent headlines by level.
:tcolumnsNumber of time columns; lower levels are combined.
:narrowTruncate the headline column, for example 40!.
:compactShorthand for :level nil :indent t :narrow 40! :tcolumns 1.
:emphasizeEmphasize level 1 and 2 entries.
:formulaA TBLFM formula added to the table; % adds a percentage column.
:sortSort by a column, such as (1 . ?a) for alphabetical order.
:fileskip0, :hidefiles, :filetitleControl file sections in multi-file reports.

A percentage column shows where the time went:

#+BEGIN: clocktable :scope file :maxlevel 2 :formula %
#+CAPTION: Clock summary at [2026-11-19 Thu 09:27]
| Headline                |    Time |      |     % |
|-------------------------+---------+------+-------|
| *Total time*            | *11:55* |      | 100.0 |
|-------------------------+---------+------+-------|
| Design                  |    4:25 |      |  37.1 |
| \_  Wireframes          |         | 3:45 |  31.5 |
| \_  Color palette       |         | 0:40 |   5.6 |
| Development             |    7:30 |      |  62.9 |
| \_  Content API         |         | 6:30 |  54.5 |
| \_  Deployment pipeline |         | 1:00 |   8.4 |
#+END:

Listing the Effort property next to the clocked time turns the report into a planning review. The :tags column shows which entry belongs to the client:

#+BEGIN: clocktable :scope file :maxlevel 2 :properties ("Effort") :tags t
#+CAPTION: Clock summary at [2026-11-19 Thu 09:27]
| Tags   | Effort | Headline                |    Time |      |
|--------+--------+-------------------------+---------+------|
|        |        | *Total time*            | *11:55* |      |
|--------+--------+-------------------------+---------+------|
|        |        | Design                  |    4:25 |      |
|        |   3:00 | \_  Wireframes          |         | 3:45 |
| client |   1:00 | \_  Color palette       |         | 0:40 |
|        |        | Development             |    7:30 |      |
|        |   6:00 | \_  Content API         |         | 6:30 |
|        |   2:00 | \_  Deployment pipeline |         | 1:00 |
#+END:

The wireframes took 45 minutes longer than estimated, and the Content API has already used 6:30 of its 6:00 although it is still open. The color palette and the deployment pipeline are within their estimates so far. If you write your own formula below the table instead of using :formula, it survives updates and is recalculated each time; formulas are explained in The Spreadsheet and Plotting.

When none of the built-in layouts fits, :formatter names a function that receives the collected clock data and inserts whatever it wants. The default formatter is org-clocktable-write-default, and its source is the best starting point for a custom one.

Clock reports in the agenda

The agenda, the overview of dated and open tasks that Org builds from your files, can show the same report below a daily or weekly view. Press R (org-agenda-clockreport-mode) to toggle it; the parameters come from org-agenda-clockreport-parameter-plist. l (org-agenda-log-mode) adds the clocked intervals and closed tasks of each day to the agenda itself. From the agenda you can also clock in and out with I and O. See Agenda Views for details.

Effort estimates

An effort estimate is the time you expect a task to take, stored in the Effort property (the name is set by org-effort-property). Estimates make 2 things possible: you can see whether a day’s plan fits into the available hours, and after the work you can compare the estimate with the clocked time.

Durations are written in the format of org-duration.el, which accepts several notations. The table below shows how Org reads some inputs, as computed by org-duration-to-minutes and printed back with org-duration-from-minutes:

InputMinutesPrinted as
0:45450:45
1:30901:30
2h1202:00
1d3h5min16251d 3:05
3d43203d 0:00

The units come from org-duration-units. By default a day (d) is 24 hours, not a working day, so 3d means 72 hours.

Setting estimates

KeyCommandPurpose
C-c C-x eorg-set-effortSet the effort of the current entry.
C-c C-x Eorg-inc-effortChange the effort to the next allowed value.
C-c C-x C-eorg-clock-modify-effort-estimateChange the effort of the clocked task.
e (agenda)org-agenda-set-effortSet the effort from the agenda.

The command is fast when the allowed values are fixed. Declare them in an Effort_ALL property, either per file or globally:

#+PROPERTY: Effort_ALL 0 0:10 0:30 1:00 2:00 3:00 4:00 6:00
#+COLUMNS: %40ITEM(Task) %17Effort(Estimated Effort){:} %CLOCKSUM
(setq org-global-properties
      '(("Effort_ALL" . "0 0:10 0:30 1:00 2:00 3:00 4:00 6:00")))
(setq org-columns-default-format
      "%40ITEM(Task) %17Effort(Estimated Effort){:} %CLOCKSUM")

The #+COLUMNS: line is for column view, a table-like overlay of properties on top of the outline, described in Tags, Properties and Column View. With this format, column view shows each task’s estimate, sums the estimates up the hierarchy (the {:} operator), and puts the clocked time next to it. In column view, S-LEFT and S-RIGHT cycle through the allowed values, which makes estimating a whole project a matter of a few keystrokes.

Using estimates in planning

When a clocked task has an estimate, the mode line shows the clocked time against it, so you notice when you exceed the plan while you are still working. In the agenda, column view sums the estimates of each day, and org-agenda-columns-add-appointments-to-effort-sum adds timed appointments to that sum, giving a picture of how much of the day is already committed. The agenda can also filter entries by effort with _ (org-agenda-filter-by-effort), for example to show only tasks that fit into the 30 minutes before a meeting.

The clock table with :properties ("Effort") shown earlier closes the loop. A habit of comparing the 2 columns during a weekly review (see Putting It Together) improves estimates faster than any rule of thumb.

Timers

Sometimes you need to measure time without assigning it to a task. Org provides 2 timers: a relative timer that counts up from zero and a countdown timer that counts down from a given duration. Neither writes CLOCK lines.

The relative timer

The relative timer is designed for notes taken while something unfolds: a meeting, a recorded talk, an incident review. Each note is stamped with the elapsed time, so you can later find the corresponding point in a recording.

KeyCommandPurpose
C-c C-x 0org-timer-startStart or reset the timer at 0. With C-u, start from an offset.
C-c C-x .org-timerInsert the current timer value.
C-c C-x -org-timer-itemInsert a list item stamped with the timer value.
M-RETorg-insert-headingIn a timer list, insert the next stamped item.
C-c C-x ,org-timer-pause-or-continuePause or resume.
C-c C-x _org-timer-stopStop the timer and remove it from the mode line.

A batch run that started the timer at 15:00 and inserted items 5 seconds, 5 minutes 17 seconds and 20 minutes 22 seconds later produced:

* Notes from the incident review
- 0:00:05 :: Timeline walkthrough begins
- 0:05:17 :: Root cause: expired credentials in the job runner
- 0:20:22 :: Action items assigned

The items are description list items (see Document Structure). If you started the timer too late, mark the region and use C-u C-u C-c C-x 0 to shift all timer values in it by a fixed amount. After a break, C-u C-c C-x 0 asks for a starting offset and proposes the timer value at point, so you can continue your notes from where you stopped.

The countdown timer

C-c C-x ; (org-timer-set-timer) asks for a duration and starts a countdown; the default duration comes from org-timer-default-timer, and a numeric prefix argument overrides it. In the agenda, the same command is on ;. When the countdown ends, Org shows a notification and runs org-timer-done-hook. Pause, resume and stop work with the same keys as for the relative timer.

A countdown is useful for time-boxed work: set it to 25 minutes, clock in on the task you want to focus on, and stop both when the timer rings. The clock records the work; the timer only tells you when to stop.

Putting the pieces together

The features in this chapter support a simple daily routine:

  1. In the morning, look at the agenda with column view to check that the estimates of the day’s tasks fit the available time.
  2. Clock in on each task as you start it; switching tasks is a single clock-in.
  3. Let idle detection and automatic clock-out catch interruptions and forgotten clocks.
  4. At the end of the week, update a clock table with :block lastweek, :properties ("Effort") and, if you work for several clients, one table per :match.

The data stays in your files as plain text, so the same records can feed an invoice, a retrospective, or a correction of next month’s estimates.

Further reading