ReKnock × Eisenhower

# DESIGN — Eisenhower Matrix for ReKnock

Mockups: open `index.html` (phone-friendly) or `mockups/*.svg`.

## 0. Principles
1. **Capture is free; classification is optional and fast.**
2. **Quadrant changes nag behaviour** — otherwise it's decoration.
3. **Nothing leaves by dismissal.** Only done, or an explicit/reviewed Q4 archive.
4. **Show less.** Home shows counts + top few, never 47 rows.
5. **Unclassified = today's behaviour**, so the migration changes nothing until Rob triages.

## 1. Data model

SQLite, additive migration (no destructive changes).

```sql
ALTER TABLE tasks ADD COLUMN important INTEGER;          -- NULL = unclassified, 0/1
ALTER TABLE tasks ADD COLUMN urgent INTEGER;             -- manual urgency flag, NULL/0/1
ALTER TABLE tasks ADD COLUMN urgent_set_at TEXT;         -- ISO ts, for decay
ALTER TABLE tasks ADD COLUMN due_date TEXT;              -- 'YYYY-MM-DD' optional, drives effective urgency
ALTER TABLE tasks ADD COLUMN quadrant_changed_at TEXT;   -- for Q1 age / Q4 archive clock
ALTER TABLE tasks ADD COLUMN last_nagged_at TEXT;        -- for Q1 interval + audit
ALTER TABLE tasks ADD COLUMN archived_at TEXT;           -- Q4 auto-archive; status stays recoverable
-- status gains 'archived' (active | done | archived)
CREATE TABLE IF NOT EXISTS settings_matrix (key TEXT PRIMARY KEY, value TEXT);
CREATE TABLE IF NOT EXISTS matrix_events (               -- audit: classification + review history
  id INTEGER PRIMARY KEY, task_id INTEGER, at TEXT, kind TEXT, from_q TEXT, to_q TEXT, source TEXT);
CREATE INDEX idx_tasks_quadrant ON tasks(status, important, urgent);
```

**Quadrant is derived, not stored** (single source of truth):

```
effective_urgent = urgent==1 (and not decayed) OR (due_date - today <= 2 days) OR overdue
if important IS NULL            -> 'unclassified'  (urgent alone doesn't classify)
important && effective_urgent   -> 'q1'  (Do now)
important && !effective_urgent  -> 'q2'  (Schedule)
!important && effective_urgent  -> 'q3'  (Quick / batch)
!important && !effective_urgent -> 'q4'  (Someday)
```
Urgency decay: manual `urgent=1` with no `due_date` expires 3 days after `urgent_set_at` (job sets urgent=0, logs event, appears in digest as "cooled off"). Re-affirm resets `urgent_set_at`.

Default settings (all configurable, stored in `settings_matrix`): `q1_cap=5`, `q1_interval_min=90`, `q1_window=08:00-21:00`, `q2_default_time=09:00`, `q3_batch_times=12:30,17:00`, `q4_archive_days=21`, `urgent_decay_days=3`, `review_day=sun`, `review_time=18:00`.

### Migration for the existing ~47 tasks
- All existing tasks: `important=NULL, urgent=NULL` → **unclassified, behaviour identical to today.** Zero surprise.
- Compute a **suggestion** (not stored, or stored in a `suggested_q` cache) per task via the heuristics in RESEARCH §7, used by the triage flow.
- Tasks with start_date in future, done tasks, and context-only tasks: left alone; context-only auto-nags get suggestion Q2/Q4.
- Backup the SQLite file before migrating; migration idempotent (check `PRAGMA table_info`).

## 2. API changes (REST, existing server)

Keep existing endpoints working. Additive:

- `POST /tasks` and `PATCH /tasks/:id` accept: `important` (bool|null), `urgent` (bool|null), `quadrant` (`q1..q4`|`do|schedule|quick|someday`|`unclassified`) as shorthand, `due_date`.
  - `quadrant` sets both flags: q1 → important=1, urgent=1; q2 → 1,0; q3 → 0,1; q4 → 0,0. (Setting q2/q4 with a due_date within 2 days still evaluates as q1/q3 — response includes `note`.)
  - Moving into q1 when full → `409 {error:"q1_full", q1:[...tasks]}` unless `force=true` or `swap_out_id` given (that task is demoted to q2).
- `GET /tasks?quadrant=q1|q2|q3|q4|unclassified&context=...&include_blocked=...`
- `GET /matrix` → `{q1:{count, top:[...]}, q2:..., q3:..., q4:..., unclassified:{count}, q1_cap, done_today}`
- `GET /triage/next?n=5` → unclassified tasks with `suggested_quadrant, confidence, reason`.
- `POST /tasks/:id/reaffirm-urgent`
- `POST /tasks/:id/restore` (archived → active, q4)
- `GET /review/weekly` → structured payload for the review flow; `POST /review/weekly/complete`.
- Every task payload gains: `quadrant`, `effective_urgent`, `important`, `urgent`, `due_date`, `next_nag_at`, `blocked`, `archive_in_days` (q4).

## 3. MCP tool changes

Existing: add_task, list_tasks, update_task, mark_done (names may differ — adapt). Changes:

| Tool | Change |
|---|---|
| `add_task` | + `quadrant?` , `urgent?`, `important?`, `due_date?`. If none given: unclassified, and the response includes `suggested_quadrant` so Claude can ask one short question. |
| `update_task` | + same params |
| `list_tasks` | + `quadrant?` filter, `sort=quadrant`; each task shows quadrant label |
| `set_quadrant(id, quadrant)` | convenience for voice ("make that urgent and important") |
| `matrix_summary` | counts per quadrant + Q1 list + unclassified count + Q1 cap status |
| `triage_next(n=3)` | returns tasks with suggestions so Claude can run a voice triage: *"Renew passport — I'd say important, not urgent. OK?"* |
| `weekly_review_summary` | Q1 audit list, Q2 candidates for focus, Q4 expiring |

Tool descriptions must teach Claude the voice mapping: "urgent and important" → q1; "important but not urgent" → q2; "urgent but not important / quick" → q3; "not important / someday" → q4; "I don't know" → leave unclassified. On `q1_full` Claude asks which to demote.

## 4. Notification behaviour (Android scheduling)

Server is source of truth; app schedules exact alarms from `next_nag_at` plans (as today). Per quadrant:

| Q | Schedule | Notification style |
|---|---|---|
| Q1 | task `nag_times` **plus** interval nags every `q1_interval_min` inside window; immediate on entry | Coral channel, high importance, persistent (ongoing), action buttons: ✓ Done · 😮‍💨 Not urgent (cools to Q2) |
| Q2 | once daily at `nag_times[0]` or `q2_default_time` | Blue channel, default importance, persistent; actions ✓ Done · Move |
| Q3 | no per-task alarms; **batch alarm** at each `q3_batch_times`: one grouped notification "N quick tasks", InboxStyle lists up to 5 | Amber channel, default; per-line done via tapping into app |
| Q4 | none | — |
| Unclassified | unchanged | existing channel |

Rules: dismiss changes nothing (schedule continues). Blocked / `start_date`-future tasks suppressed. Separate notification channels per quadrant so Rob can tune sound/vibration in Android settings. Boot/timezone/permission handling reuses existing code. Moving a task between quadrants cancels old alarms and registers new ones immediately (server push or next sync).

## 5. Android UI

### Visual language
- Colours (dark-first, light supported):
  - Q1 Do now — coral `#FF5A5F`
  - Q2 Schedule — indigo-blue `#4C8DFF`
  - Q3 Quick — amber `#FFB020`
  - Q4 Someday — slate `#7C8AA0`
  - Background `#0F1420`, surface `#181F2E`, text `#EAF0FA`. Each quadrant tile is a soft gradient of its colour at ~14% over surface, with a 2dp colour edge. Never colour alone: each quadrant has an icon (🔥 flame, 🗓 calendar, ⚡ bolt, 🌙 moon) and label.
- Type: rounded sans (e.g. Nunito/Google Sans), large counts (40sp) as hero numbers.
- Rounded 20dp corners, 12dp gaps, generous padding.

### Home: 2×2 matrix (mockup 1)
- Top: greeting + "Done today ✓ 3" pill. Axis labels: columns *Urgent | Not urgent*, rows *Important | Not important* (small, muted).
- Each tile: icon + name, big count, top 2–3 task titles (ellipsized), "+N more". Q1 tile shows `3/5` capacity ring.
- Bottom strip: **"12 to sort → Triage"** (only if unclassified>0), context chips ("I'm in…").
- FAB: **＋** (type) with long-press for mic.
- Tap tile → quadrant screen (full list, Q1 first card enlarged). Long-press a task row → lifts (haptic) → drag; other tiles pulse; drop zone highlights; drop = reclassify (haptic + brief toast "Moved to Schedule · next nag 09:00 · Undo").
- Landscape/tablet: same grid.

### Quick classify chip on add/edit (mockup 2 sheet)
Two toggle chips **Urgent** / **Important** with live preview: "→ Do now, nags every 90 min". Optional due date picker. Suggestion shown as a pre-filled ghost state ("Suggested: Schedule — tap to accept").

### Triage flow (mockup 2)
- Entry from home strip, notification ("5 tasks to sort — 1 min"), or Claude voice.
- One card at a time: task text, contexts, age ("added 12 days ago"), suggestion pill with reason ("mentions 'tax'").
- Four large buttons in a 2×2 mirror of the matrix at the bottom half (thumb zone); the suggested one outlined. Swipe aliases: ← not important, → important then second prompt Urgent?/Not; or just buttons.
- Extras: **Done already**, **Skip** (returns later), **Delete**.
- Progress bar "7 / 47", session default 10 cards then "Nice — 37 left. Continue / Later". A gentle daily nudge (one notification, 5 cards) until unclassified = 0, then it stops forever.
- Haptic tick + card flies to its quadrant corner with colour flash.
- "Accept all suggestions" option on a summary screen listing suggestions by quadrant for quick review (high-confidence only), since 47 tasks is a lot.

### Quadrant screen
Header colour band, rule line explaining behaviour ("Nags every 90 min until done"). List sorted by age/due. Row: checkbox-style done target (large), title, context chips, due badge, "blocked by …" dim state. Q1 "full" banner when 5/5. Q4 shows "archives in N days" per row and a weekly review shortcut.

### Done feedback
Tap done → checkbox fills with quadrant colour (150 ms), ring pulse + check draw (stroke animation), row collapses; tile count ticks down with number roll; small particle burst (8–12 dots, quadrant colour); haptic `CONFIRM`. Clearing Q1 entirely: bigger "Q1 clear" celebration (soft confetti, 1.5 s, no blocking). Respect "reduce motion". Done-today counter bumps.

### Weekly review (mockup 4)
Stepper per RESEARCH §10. Each step one screen with big buttons; progress dots; ≤5 min; "Skip step".

### Widgets (Glance/AppWidget)
- **Matrix 2×2 (4×2 cells)**: four coloured tiles with counts; tap tile deep-links to quadrant. Shows next nag time.
- **Q1 "Do now" list (4×2)**: up to 4 tasks with ✓ buttons (tap opens a confirm to prevent accidental done).
- **Q2 "Today's focus" (2×2)** and **Knocking now** (existing plan).
- Updates on every change via broadcast; no polling.
Widgets never offer "dismiss".

### Digest (email)
```
ReKnock — Tue 4 Nov
✓ 19 done yesterday (Q1 4 · Q2 7 · Q3 6 · Q4 0 · unsorted 2)
Knocking now: 47 → 🔥 Do now 3 · 🗓 Schedule 11 · ⚡ Quick 6 · 🌙 Someday 9 · ❔ unsorted 18

🔥 Do now (3/5)
 • Call accountant (due tomorrow)
 …
🗓 Today's scheduled (9:00)
 • …
⚡ Quick batch: 6 tasks ≈ 15 min
🌙 Archiving soon: 2 (in 3 days) — reply or open app to keep
Cooled off: "Fix gutter" (no longer urgent)
18 left to sort → open triage
```
Subject: "19 done · 3 to do now". Honest tone, no shame.

## 6. Anti-inflation & hygiene jobs (server cron)
- Hourly: urgency decay; due-date driven recompute of `next_nag_at`; Q4 archive after `q4_archive_days` since `quadrant_changed_at` with no edit.
- Daily: digest.
- Sunday: weekly review notification; if skipped, repeats next day.

## 7. Edge cases
- Task with `due_date` but `important=NULL` → stays unclassified (nags as today) but shows due badge; triage suggests urgent.
- Quadrant changes while notification showing → replace notification via same id.
- Offline app: caches matrix; reclassification queued and synced; server wins on conflict by `updated_at`.
- Done tasks remain historical in digest stats only.
- Dependencies: blocked tasks excluded from Q counts for nag purposes but visible dimmed; unblocking triggers an immediate nag per its quadrant.
- Q1 cap bypass for due-date-derived urgency: still counts toward cap but is allowed over cap (truth beats cap) with a banner "Over capacity — 7 in Q1".

## 8. Rollout phases
1. Backend + DB (migration, derivation, scheduler plan, jobs, API).
2. MCP tools.
3. Android (matrix, triage, notifications, widgets, review, polish).
Each phase ends with a testing checkpoint.

## 9. Decisions Rob may want to change
Q1 cap 5; Q1 interval 90 min; Q3 batches 12:30/17:00; Q4 21-day archive; urgency decay 3 days; unclassified unchanged; palette. All are settings/constants.

# RESEARCH — Eisenhower Matrix for ReKnock

> Method note: this is synthesised from my own knowledge of the model and of these apps' public behaviour (as of my training; app details change). I did not browse live, so treat specific app feature claims as "well-known as of last I knew" and glance at each app if a detail matters.

## 1. The model, and what it actually says

- Origin: Dwight Eisenhower ("What is important is seldom urgent, and what is urgent is seldom important"), popularised by Stephen Covey as the Quadrant I–IV model in *7 Habits*.
- Four quadrants:
  | | Urgent | Not urgent |
  |---|---|---|
  | **Important** | Q1 **Do now** (crises, deadlines) | Q2 **Schedule** (planning, health, relationships, prevention) |
  | **Not important** | Q3 **Delegate / batch** (interruptions, most email/calls) | Q4 **Drop / someday** (time-wasters) |
- The real insight is not the grid, it is **Q2 is where life improves, and Q1 is what Q2 becomes when neglected.** A Q2 task with a deadline *migrates* to Q1 as the date nears. A good implementation models that migration instead of making the user re-sort.
- Definitions that keep sorting honest:
  - *Urgent* = has a consequence **soon** (time-boxed, someone is waiting). It is about the clock, not about feeling anxious.
  - *Important* = moves you toward your goals/values or avoids real harm. It is about the outcome.

## 2. Best practices

1. **Two binary questions, not four buckets.** "Does this have a clock?" and "Does this matter?" are easier than "which quadrant?" and map to two taps.
2. **Keep Q1 small.** Commonly cited limit: ~3–5 items in "Do now" at once. If Q1 has 15 things, nothing is in Q1.
3. **Protect Q2.** Put Q2 items on a *specific time*, not just a list. Unscheduled Q2 is just a wish list.
4. **Q3 = batch or hand off.** Process in one or two windows per day; don't let them interrupt Q1/Q2.
5. **Q4 = decide, then let go.** Explicit "not now" is a decision; a task that rots untouched is a hidden cost.
6. **Re-evaluate on a rhythm.** Urgency changes daily, importance rarely. A weekly review is where the matrix stays honest.
7. **Limit WIP / pick one.** Matrix tells you *category*, not *next action*; pair with "the one thing now".

## 3. Common pitfalls

| Pitfall | Why it happens | Mitigation for ReKnock |
|---|---|---|
| **Q1 inflation** — everything becomes "urgent+important" | Urgency feels good; no cost to marking it | Soft cap (5) with a forced swap prompt; urgency **decays** (expires after N days unless a due date backs it); show "Q1 age" |
| **Q2 graveyard** | No time attached, never surfaces | Q2 gets a daily nag at a *scheduled time*; weekly review picks "this week's Q2 focus" |
| **Sorting fatigue** | Classifying 47 tasks in one sitting | Triage in small sessions (5/day), pre-suggest quadrant, swipe UI, unclassified stays valid |
| **Static classification** | Deadlines approach but flag stays "not urgent" | Effective urgency derived from `due_date` automatically |
| **Matrix becomes a browse-and-ignore list** | Pretty grid, no consequence | Quadrant **drives nag behaviour**; no quadrant is passive except Q4, which is an explicit, reviewed, auto-archiving parking lot |
| **Q3 disguised as Q1** | Other people's urgency | Label Q3 "Quick / batch"; digest shows Q3 ratio |
| **Over-engineering input** | Many fields per task | Quadrant optional on add; voice default is "unclassified → triage later" |

## 4. How other apps do it

*(High level; verify details in-app.)*

- **Todoist** — no native matrix. Users emulate with priorities P1–P4 (P1=red) plus filters (`p1 & due before: +3 days`), or the community "Eisenhower" template using labels like `urgent`/`important` and a filter-based board view. Lesson: *priority levels are the closest thing, and filters make views cheap*; but there is no drag between quadrants. Natural-language input (`p1`) is a nice low-friction pattern.
- **TickTick** — built-in Eisenhower Matrix view (Pro). Four coloured quadrants, drag-and-drop tasks between them, each quadrant driven by smart-list rules (priority + due date). Defaults: high priority = important, due today/overdue = urgent. Lesson: **derive urgency from the due date, importance from priority; drag rewrites the underlying fields.** Closest to what ReKnock needs.
- **Things 3** — deliberately no matrix; uses Today / Upcoming / Anytime / Someday. "Someday" is the Q4 analogue; "This Evening" is a batch bucket. Lesson: a **Someday** state with distinct, calm visual treatment; restraint is the product.
- **Sunsama** — daily planning ritual: pull tasks into today, set time estimates, shutdown ritual. Not a matrix, but strong on **ritual and a "you're overcommitted" signal** when planned hours exceed capacity. Lesson: caps and rituals prevent inflation.
- **Akiflow** — time-blocking inbox: triage inbox → schedule onto calendar. Lesson: **Q2 = give it a time slot**; "inbox → triage" flow with keyboard/swipe speed.
- **Eisenhower.me / Eisenhower app (Android/iOS)** — pure matrix apps: 2×2 board, tap quadrant to add, drag between, sometimes AI "auto-sort". Often criticised for being a prettier list with no follow-through (no reminders per quadrant). Lesson: **the gap ReKnock fills — the quadrant should change reminder behaviour.**
- **Priority Matrix (Appfluence)** — enterprise-ish; 2×2 board with quadrants as expandable "buckets", drag items, email-to-task, and a bubble ordering within a quadrant. Lesson: ordering inside a quadrant matters; show top 3 with "+N more".
- **Notion / Trello templates** — static boards; cautionary tale for graveyards.
- **Motion / Reclaim** — auto-schedule tasks by priority + deadline: shows value of deriving urgency automatically.

**Cross-app takeaways:** (a) derive urgency from dates; (b) drag-to-reclassify rewrites fields; (c) Someday is a first-class calm state; (d) a quadrant that doesn't change behaviour is decoration; (e) triage inbox UX should be swipe-fast.

## 5. ADHD-friendly / low-friction design

- **Zero required decisions at capture.** Capture first, classify later. Unclassified is a normal state, with a gentle "triage" affordance.
- **Few choices per screen**: one card at a time, big targets, thumb-reachable bottom half.
- **Immediate, tactile reward**: haptic tick on classify, satisfying done animation, streak/"cleared" counters. Dopamine without shame.
- **No shame mechanics**: avoid red overdue counts that grow without bound; Q4 and auto-archive are framed as *relief* ("lighter by 6").
- **Externalise time**: show "next nag at 14:00" so the brain trusts the system.
- **Reduce visible load**: home shows counts and top items, not 47 rows. Q1 shows max 5; others are one tap away.
- **Time-boxed rituals**: triage of 5 tasks (~60 sec), weekly review ≤5 minutes with a progress bar.
- **Voice as first-class**: Rob captures by voice; classification phrases must be forgiving.
- **Resilience to forgetting**: the persistent no-dismiss nag is already the core ADHD feature; the matrix tunes its *volume*, never removes it silently.

## 6. Fast classification methods

| Method | Gesture | Notes |
|---|---|---|
| Two taps | Tap "Urgent?" chip, tap "Important?" chip (each toggles) | Works anywhere; default both off = unclassified until touched |
| Four-button | Big coloured Q1–Q4 buttons | Used in triage card |
| Swipe (Tinder-style) | Triage card: ➡ important, ⬅ not important, then ⬆ urgent / ⬇ not urgent as second pass; or swipe into corner | Two-pass per card is still 2 gestures; alternatively diagonal swipes → 4 quadrants (more error-prone) |
| Drag | Long-press chip/row, drop in quadrant | Best for rearranging on matrix home |
| Voice | "urgent and important", "important but not urgent", "just do it quickly", "someday" | Parsed by Claude on the MCP side into booleans; MCP tool takes explicit params |
| Row swipe | In lists: swipe right = promote, left = demote | Optional |

Recommendation: **triage card with 4 big buttons + horizontal/vertical swipe aliases; drag on matrix; voice via MCP params.**

## 7. Auto-suggest quadrant

Deterministic, explainable heuristics (no LLM needed on-device; Claude on voice can do richer reasoning and pass explicit values):

- **Urgent signals**: `due_date` ≤ 48h; words "today", "tonight", "tomorrow", "asap", "deadline", "overdue", "before <weekday>", "by EOD", "expires", "due"; task with nag history of repeated offers; blocking other tasks (`blocks` non-empty → raise urgency/importance).
- **Important signals**: words "tax", "insurance", "doctor", "health", "pay", "bill", "renew", "contract", "client", "kids", "family", "launch", "invoice", "license"; context `Premco`/`ODL` (work) → important; `blocks` count ≥ 1.
- **Not important signals**: "maybe", "someday", "look into", "check out", "organize", "browse", "idea"; context-only tasks that were auto-promoted to daily nags after 3 days unoffered → suggest Q4 or Q2 and ask.
- **Delegate/quick signals**: "call", "email", "reply", "text", "book", "order", "pick up", "drop off"; context Phone call / Errands → Q3 candidate if not important.
- Output `{suggested_quadrant, confidence, reason}`. Never auto-apply below high confidence; in triage the suggestion is the **pre-highlighted button**, one tap to accept.

Also, **effective urgency** is computed live: `urgent = manual_urgent OR due_date within 2 days`.

## 8. Quadrant → nag intensity

| Quadrant | Behaviour | Rationale |
|---|---|---|
| **Q1 Do now** | Persistent notification; re-nags every **60–120 min** (default 90) between 08:00–21:00 in addition to its `nag_times`; first nag immediately when moved into Q1; cap of 5 tasks | Real urgency deserves frequency; the cap stops notification fatigue |
| **Q2 Schedule** | **One** nag per day at its chosen time (default 09:00 if none; use existing `nag_times[0]`); optionally "this week's focus" pin | Calm, predictable, protects important/non-urgent work |
| **Q3 Quick/batch** | No individual nags; **two batch notifications** per day (e.g. 12:30 and 17:00): "6 quick tasks — 15 min?" with expandable list; each still needs mark-done | Batch cuts interruptions |
| **Q4 Someday** | No daily nags. Included in Sunday weekly review. If untouched **21 days** → auto-archive (status `archived`, recoverable, announced in digest). | Prevents graveyard without losing data |
| **Unclassified** | **Current behaviour unchanged** | Safe migration; no surprises |

Philosophy check: dismissing a notification still changes nothing; the schedule continues. Only done (or an *explicit* user re-classification / auto-archive of Q4) stops nagging. Q4 is the one deliberate carve-out and is a conscious user decision, reviewed weekly, and reversible. Contexts and `start_date` still apply first (a task quiet until a date stays quiet; blocked tasks don't nag until unblocked).

## 9. Preventing Q1 inflation

1. **Soft cap 5**: adding a 6th shows "Q1 is full. Swap one out?" (pick one to demote). Voice/MCP gets a response telling Claude, who asks Rob.
2. **Urgency decay**: manual urgency without a due date expires after **3 days** → falls to Q2 (with a visible "cooled off" note in the digest). Re-affirm with one tap ("still urgent").
3. **Due-date-backed urgency is truthful**: derived, not manual, so no gaming.
4. **Q1 ratio in digest**: "Q1 is 8% of your tasks" — gentle awareness.
5. **Q1 age badge**: items in Q1 > 7 days ask "Is this really urgent, or just important?"
6. **Frequency cost**: Q1 nags are loud, so users self-police.

## 10. Weekly review ritual

Sunday (configurable) notification "Weekly reset — 5 min". Guided steps, each a single screen:
1. **Celebrate**: done this week by quadrant.
2. **Q1 audit**: each Q1 item: still urgent? (keep / cool to Q2 / done).
3. **Pick Q2 focus**: choose up to 3 Q2 tasks to give a specific day/time this week.
4. **Q3 sweep**: batch or drop.
5. **Q4 purge**: keep / delete / promote; items with archive countdown shown.
6. **Triage leftover unclassified.**
Finish → confetti-lite, `last_reviewed_at` set; skip allowed (reminds again next day, nag-style).

## 11. Integration with contexts and dependencies

- **Contexts**: orthogonal to quadrant. "I'm in Computer mode" shows tasks for that context **sorted Q1→Q2→Q3→Q4** with quadrant colour dots; Q4 hidden by default. The matrix home gets a context filter chip.
- **Dependencies**: a blocked task is dimmed in its quadrant ("waiting on X") and doesn't nag; the *blocker* inherits `max(urgency/importance)` of what it blocks as a *suggestion/badge* ("blocks a Q1 task") — and optionally effective quadrant promotion, but only displayed, never silently rewriting fields.
- **Context-only tasks** (become daily 09:00 nags after 3 days unoffered): treated as unclassified; triage suggests Q2 (keep nagging daily) or Q4.
- **start_date**: quiet tasks are shown dimmed/collapsed in a "Later" strip, not in quadrant counts.

## 12. Sources / further reading (from memory — verify links)
- Covey, *The 7 Habits of Highly Effective People* (Quadrant II).
- Eisenhower speech, 1954 (quoting Dr. J. Roscoe Miller).
- TickTick help centre: "Eisenhower Matrix".
- Todoist templates/blog on Eisenhower filters.
- Things 3 docs on Someday/This Evening.
- Sunsama "daily planning ritual" documentation.