Before learning about yantar92's tip, I used a hackier solution (gist):

• Fetch the repeater using text properties associated with the agenda entry.
• Use org-agenda-finalize-hook, which runs after the agenda view is built but before it is displayed, to insert the repeater string.

Prior to that, I tried another solution using column view (M-x org-agenda-columns). This method involves setting the :COLUMNS: property to display the SCHEDULED date as a separate column.

(setq org-columns-default-format-for-agenda
      "%TODO %PRIORITY(Pri) %60ITEM(Task) %SCHEDULED")

While this approach works and is built-in, the resulting display is verbose and difficult to parse visually. This led me to seek a better solution with custom Elisp.

"Projects" and "Areas" are inherited from GTD. "Distinguish Project and Area" is a common challenge for GTD and PARA adopters, including me. I once had many unimportant projects without deadlines that cluttered my agenda. There are many discussions and articles on it¹ and the model answer is to check (1) the nature of the task and (2) if there is a deadline.

• A project has (1) a specific outcome/goal and (2) a deadline.
• An area has (1) a standard to be maintained that (2) is continuous over time.

In addition to the model answer, I have my interpretation,

• Projects contain the tasks I should focus on (because of the importance, urgency and desirability). They have higher priority over the other categories. I work on them first, especially when there is a chunk of uninterrupted time or my energy level is high. If a "project" does not come with a deadline, I set one for it.
• Areas contain the tasks I have to do. I reserve some time for these tasks every day to keep areas maintained. I can also skip them for a while when the current projects are too demanding.
• Resources contain the tasks I am interested to do. When there is no pressure from projects or areas, I can choose to work on these tasks or simply take a rest.

These three questions help decide which PARA categories a task should go to:

1. Does it require my focus within a timeframe? If yes, make it a project.
2. Is it something I have to do? If yes, move it to an area
3. Is it something I want to do? If yes, move it to a resource.

On one hand, I organize my tasks. On the other hand, I know it is not necessary to get it perfect.

Firstly, it takes a lot of effort. I move forward and do the actual work when the tasks are by-and-large in the right places that help to prioritize. The end goal should be the actual outcomes instead of organizing.

Secondly, it is impossible. PARA is a system of single classification. Everything is either a project, an area, or a resource. In practice, a task or note can fall into multiple projects, areas, or interests. For example, "planning a trip for the 10-th anniversary" could arguably belong to either area "spouse" or area "travel".

Organizing should be forgiving. It is okay to organize wrongly as long as it works. PARA is not a system for perfectionism but for pragmatism.

Let's talk about my implementation!

I use tags for the actual areas and resources. I assign each of them a specific tag to the corresponding subheadings. This gives me a set of controlled vocabularies for tagging projects and notes. For example, I know I should use writing instead of write or blogging for area "writing". I don't create tags for projects (which are short-term and grow over time) to keep my tag set small and useful².

I use categories for the PARA top categories, Project-Area-Resource. When looking at my org agenda view, I immediately know which tasks are my top focuses (Project), which are things I need to do (Area) or interested to do (Resource). I also know which exact area or resource they belong to with the tags on the right.

Tip: I can filter tasks by category and tag by pressing / (M-x org-agenda-filter) and clear filters with | (M-x org-agenda-filter-remove-all).

For project notes, I add or link them directly under the corresponding org subtree in todo.org as I avoid adding project tags. When a project is completed or canceled, I convert the reusable part into the area or resource notes, and archive the project subtree to todo.org_archive.

I place the areas and resources notes under ~/note. I tag them with the tags defined in todo.org and reserve the directory hierarchy³ for the note types. This gives me the flexibility to have multiple tags for a note.

Here is a simplified version of my org directory:

org
├─ todo.org
└─ note
   ├─ 20221125T211904--org-attach__emacs.org
   ├─ ...
   ├─ meta
   │  ├─ ...
   │  └─ 20200202T222222--using-org-mode__emacs.org
   └─ reference
      ├─ article
      │  ├─ ...
      │  └─ 20221226T150449--creating-family-rules__parenting.org
      └─ book
         ├─ ...
         └─ 20220907T134123--building-a-second-brain-tiago-forte__pkm.org

• note/20221125T211904--org-attach__emacs.org is a regular note.
• note/meta/20200202T222222--using-org-mode__emacs.org is a meta note that connects other notes, like the org-attach__eamcs.org above.
• note/reference/article/20221226T150449--creating-family-rules__parenting.org is a reference note for the article "Creating Family Rules", tagged with my resource "parenting".
• note/reference/book/20220907T134123--building-a-second-brain-tiago-forte__pkm.org is a new book note for the book "Building a Second Brain" by Tiago Forte.

So far, I don't archive notes under ~/note. If I need to, I might use the tag ARCHIVED and write some elisp to filter them.

Denote uses the timestamp in its file-naming scheme as the identifier and uses its link type denote: for linking. This approach allows notes to be taken in other formats (.md and .txt).

Org-roam uses the ID properties as the identifier and the built-in link type id: for linking. It sticks with the Org-mode ecosystem. It utilizes an external database to indexes note metadata, like titles, tags, and locations and searching notes efficiently without parsing any org files. When working on multiple computers, the user might need to re-index the org files.

This is the biggest architectural difference between Denote and Org-roam. If all notes are written in Org-mode, I find Org-roam provides cleaner org files because it does not introduce a new link type.

Denote works for all files. Not only can the user take notes in Org-mode, Markdown, or Txt, but also name a PDF file so that it could be identified, linked, searched and tagged.

Org-roam works for only Org-mode files. It leverages the mature Org-mode ecosystem. For example, the user can use org-attach to associate a PDF file with a note.

Frankly speaking, Denote is designed for Emacs users. Org-roam is designed for Org-mode users.

In a file-based note system, it is inevitable to have coupling between the filename and the content (e.g., keeping #+TITLE: and file name in Org-mode).

Denote answers with its file-naming scheme and need to keep filename consistent and update-to-date so that search results remain valid after changing title or tags. Maintaining the naming scheme could become a burden without any automation. Denote provides denote-rename-* and denote-dired-rename-* for the job.

Org-roam does not enforce any file-naming scheme. The default org-roam-capture-templates uses the creation timestamp and title slug as the filename, and that is all.

Note that the Denote file-naming scheme has a limitation: cannot define a tag with multiple words. For example, the tag "note-taking" becomes two tags "note" and "taking" unless combining them to "notetaking".

Utilizing its file-naming scheme, Denote can efficiently search for a note by filename without parsing the content of the file. Users can search notes with titles and tags by prefix - and _ respectively. The out-of-the-box experience does not fit my need. Users need to write some emacs lisp or learn Dired to search efficiently.

Org-roam provides better out-of-the-box searching experience. With a little customization, I can search notes by folder name, title, and tags, recursively across sub-folders, sorted by the last modification time. This suits most of my needs.

It is nice to eradicate the dependency on a database with Denote. However, I found it hard to replicate the Org-roam searching experience with Denote, especially sorting notes by last modification time within subdirectories. Note that full-text search could be achieved by counsel-rg for both.

• No database is needed. Seamless across multiple machines.
• A simple but powerful file-naming scheme that works for all files.
• Allow notes in other formats (txt, md). (Not for me. All my notes are in org.)

• Uses non-standard link type denote:.
• Worse out-of-the-box searching experience. (I believe it is hackable)
• Tag with multiple words like "note-taking" becomes "note" and "taking"

My first attempt was using Nextcloud's WebDAV, after searching "Syncthing WebDAV" and found this story.

I added the Syncthing's local folder to Nextcloud via external storage so it could be accessed from WebDAV. It worked. It proved that Syncthing with WebDAV is a viable solution.

However, Nextcloud is too heavy for my Raspberry Pi 3. The latency is high enough to degrade the mobile experience. This could be a good solution for existing Nextcloud users with a faster hosting machine.

Since my Raspberry Pi is already using Caddy as the web server, why not give Caddy's WebDAV a shot? Caddy is written in Go and should have better performance.

The WebDAV module was not built-in and I need to built a new Caddy binary with xcaddy. Then, I updated the systemd service to run as the same user as syncthing to get the file permission right.

It worked and indeed ran so much faster. I am satisfied!

Here is the snippet from my Caddyfile WebDAV config.

my.webdav.host {

    basicauth * {
        <user> <hash>
    }

    root * /path/to/webdav

    @get method GET
    route {
        file_server @get {
            hide .git .gitignore .stfolder .stversions
            browse
        }

        webdav
    }
}

I reduce the fsWatcherDelayS from 10s to 1s in all instances. This makes the synchronization happens more instantly and seamlessly between devices. For example, when I make a change on the phone, it updates the Raspberry Pi and synchronizes across other computers in a second.

When waking up from sleep, Syncthing can take quite a while to recover the connection.

Syncthing used to provide an option called restartOnWakeup to restart Syncthing on wakeup and avoid this long delay. However, this option has been removed in 2022. I replicated this behavior myself, by writing a script to restart Syncthing, and running it on wake up.

Not every task should go into the system. Avoid filling the system with bullshits and diluting the things that matter. I only add tasks that I really want or need to do.

To clarify¹, the task management system described below is not the "inbox" in GTD. I still capture things into my inbox but not all of them will be converted to a task in the task management system (org agenda files) eventually.

There are two reasons for this. First, tasks could be deprioritized or even unnecessary. Second, we have limited time and cannot do everything. We should have an opinion on the priority.

Open loops are tasks that have been started but not finished. They stay in our minds and occupy some of our limited working memory so that we cannot focus on another task we are working on.

Also, open loops reduce agility, according to Little's Law. The more the open loops, the longer time to finish each of them on average.

The system should suggest to the user what to do next so that the user can reserve the will power to the real task. This also avoids skipping hard tasks with easy tasks unconsciously.

I use as few TODO keywords as possible but not too few. For example, it is common to use only two states ("TODO" and "DONE") but this does not align with the principles I mentioned above. I need a state for "open loops" so that I can keep the number of them small. I also need to distinguish a smaller set of "next actions" from all tasks.

So far, I defined these five keywords:

This diagram illustrates the transition of those states.

                                 +------+
                                 | INTR |
                                 +------+
                                    |
                                    v
+------+   +------+   +------+   +------+
| TODO |-->| NEXT |-->| PROG |-->| DONE |
+------+   +------+   +------+   +------+

In the past, I tended to set a date for all tasks. If I want to do A, B, and C on Monday, then I schedule them for Monday. This sounds intuitive but, in reality, I ended up rescheduling many incompleted tasks at the end of every day. It was not only wasting time but also depressing.

Later, I changed to rely more on the TODO keywords. For example, if a task is still in progress, I keep the state unchanged as PROG instead of rescheduling it every day until it is done. I am now using the "scheduled date" to hide a task until the date I should look at it again. Similar to the snooze feature in Gmail.

For example, when a PROG task is being blocked, I set the SCHEDULED date to hide it until the date I want to revisit. On the scheduled date, if the task is unblocked, I will remove the SCHEDULED date. If the task is still blocked, I reschedule it again. It acts as the waiting for list in GTD.

At the beginning of the day, I review the tasks that are scheduled for today. The goal here is not to finish them, but to update or remove the scheduled date so that there is nothing left.

1. If the task is still blocked, reschedule it
2. If the task could be done in a few minutes, then do it and mark it as DONE.
3. Otherwise, remove the scheduled date and optionally update the TODO keywords.

Removing the scheduled date is the best outcome. It indicates the previous estimation was correct, at least not too early. Rescheduling indicates the previous estimation is inaccurate. I would avoid rescheduling the task to tomorrow indiscriminately and try to make a good estimation to reduce the number of rescheduling.

After reviewing all tasks scheduled for today, it is time to pick a task and do some real works. This step is straight-forward with the customized agenda view above.

1. Pick an INTR task if there is any.
2. If there is no INTR task, then pick a PROG task and work on it. If that task is blocked, set a SCHEDULED date to hide it.
3. If there is no INTR and PROG task, then start a NEXT task.
4. If there is no task in the agenda view, then review the TODO tasks and convert some to NEXT.

The secret of having a system that works in the long-term is regular maintenance. I do it at least once a week. For examples,

• Promote some tasks from TODO to NEXT. Demote or even delete deprioritized tasks.
• Review the journal and add TODO if something needs follow-up.
• Archive completed tasks and extract to permanent notes².

Evernote has a reminder feature for simple task management, which is already enough for me. Since it is a note-taking app, I can add rich context like images or even audio seamlessly. Tusk makes it usabe on Linux and the official Android app is simply awesome. Synchronization works out-of-the-box.

However, it fails on the privacy bit.

Org-mode is for keeping notes, maintaining TODO lists, planning projects, and authoring documents with a fast and effective plain-text system. It is absolutely capable.

However, the learning curve of Org-mode is steep and even steeper for non-Emacs users. Users are expected to read documentation and practice. Once familiarized with Emacs, its usability on Linux will jump from 0 to 5 (or even infinity). The Android client Orgzly is usable but could be better. Synchronization works with SyncThing.

Joplin and Standard Note are both strong note-taking alternatives to Evernote. However, they suck in task management because they simply cannot show all tasks scheduled for today. They both have a decent desktop app written in Electron. Synchronization works natively and users can turn on end-to-end encryption for privacy/security.

If task management is not a requirement, both Joplin and Standard Note are very good alternatives.

Taskwarrior and TODO.txt are both FOSS for task management. However, they both allow only one line per task, which makes adding extra context to the task very hard. Their clients are barely usable to me (or I have not learned enough). Secure synchronization works with a self-hosted server or with SyncThing for Taskwarrior and TODO.txt respectively.

TiddlyWiki is a "non-linear personal web notebook". It looks fancy but I haven't tried it intensively because Org-mode seems working for me already at this point. I will leave it as a question mark.