notes-organization-old-organizEtdDesignOld asof 220115

TODO

DONE(d)
NIX(x)
    ASSIGN(a) DELEG(g) LOOK(l) RELY(y)
    WAIT(w) BLOCK(b) PAUSE(z) REQUIRE(q) | HOLD(h)
    ROADMAP(m) READY(r) CHECK(c) FINISH(f) BOOKED(o)
    STEW(s) FOLLOWUP(u) REVIEW(v)
  - can mb remove the 'microactions' like STEW FOLLOWUP REVIEW LOOK, and maybe ASSIGN, for example
    - mb CHECK, FINISH, except that CHECK is higher priority than WIP (and WIP should be higher priority than READY), so there is some semantics to CHECK (and same goes for FINISH, which is even higher priority than CHECK, although i'm not sure if we need both CHECK and FINISH); otoh the same goes for WIP vs READY, so maybe that's enuf
    - also FOLLOWUP is different from WAIT in that it is actionable; could just create a new task for the followup but would be more convenient to have a FOLLOWUP status
  - is importance or urgency or some combination one of the 4 dimensions? No, they are ortho to the TODO statuses (even though they are also trinary)
  - similarly, "when" ("scheduled") dates, due dates are, like imp urg, 'planning' attributes that are not one of the 4 dims
  - should map out the todo states (which ones are subsets of each other), and for each one, give its attributes on the 4 dims
  - so what are the 4 dims? i think 3 of them are: completion/openness, activity (stop or go), actionability (or more generally, what you/the system have to do next)/needs attention. Not sure what #4 is?:
    - committment/defineness (could would/toconsider should will must? or something trinary encompassing these)? or, related,
    - firmness (eg is 'scheduled' a reminder or a when date? is the due date a hard deadline? when we say this is a TODO, does that mean we have selected/committed to it/we definitely (or close to that) want to do it?)
    - trackedness (tracked/untracked/later)?
    - needs attention?

NEW: not started

IDEA: not startedTODO: not startedWIP: started, ready, actionable, tracked DONE: done, n/a, n/a, n/a NIX: done::nix DELEG: started?, go?, not actionable, tracked RELY: started?, go?, not actionable, later? untracked? WAIT: any open, stop, not actionable? or is it needs attention b/c followup?, tracked BLOCK: any open, stop, actionable?, tracked or later PAUSE: any open, stop, not actionable, tracked or later REQUIRE: any open, stop, not actionable, later HOLD: any open, stop, not sure about actionable?, untracked ROADMAP: not startedREADY: not started, actionable, tracked? (NEXT?: not started, actionable, tracked?) CHECK?: started, actionable, tracked BOOKED: not started
started (any open), any activity, actionable, tracked
started (any open), go, actionable?, untracked
started (any open), any activity (eg dep, ready), actionable?, tracked
started (any open), not actionable? (not READY), tracked? later?
started (any open), not actionable and doesn't need attention, tracked?

a lot of question marks there, suggesting that the choice of 4 dims either isn't quite right yet, or aren't formalized enuf yet

roadmap, must

Feature summary list

Core data structures

Area data structure

Item data structure

TaskTemplate (subclass of Item)

RecurringTask (subclass of TaskTemplate)

Task data structure (subclass of TaskTemplate)

Computed properties:

NOTE:

Note data structure (subclass of Item)

Heading data structure

Computed property:

Person

User

Group

CalendarEvent

todo

calendar events have a project field, etc (mb they are even a subtype of task, or maybe both tasks and events share a superclass?)

Eras of time (timeEra)

Time eras are represented as integers using the following enumeration/convention:

1=today 2=tomorrow 3=next_few_days 4=week 5=next_few_weeks 6=month 7=quarter 8=year 9=someday 0=nil. In the UI the "0" key is used to assign this.

A floating point number in between two eras is treated as falling in the next higher era (eg 1.5 is in the 'tomorrow' era)

Most eras are subsets of each other: (today or tomorrow) \subseteq few_days \subseteq week \subseteq few_weeks \subseteq month \subseteq quarter \subseteq year \subseteq forever

Eras of sequence (seqEra)

Used for sprint-like ordering/classification

1=now/current 2=next few 3=current sprint 4=next sprint 5=near/soon 6=planned to do sometime 9=not planned yet/idea 0=nil

hierarchy:

 9unplanned  8planned  
                |
          4current,5next,6second,7near
            |
          1now,3nextfew
                  |
               2next

taskType

0=nil/ordinary 1=tosay 2=todg 3=chore 4=quick/anytime 5=errand 6=call/mtng 7=physical 8=atcomputer 9=meta

Questions

statuses

task completion statuses:

task what-do-I-need-to-do-with-it statuses:

task state-of-organizational-system statuses:

(um, no, e.g. CHECKING is a completion status, not an organizational system status)

does delegation go in what-do-I-need-to-do-with-it or state-of-organizational-system statuses?

task health statuses (and their colors): - healthy: green - minor_problems: yellow - major_problems: red - waiting/paused: blue

old note: statuses can have substatuses (eg. todo can be 'todo' vs 'soon', done can be replaced by 'done' vs 'cancelled' vs 'hold', so in total we can have active/todo, active/soon, inactive/done, inactive/cancelled, inactive/hold)

ideas for smaller group of statuses:

see gumroad roadmap: https://www.notion.so/Roadmap-ce2ad07c483046e7941227ad7810730d

mb "roadmap" instead of "planned"?

now ondeck soon anytime later someday

task completion status ideas: TODO/WIP/PAUSED/DONE TODO: NEW/IDEA/ROADMAP/PLANNED/READY/NEXT WIP: WIP/CHECKING/FINALIZING/REVIEWING/DONE

INACTIVE/ACTIVE/DONE

i guess WAIT is a what-do-I-need-to-do-with-it status, whereas HOLD is a task completion status

does the TRACKED/UNTRACKED/LATER/ZZZ stuff go here too? mb. that sounds like state-of-organizational-system stuff.

does WHEN stuff go here eg SOON, NEAR? No, scheduling is not status. Except that NEXT might be a state-of-organizational-system status. PENDING might be a state-of-organizational-system status, or a task completion status.

so here's some ideas: task completion statuses: TODO/DOING/DONE/HOLD TODO:IDEA/ROADMAP DOING:PLAN/STARTED/CHECK/FINAL DONE: DONE/DEAD

should PEND, BLOCK, HOLD be in task completion statuses? How about HALFway done?

i guess one way to think about is the task completion status is what a third party would want to see to see how a task is progressing. That would suggest, though, they you would want health stuff like BLOCK, HOLD, although from another perspective that seems ortho.

i guess another way to think about it is to write the agenda views that i want, and then redo the statuses to make them clearer.

task what-do-I-need-to-do-with-it statuses: READY/PEND/WAIT/BLOCK/TODG/DG

task state-of-organizational-system statuses: NEW/UNTRACKED/LATER/TRACKED/TODG/NEXT/RELY/REVIEW

or should DG be state-of-organizational-system statuses?

mb what-do-I-need-to-do-with-it statuses should just be READY/NOTREADY. Although maybe IDEA/ROADMAP is also a what-do-I-need-to-do-with-it concept.

and actually, DONE is a subtype of CLOSED (NIX is a potential sibling)

WAIT PAUSE PARK STALL STOP

ok, i'm a little lost there. What do i need the statuses to do, and what was wrong with the way i was doing them before? what do i need them to do:

what was wrong:

so mb WAIT vs DG are actually separate/ortho from each other

so maybe the three things are:

should "snooze/defer" be a status?

my current setup has: NEW(n) IDEA(i) TODO(t) NEXT(x) PLAN(p) DO(d) BLOC(b) SET(s) SOON(o) GO(g) WIP(w) VERI(v)

other tags: WAIT STEW DG TODG WARN IMPORTANT URGENT QUICK LOOM DEC KEY MUST
LATER(l) MAYBE(m) RELY(r) DONE(e) HOLD(h) NOPE(-) CANT(c) OSCOPE(0) REF(r)

some flaws with that:

current ideas:

statuses before the

are open, after are closed.

task completion: IDEA TODO WIP

substates of TODO task completion: ROADMAP PLAN READY NEXT substates of WIP task completion: GREEN YELLOW RED CHECK FINISH what you have to do: NEW TRACK REVIEW delegation: TODG DELEG FOLLOWUP stop or go: WAIT PAUSE BLOCK DEP STEW
DONE NIX
LATER RELY UNTRACK
RELY
HOLD

what these mean: task completion: IDEA TODO WIP

DONE NIX
  task completion means how close the task is to being done
  IDEA is an idea for a task that you haven't decided whether to do or not
  TODO is a task that you want to do but haven't done yet
  WIP is a task that is being working on
  DONE is a task that has been completed
  NIX is a task that has not been completed and is no longer planned to be done

substates of TODO task completion: ROADMAP BOOKED PLAN READY NEXT ROADMAP means that you are planning to do this task at some point BOOKED is a task that is not yet WIP but that we don't need to worry about finding time for because it has been scheduled/planned/delegated/booked PLAN means that you need to plan out how/when to do this READY means the task is ready to be done NEXT means that this task has been selected, possibly among some others, to be done "next", although multiple tasks can be in NEXT at once.

should BOOKED be a closed state? Alternately we need another distinction between TODOs that need attention, and BOOKED which does not. Should BOOKED be moved into 'what you have to do'?

we could extend the semantics of the

to mean any sort of distinction, then we get:

substates of TODO task completion: ROADMAP PLAN READY NEXT

BOOKED
  ROADMAP means that you are planning to do this task at some point
  PLAN means that you need to plan out how/when to do this
  READY means the task is ready to be done
  NEXT means that this task has been selected, possibly among some others, to be done "next", although multiple tasks can be in NEXT at once.
  BOOKED is a task that is not yet WIP but that we don't need to worry about finding time for because it has been scheduled/planned/delegated/bookedwhere the 
means things that need attention, vs things that dont

substates of WIP task completion: GREEN YELLOW RED CHECK FINISH GREEN means the task is coming along as planned YELLOW means there are some minor issues RED means there are major problems; the task requires major attention, and/or the task may not complete as planned and/or may be very late CHECK means that it is thought that the task is complete, but it still needs to be tested/double-checked/verified/approved by stakeholders FINISH means that the task is complete except for some finishing stuff (e.g. releasing to production, billing the client, etc)

delegation: TODG DELEG LOOK

RELY
  TODG means you need to delegate this task
  DELEG means the task has been delegated, but you still need to keep an eye on it
  LOOK means the delegee says the task is done, and you need to take a look, and maybe send it on
  RELY means the task has been delegated, and you can rely on the delegee to do it without you keeping an eye on it, unless something extraordinary happens (e.g. if the delegee quits)where the 
means things that need attention, vs things that dont

what you have to do: NEW TRACK DO STEW DEC FOLLOWUP REVIEW

LATER UNTRACK
  NEW means the task is new to the system and may still need to be described/prioritized/categorized/scheduled/triaged
  TRACK means you need to keep an eye on the task, and maybe plan when to do it
  DO means you need to do the task
  STEW means that you need to mull something over before continuing
  DEC means that you need to decide something
  FOLLOWUP means you need to follow up with someone
  REVIEW means the task is closed except you should do a personal retrospective on it
  LATER means that task is for a later phase of the project, and doesn't need to be tracked right now, although it probably will be tracked later
  UNTRACK means that the task is not being 'tracked', for example, someday/maybe taskswhere the 
means things that need attention, vs things that dont

stop or go: GO STOP

HOLD
  GO means that the task can proceed (if someone does it)
  STOP means the task is being stopped by something
  HOLD means the task was put on hold, and does not need to be paid attention to unless and until is it taken off hold    here, the 
still means open/closed

substatuses of stop: WAIT BLOCK

PAUSE DEP
  WAIT means the task is waiting for someone to get back to you, and may require followup
  PAUSE means the task is waiting for time to pass or for some external event or condition to occur
  BLOCK means the task has encountered some problem halting progress that needs attention
  DEP means the task is waiting for another task to be completed before it progresses (maybe this should be PENDing?)where the 
means things that need attention, vs things that dont (except to check if the condition is satisfied yet)

now, which of these are mutually exclusive? If a bunch are mutually exclusive, then we can make them the orgmode 'TODO states'. Let's start with task completion. These can be combined with the substates of TODO and substates of WIP. They cannot be combined with delegation, because a task can be delegated before it is started or after. They probably can't be combined with 'what you have to do', b/c eg a task can be RED or GREEN, although here i'm not sure, and maybe RED YELLOW GREEN could be eliminated instead. I should think about this more.

STOP can't exactly be combined with task completion but it almost can; we just want to store the task status in a tag when it goes into STOP and then restore it later.

i think maybe we should split out the RED GREEN YELLOW.

maybe think about combining them like this: You sit down at your computer after going on vacation for two weeks, and need your memory refreshed about where things are at. As each task comes up, you think, "Oh yeah, that stupid thing. So where's this *#$*@! task at? And what do i need to do about it?". If any of these can answer those questions best, maybe they should be orgmode TODO states, even if they are logically ortho to task completion.

IDEA TODO WIP

ROADMAP PLAN READY NEXT GREEN YELLOW RED CHECK FINISH? Yes, but we're taking out GREEN YELLOW RED, as per above. TODG DELEG LOOK NEW TRACK DO STEW DEC FOLLOWUP REVIEW GO STOP
DONE NIX? Yes, all of those.
BOOKED? Yes, all of those.
RELY? Yes
LATER UNTRACK? Some of them (NEW STEW DEC FOLLOWUP REVIEW); TRACK may not belong here, and maybe not LATER or UNTRACK either.
HOLD: HOLD and maybe STOP

So, revised proposal:

completion: IDEA TODO WIP

TODO: ROADMAP PLAN READY NEXT WIP: DO CHECK FINISH Delegation: TODG DELEG LOOK What you have to do: NEW STEW DEC FOLLOWUP REVIEW Stopping: WAIT BLOCK
DONE NIX
BOOKED
RELY
PAUSE DEP HOLD

That's 27 states! One too many for the 26 letters of the Latin alphabet! So maybe remove one of those. Maybe DO, b/c DO has the same semantics as its parent, WIP. So:

completion: IDEA TODO WIP

TODO: ROADMAP PLAN READY NEXT WIP: CHECK FINISH Delegation: TODG DELEG LOOK What you have to do: NEW STEW DEC FOLLOWUP REVIEW Stopping: WAIT BLOCK
DONE NIX
BOOKED
RELY
PAUSE DEP HOLD

and ortho to all of those: TRACKED

LATER UNTRACKED

mb change TODG to ASSIGN because none of the tohers start with A, but TODO starts with T.

alphabetically: ASSIGN BOOKED BLOCK CHECK DONE DEP DEC E FOLLOWUP FINISH deleG HOLD IDEA J K LOOK roadMap NEXT NEW NIX O PLAN PAUSE Q READY RELY STEW TODO U reView WIP WAIT X Y Z

OK rename DEP to reQuire. paUse. niX. relY. bOoked. DEC = STEW. NEXT can be/should be a tag rather than a status (TODO make NEXT a tag)

Now we have: alphabetically: ASSIGN BLOCK CHECK DONE E FINISH deleG HOLD IDEA J K LOOK roadMap New bOoked PLAN reQuire READY (could also be E) STEW TODO followUp reView WAIT WIP niX relY Z (pause)

so what should WIP be renamed/what letter should WIP be assigned to? Honestly PLAN may not need to be a status. We can always make separate tasks to plan things. So:

ASSIGN BLOCK CHECK DONE E FINISH deleG HOLD IDEA J K LOOK roadMap New bOoked wiP reQuire READY STEW TODO followUp reView WAIT niX relY Z (pause)

so right now we have: NEW(n) IDEA(i) TODO(t) WIP(p)

ASSIGN(a) DELEG(g) LOOK(l) RELY(y) WAIT(w) BLOCK(b) PAUSE(z) REQUIRE(q)ROADMAP(m) READY(r) CHECK(c) FINISH(f) BOOKED(o) STEW(s) FOLLOWUP(u) REVIEW(v)
DONE(d)
NIX(x)
HOLD(h)

NEW conceptually belongs with STEW(s) FOLLOWUP(u) REVIEW(v) RELY BOOKED PAUSE REQUIRE REVIEW are open statuses that don't require attention

most common are probably: NEW(n) IDEA(i) TODO(t) WIP(p) WAIT(w) ASSIGN(a) DELEG(g)

maybe make those the first line (as long as there's a toplevel keybinding to go directly to DONE; otherwise probably want just NEW IDEA TODO DONE) (NEW is in here so that you can start on NEW and cycle to IDEA easily) (maybe dont have NIX there, i'm not sure)
DONE(d) NIX(x)

and ortho to all of those: TRACKED

and ortho to all of those: NEXT
LATER UNTRACKED

should we introduce STOP so that we have something like WAIT that generalizes WAIT BLOCK PAUSE REQUIRE that can go in the 'most common'?

and right now we have properties additional properties: completion, tracking, inMotion, isNext, health and computed properties attentionRequired, isOpen, isReady NEW STEW FOLLOWUP REVIEW can just be tags (or just todo states that act in place of tags). STEW FOLLOWUP REVIEW can be named something like 'microactions' or stdActions or something

maybe LATER is just a negative attentionRequired tag, rather than isTracking, and isTracking is a bool maybe we have: nexts \subseteq actionable \subseteq attentionReqd \subseteq tracked well not quite b/c you have have actionable untracked things -- but it's true that if something is both tracked and attentionReqd then there's something about that. Also the name attentionReqd is misleading because if it's low-priority and untracked you don't want to pay attention to it even when it is in an attentionReqd state.

someone else's: (setq org-todo-keywords (quote ((sequence "TODO(t)" "NEXT(n)" "

" "DONE(d)")
              (sequence "WAITING(w@/!)" "HOLD(h@/!)" "|" "CANCELLED(c@/!)" "PHONE" "MEETING"))))

hmm mb get rid of the following as a separate data item (altho keep it conceptually): TRACKED

and instead compute that based on IDEA being UNTRACKED, LATER being a new status, and everything else being TRACKED? Well, that loses the ortho of having eg an untracked task be WIP. Hmm..
LATER UNTRACKED

mb get rid of LOOK; just call it CHECK. How are we distinguishing b/t us checking and someone else checking? Maybe someone else checking is a WAIT?

why_nix: NOPE(-) CANT(c) WONT GAVEUP SKIP MISSED OSCOPE(0) DUP(r) CANCEL DELETE NOPE means someone decided they didn't want this to be done CANT means the task seems to not be feasible WONT means the task seems to contradict a design constraint or goal GAVEUP means we encountered difficulty and gave up SKIP means this task was skipped due to deprioritization MISSED means we missed our opportunity to do this OSCOPE means the task was decided to be out-of-scope DUP means the task has been merged into another CANCEL means that whoever desired/asked for the task changed their mind/unasked for it DELETE means that the task was deleted from this system for some reason

Internal planning as in how are we going to do this and X ternal planning as in how does this fit into the larger plan . Either of those can be in the plannING stage or plantnED.

booked description: You can have things scheduled for a certain day or you can just have things that are "Scheduled " Meaning that they are in some ordering or dependency chart or that someone else is responsible for them

One way to look at primary Task status is: whatever the kanban columns, should be?

(i mainly put requested not bc its a good state but bc it has a good abbrev: req)

Perspectives

need places to put:

different tools for wip project management task backlog personal productivity

(C) backlog vs (workspace?) (see the connection to kanban inventory, wpietri sp big board; limit number of WIP). active vs waiting-on and followups. daily workspace? weekly, monthly too? different tools for: personal workspace (todo list); project management (other ppls tasks eg constructionproj; planning/scheduling far out -- tasks that are 'snoozed' and reappear later; also team task management); backlog (dealing with urgent tasks that will appear later; remembering midpriority should-dos and somedaymaybes and important but not urgents)

functions of organizational systems:

to put another way, systems for:

i might divide this into:

"someday" todos "anytime" todos

Use cases

some key activities include:

Need solution for

Situations and their solutions

Approaches

stuff to think about

some of my immediate use cases include:

other ppl keep it pretty simple. Eg some of them only have two gradations of importance (normal and high), some work mostly out of things 3's inbox or today view, some treat 'today' as meaning 'this week' and only plan for this week, etc. They don't care about status ontologies, they focus on just having a list in each project of tasks they thought of, and then assigning some of those tasks to nearby epochs.

idea: since it's easy to go to the beginning or end of text files, use both ends. E.g. prioritized todos at the top, 'brainstorm' todos at the bottom. Or short term at the top, long term at the bottom. Or urgent at the bottom, important at the top. Or active todo at the top, waiting-on at the bottom. Or tasks at the top, notes at the bottom.

Features

readable plaintext exports

can export only a part/subset

also orgmode exports, todo.txt exports

chores

recurring 'chores'. These need to bubble up automatically.

custom colors

color tasks in various views according to custom filters, e.g. if the project and the task are important, then red, otherwise a different color per project

reviews

Reviews are recurring tasks (chores). Reviews are per-project, and different projects can have different review frequencies. Reviews inherit their project's importance.

Are the reviews in some sort of organiz/meta area, or are they in the project they refer to? I think they should be in the project they refer to. This assists in inheriting the project's importance.

You can also set reviews for Areas.

delegation

is my old system (DG, TOGD, @k, etc) good enuf or should i change it?

custom when types

in addition to time era and seq era, there can be other types of eras

potential features

next actions, stuck projects

Implementation architecture

some links:

https://www.reddit.com/r/orgmode/comments/iw0web/orgsuperagenda_function_to_group_project_with_its/ summary: https://github.com/alphapapa/org-super-agenda groups stuff. Customize with auto-outline-path or auto-parent or auto-map.

https://github.com/alphapapa/org-super-agenda

https://orgmode.org/worg/doc.html

"Each item occupies a single line. The line starts with a prefix that contains the category (see Categories) of the item and other important information. You can customize in which column tags are displayed through org-agenda-tags-column. You can also customize the prefix using the option org-agenda-prefix-format. This prefix is followed by a cleaned-up version of the outline headline associated with the item. " -- https://orgmode.org/manual/Presentation-and-Sorting.html

org-agenda-prefix-format to customize what is shown in each agenda line http://doc.endlessparentheses.com/Var/org-agenda-prefix-format.html org-agenda-hide-tags-regexp to not display certain tags org-agenda-remove-tags to hide all tags org-agenda-todo-keyword-format org-agenda-entry-text-exclude-regexps (setq org-agenda-entry-text-mode t) (setq org-agenda-entry-text-maxlines 5) org-agenda-entry-text-exclude-regexps

" (defun gg/entry-text-nix-empty-line () "Delete empty entry text lines in agenda" (goto-char (point-min)) (replace-regexp (concat "^ *" org-agenda-entry-text-leaders " *\n") ""))

(add-hook 'org-agenda-finalize-hook 'gg/entry-text-nix-empty-line) " -- https://emacs.stackexchange.com/questions/59546/getting-rid-of-plain-text-timestamp-entry-in-agenda-export

(http://sidebrain.sourceforge.net/ rec by a commentor in https://emacs.stackexchange.com/questions/51161/create-a-rabbit-hole-task-stack-that-can-be-pushed-popped )

" Try customizing org-agenda-prefix-format. This can be used to tweak how various kinds of items (including TODOs) are displayed in agenda views.

In particular, you can use %l in the todo format to prefix the item with a number of spaces corresponding to its level in the hierarchy." -- https://emacs.stackexchange.com/questions/5900/how-can-i-view-the-hierarchy-of-todo-keywords-in-org-agenda-mode

https://emacs.stackexchange.com/questions/14852/divider-lines-in-org-agenda

https://emacs.stackexchange.com/questions/5472/flexible-org-todo-dependencies

https://emacs.stackexchange.com/questions/tagged/org-agenda

org-agenda-filter-by-regexp https://orgmode.org/worg/doc.html read various hooks, search for org-agenda (so far i got about 25% through; to "org-agenda-list") https://karl-voit.at/2019/11/03/org-projects/ https://willschenk.com/articles/2021/sql_in_org_mode/ https://emacs.stackexchange.com/questions/63031/emacs-org-mode-custom-agenda-view-for-each-project https://emacs.stackexchange.com/questions/46882/custom-agenda-view-in-org-mode-grouping-per-month https://www.reddit.com/r/orgmode/comments/elacvo/orgsuperagenda_add_hierarchy_information_to/ https://orgmode.org/manual/Tag-Hierarchy.html https://orgmode.org/worg/org-glossary.html "Changing a TODO state can also trigger tag changes. See the docstring of the option org-todo-state-tags-triggers for details. " http://doc.norang.ca/org-mode.html https://orgmode.org/manual/index.html

could use CATEGORY to specify parent project

could mb implement my 'ortho' status facets using: https://orgmode.org/manual/Multiple-sets-in-one-file.html and org-todo-state-tags-triggers. That is, the TODO state is sort of a composite task status, and when you switch from one ortho dimension to another, org-todo-state-tags-triggers saves the value of the other one in a tag. The value in doing it this way rather than using separate properties/tags is:

org-fast-tag-selection-include-todo

various things can filter/trigger by level, so it may be good to have a fixed number of levels for areas and maybe for projects. What do we do for an empty subarea? Or do we just make the user make up areas for that? Or is the convention that it's the same name as the parent in that case (this could also be the home of catchall'd tasks that are in a parent area but not in any of its subareas)? Or could the convention be that it's the empty string in that case (would make area::subarea formatting simpler: "area::" for the catchall subarea)?

https://orgmode.org/manual/Stuck-projects.html

can agenda views recognize negation of a tag? Yes; using '!', see https://orgmode.org/manual/Matching-tags-and-properties.html. This could make tags triggered onto todo state change easier; otherwise for each ortho set of tax we would have needed to introduce a default, for instance not NOTDELEGATED

principle: want to be able to infer default ortho properties if they are not given. So maybe untracked should be a tag, and idea

lateruntracked means untracked, otherwise the default is tracked

https://orgmode.org/worg/org-tutorials/org-custom-agenda-commands.html org-agenda-entry-types

http://doc.norang.ca/org-mode.html shows how to define 'projects' as any item with subtasks, and then find stuck projects (projects without a NEXT action): http://doc.norang.ca/org-mode.html section http://doc.norang.ca/org-mode.html#TodoKeywordProjectTaskStates section 14.2 Project definition and finding stuck projects

UI

UI TODO

main screen: modular query spacebar to edit task (without leaving screen) enter to:

keys i toggles the IMPORTANCE>=1 seach filter on or off I sets a custom IMPORTANCE threshold

edit task mode: choices of key assignments (are consistent with the idea of / reflect the semantics of) keys in modular agenda view

i toggles the importance of the task between 0 and 1 I sets the importance to a custom number esc goes back to modular query mode

new task mode is just edit task mode

if the user doesn't enter a key for awhile, the key hints popup. ? goes to the key assignment help mode. F1 is like 'less' viewing the plaintext manual.

Some of the function keys switch to various preset queries.

On the sidebar is a few preset queries, and starred items, and a project browser.

keybindings: using cokemak layout, here's what we have to work with: (omitting keys like tab, backspace, enter, home, shift, which cannot easily be typed/shown as a single character):

`1234567890-= qwfpgjluy;[]\ arstdhneio' zxcvbkm,./

the home row is:

arst d h neio '

so the most common stuff should go there. My email keybindings work pretty well:

a,A: todo-, todo r: reply, sort reverse s: low, mbox t: up, first

d: archive (dont delete the message, but dont tag it either, and remove from inbox), save (like archive, but also tags with 'save' h: important toggle, flag toggle

n: down, last e: delete, mark with the 'deleted' tag but don't actually delete (note: i dont use this one much) i: fyi, toread (toread means an important fyi) o: wait, ref

',": ctx, custom edit labels

tab: next-new-then-unread enter: display-message space: display-message

so can i be inspired by those to get some ideas for the etd home row?

in email, the most important (non-motion/command/special) key is delete. What is that for tasks? Maybe importance, or maybe when, or maybe todo status change.

note that most task views (a) group by project (or whatever else the user specifies), and (b) preserve task (and section and note) ordering unless the user specifies something else

predefined enums such as statuses are at most 8 characters, and the UI assumes that custom variants are also at most 8 characters (when setting column lengths, etc)

2D grid to cycle through substates

it will be less annoying if the keyboard hints box at the bottom of the UI is permanent rather than appearing after a few seconds of inactivity

The problem with having too many statuses is that in the UI it's too hard to specify one or to cycle through them. This can be ameliorated by per-project choice of status via "project type". Project type could also select whether when era is time-based or sequence / sprint-based. Also these choices could be made at the level of any item for its sub items rather than at the project level; or alternately, an items "project" is its closest ancestor of type project whether that is a project sub project or sub sub project etc.

some paper planners have an "important dates" page -- this is just part of the overview

Common symbols

W: firm when w: soft when I: important (importance >=1) i: importance <1

Keyboard keys

Displays

Views (modes)

some modes we have: agenda view/modular query, edit item, help

agenta view

shows one line per item and no empty lines in between

Expanded agenda view

shows three lines instead of one and empty lines in between items?

Timeline view

Calendar view

can be per-project, that is, can see each project's 'Calendar'

Kanban view

Overview views

you can view all tasks by month; but you can also view the month overview, which is a different thing

an overview of an era (are there other kinds of overviews, not counting the ordinary task views/queries such as all important+urgent or flagged or favorited, etc?) includes those tasks which are marked as overview for this area

What else do era overview screens include (are tasks which are both important/urgent at the level of the era included? What about tasks which are both important/urgent in suberas, eg imp urg tasks (the 'now' era) when viewing the month era)?

the PARA system uses the P->A->R->A not just as types, but as levels of overview-ness

in an era overview you can see which tasks will be urgent in that era

older note:

Edit item screen

edit item screen starts in a text box editing the item text but other fields are also displayed and you can tab over to them? Or maybe hit escape and then use standard keys (like d for deadline) to access them. In fact maybe editing starts without editing the text so that you can use those keys

Flags and stars

sIf imp and urg and priority are relative to each project, is there any way for a user to force a task to be marked something like 'important' in the global views, that is, UI views showing tasks from all projects? Yes, there is a "flag" functionality, and flagging is global. There is also a 'star' functionality which is adds a task to a 'favorite' list (which is then shown in various parts of the UI, eg the main sidebar; but 'favorites' have relevance to the data ontology beyond just being a UI element (later: okay what is that relevance? my they show up in overviews?)).

Ref autonumbering

Can automatically put hierarchical autonumbering in the 'ref' field, eg. 1.3.11.4, but then later 'freeze' the existing numbers -- this allows you to eg draft a requirements document to give to a contractor, and then after that document is shared with a contractor, freeze the numbering and use the numbers as perma-IDs.

Queries

Preset query screens

show important/urgent tasks in any chosen era

Modular queries

i vs I: I means filter for importance >=1 w vs W: W means filter for firm when

various keys for 'when' in various eras

Fully custom queries

Use some sort of query language

allow saving queries

Menu bar

Function keys

F1: help F2: F3: F4: F5: F6: F7: F8: F9: F10: F11: F12:

Misc UI notes

UI hard / for later

stuff that is probably hard to do, so dont bother for now

generally, we're going to focus on what we can easily on top of orgmode setup, without too much programming. Mayyybe later we can do more, but don't count on it. It's useful to design the ideal system

Misc notes

Toreads