path: root/.ai/workflows/task-review.org

#+TITLE: Task Review Workflow
#+AUTHOR: Craig Jennings & Claude
#+DATE: 2026-04-25

* Overview

Unified workflow for reviewing open tasks. Two modes share the same data-gathering and reconciliation logic, then branch on output:

- *List mode* — exhaustive, priority-grouped display of every open task. Use when Craig wants to see his full plate.
- *Next mode* — single-task recommendation via prioritization cascade. Use when Craig wants to pick what to do next without scanning the whole list.

This workflow supersedes the previous standalone =open-tasks.org= (list mode) and =whats-next.org= (next mode), which duplicated the data-gathering and reconciliation logic.

* When to Use This Workflow

User says one of:

- *List mode triggers:* "list open tasks", "show me all tasks", "what's on my plate", "task review"
- *Next mode triggers:* "what's next", "what should I work on next", "what should I work on", "I need a recommendation"
- *Ambiguous:* "what should I do today", "show me my tasks" — ask which mode

* Phase A: Data Gathering (one parallel batch — both modes)

Issue all source reads as a single batch of parallel tool calls. They're independent:

1. Read =notes.org= — sections *Active Reminders* and *Pending Decisions* only.
2. Read each of the 2-3 most recent files in =.ai/sessions/= — only the *Next Steps* subsection under =* Summary= (those capture recent "next time, do X" items that may still be open).
3. Read =todo.org= — entries under the open-work header (=* $Project Open Work=, e.g. =* Homelab Open Work=). Skip the resolved header (=* $Project Resolved=).
4. Run =date= for an accurate timestamp (used to evaluate deadlines + flag suspected completions).

The phases below work entirely from this in-memory snapshot. The original split-workflow versions issued these reads sequentially in different files; consolidating saves round-trips and prevents the two implementations drifting apart.

* Phase B: Reconcile (both modes)

Compare the open-task signal across sources. For each task in =notes.org= Active Reminders or in a recent session's Next Steps that does NOT have a corresponding =todo.org= entry:

1. Create a new =** TODO= entry under the =* $Project Open Work= header.
2. Assign a priority based on context: =[#A]= if time-sensitive or blocking, =[#B]= if important, =[#C]= if low urgency.
3. Include:
   - =:CREATED:= property with today's date.
   - Brief description of what needs to be done.
   - Why it matters (context from the reminder or session note).
   - Recommended approach or next steps.
4. If a deadline exists, add a =DEADLINE:= line.

*Do NOT remove the item from =notes.org= Active Reminders.* Reminders serve a different purpose (surfaced at session start). The =todo.org= entry is for tracking and prioritization.

*Judgment call:* Not every reminder needs a =todo.org= entry. Skip:
- Pure informational notes (e.g. "rsyncshot running with 600s timeout").
- Waiting-for items with no action Craig can take (e.g. "package arriving Feb 25").
- Items already completed (handle in Phase C list mode).

* Phase C: Mode-Specific Output

** List Mode

*** Step 1: Review for Suspected Completions

Quickly scan all open tasks and check if any appear already done, based on:
- Recent session history mentioning completion.
- Context clues (e.g. "arriving Feb 7" and today's date is Feb 12).
- Work completed in previous sessions that wasn't marked done.

Build a list of *suspected completions* — do NOT mark them done yet. These get confirmed with Craig in Step 3.

*** Step 2: Display All Open Tasks

Present grouped by priority. Format rules:

- *Group by priority:* A (High), B (Medium), C (Low/Someday).
- *Default priority:* Tasks without an explicit priority are treated as C.
- *No table structure* — use a flat bulleted list within each group.
- *Include deadlines:* If a task has a =DEADLINE:=, show it inline as =DEADLINE: <date>=.
- *Include scheduled dates:* If a task has a =SCHEDULED:=, show it inline.
- *Keep descriptions concise* — task name + one-line summary, not full details.
- *Note source* if task came from reminders only (not yet in =todo.org=) vs =todo.org=.

Example:

#+begin_example
**Priority A (High)**

- Complete Sara Essex email setup — add Google Workspace MX records, verify delivery
- Set up Comet KVMs — remote console for TrueNAS and ratio
- Complete UPS/TrueNAS integration — USB cable, configure shutdown threshold. DEADLINE: <2026-01-21>

**Priority B (Medium)**

- Design Zettelkasten architecture — resume at Question 4 (Staleness)
- Compare Ubiquiti UTR vs open source mesh router

**Priority C (Low / Someday)**

- Explore Whisper-to-Claude-Code voice integration
- Get Keychron Q6 Pro carrying case. SCHEDULED: <2026-02-07>
#+end_example

*** Step 3: Confirm Suspected Completions

After displaying the list, present suspected completions:

#+begin_example
These tasks may already be completed — can you confirm?
- "OBSBOT Tiny 3 webcam arriving" — it's past the expected delivery date
- "Sweetwater order arriving" — expected Feb 7, now Feb 12
#+end_example

For each task Craig confirms as done:
1. Add =CLOSED: [YYYY-MM-DD Day]= timestamp (use the =date= output from Phase A).
2. Change status from =TODO= to =DONE=.
3. Add a brief completion note (when/how it was resolved).
4. Move the entry from =* $Project Open Work= to =* $Project Resolved= in =todo.org=.
5. If the task also exists in Active Reminders in =notes.org=, remove it from there.

For tasks Craig says are NOT done, leave them as-is.

** Next Mode

Apply the prioritization cascade in order. Stop at the first matching step:

*** 1. In-Progress Tasks
- Look for tasks marked =DOING= or partially complete.
- *If found:* Recommend that task (always finish what's started).
- *If user declines:* Continue to next step.

*** 2. Active Reminders
- Review notes.org Active Reminders (already in the Phase A snapshot).
- *If found:* Recommend reminder task.
- *If user declines:* Add to =todo.org= per Phase B (if not already there), then continue.

*** 3. Deadline-Driven Tasks
- Scan =todo.org= for tasks with explicit deadlines.
- *If found:* Recommend the task with the closest deadline.
- *If none:* Continue to next step.

*** 4. V2MOM Method Order (if applicable)
If =todo.org= is structured with V2MOM methods:
- Method 1 priority A tasks first.
- Then Method 2 priority A, Method 3 priority A, etc.
- Then Method 1 priority B, Method 2 priority B, etc.
- Continue pattern through priorities C and D.

*** 5. Simple Priority Order
If =todo.org= is a flat list:
- Evaluate all priority A tasks, pick most important.
- If no priority A, evaluate priority B tasks.
- Continue through priorities C and D.

*** 6. All Tasks Complete
If no tasks remain: report "All done — no open tasks in =todo.org=."

*** Handling Multiple Tasks at Same Level

When multiple tasks share priority/method position, pick one based on:

1. *Blocks other work* — dependencies matter.
2. *Recently discussed* — mentioned in recent conversation.
3. *Most foundational* — enables other tasks.
4. *If truly uncertain* — show 2-3 options and let Craig choose.

*** Output Format

Keep the recommendation concise but informative:

#+begin_example
Next: Fix org-noter reliability (Method 1, Priority A, 8/18 complete)
Reason: Blocks daily reading/annotation workflow
#+end_example

Include:
- Task name / description.
- One-line reasoning (which cascade step matched and why).
- Progress indicator (for V2MOM-structured todos).

* Resolving a Task — Format Reference

When moving a task to Resolved (list mode Step 3), it should look like this:

#+begin_example
** DONE [#A] Set up Comet KVMs
CLOSED: [2026-02-12 Thu]
:PROPERTIES:
:CREATED: [2026-01-19 Mon]
:END:

Comet KVMs set up for TrueNAS and ratio. Remote BIOS/console access working.

*Resolution:* Completed during Feb 12 session. Both KVMs connected and tested.
#+end_example

Key elements:
- =DONE= replaces =TODO=.
- =CLOSED:= line with completion date.
- Original =:PROPERTIES:= block preserved.
- Brief resolution note explaining when/how.

* Common Mistakes

1. *Running Phase A sequentially* — issue all reads in one parallel batch.
2. *Marking tasks done without confirmation* — always ask Craig first (list mode Step 3).
3. *Removing reminders from =notes.org= when adding to =todo.org=* — they serve different purposes.
4. *Creating =todo.org= entries for pure informational reminders* — use judgment in Phase B.
5. *Using a table for the task list* — Craig prefers flat bulleted lists in list mode.
6. *Skipping the cascade order in next mode* — the cascade exists to override subjective choice with objective criteria; respect it.
7. *Recommending more than one task in next mode* — be decisive. Only show 2-3 if truly uncertain after applying the same-level tie-breakers.
8. *Re-querying =todo.org= during Phase C* — the snapshot from Phase A is canonical; don't re-read.

* Living Document

Update this workflow as task management patterns evolve. If new task sources are added (external issue trackers, shared task lists), add them to Phase A. If the cascade ordering needs to change for a project, document the variant here.

* Replaces

This file replaces:
- =open-tasks.org= (list mode logic now lives in Phase C → List Mode)
- =whats-next.org= (next mode logic now lives in Phase C → Next Mode)