From cf84d6d2ddff3ca507aa19c9b1ae97e327999373 Mon Sep 17 00:00:00 2001
From: M Dombaugh <michael.dombaugh@gmail.com>
Date: Mon, 2 Mar 2026 17:35:00 +0000
Subject: [PATCH] various enhancements for new tabs and bug fixes

---
 core/base_repository.py                       |    1 +
 lifeos-claude-code-prompts_R1_1.md            |  337 +++
 main.py                                       |    2 +
 project-docs/lifeos-system-design-document.md | 2068 +++++++++++++++++
 routers/decisions.py                          |    7 +
 routers/eisenhower.py                         |   60 +-
 routers/focus.py                              |   50 +-
 routers/history.py                            |   91 +
 routers/lists.py                              |   59 +
 routers/meetings.py                           |  168 +-
 routers/notes.py                              |   14 +
 routers/projects.py                           |  143 +-
 routers/search.py                             |  340 ++-
 routers/tasks.py                              |  129 +-
 routers/weblinks.py                           |   14 +
 static/style.css                              |    5 +-
 templates/base.html                           |    4 +
 templates/decision_form.html                  |    3 +-
 templates/eisenhower.html                     |   55 +
 templates/focus.html                          |   55 +-
 templates/history.html                        |   32 +
 templates/list_detail.html                    |   34 +
 templates/list_form.html                      |    4 +-
 templates/lists.html                          |   40 +-
 templates/meeting_detail.html                 |  124 +-
 templates/note_form.html                      |    2 +
 templates/project_detail.html                 |   79 +-
 templates/task_detail.html                    |  107 +-
 templates/weblink_form.html                   |    4 +-
 tests/conftest.py                             |   23 +
 tests/registry.py                             |    3 +
 tests/test_business_logic.py                  |  740 ++++++
 32 files changed, 4501 insertions(+), 296 deletions(-)
 create mode 100644 lifeos-claude-code-prompts_R1_1.md
 create mode 100644 project-docs/lifeos-system-design-document.md
 create mode 100644 routers/history.py
 create mode 100644 templates/history.html

diff --git a/core/base_repository.py b/core/base_repository.py
index ebc0843..c31d698 100644
--- a/core/base_repository.py
+++ b/core/base_repository.py
@@ -161,6 +161,7 @@ class BaseRepository:
             "category", "instructions", "expected_output", "estimated_days",
             "contact_id", "started_at",
             "weekly_hours", "effective_from",
+            "task_id", "meeting_id",
         }
         clean_data = {}
         for k, v in data.items():
diff --git a/lifeos-claude-code-prompts_R1_1.md b/lifeos-claude-code-prompts_R1_1.md
new file mode 100644
index 0000000..5971648
--- /dev/null
+++ b/lifeos-claude-code-prompts_R1_1.md
@@ -0,0 +1,337 @@
+# Life OS - Claude Code Prompts for DEV Enhancements
+
+**Target Environment:** DEV only (lifeos-dev.invixiom.com)
+**Codebase Location:** `/opt/lifeos/dev/`
+**Hot Reload:** Changes to files in `/opt/lifeos/dev/` are picked up automatically by uvicorn `--reload`. No container rebuild needed.
+**Database:** `lifeos_dev` on container `lifeos-db` (PostgreSQL 16)
+
+---
+
+## PROMPT 1: Task Detail Page - Add Tabs
+
+**Context:** The task detail page at `/tasks/{task_id}` currently shows task metadata but does NOT use the tabbed layout. The project detail page at `/projects/{project_id}` (template: `project_detail.html`) IS the reference implementation for tabbed detail views. It uses a `?tab=` query parameter to switch between tabs, with tab content rendered server-side via Jinja2 conditionals.
+
+**Codebase facts:**
+- Stack: Python 3.12, FastAPI, SQLAlchemy async, Jinja2 templates, vanilla JS/CSS
+- Template to modify: `templates/task_detail.html`
+- Router to modify: `routers/tasks.py` (the `task_detail` GET handler at `/tasks/{task_id}`)
+- Reference template: `templates/project_detail.html` - copy the tab-strip HTML structure and `?tab=` query param pattern exactly
+- CSS: `static/style.css` already has `.tab-strip` and `.tab-content` classes from the project detail implementation
+- BaseRepository pattern: `core/base_repository.py` provides generic CRUD. All queries use `is_deleted = false` filtering automatically.
+
+**Existing DB tables/junctions (already in schema, may not have app code):**
+- `notes` - has `domain_id`, `project_id` columns. Notes don't have a `task_id` FK directly. You'll need to either add a `task_id` FK column to notes OR use a polymorphic junction (e.g., `note_tasks` or use `file_mappings` pattern with `context_type='task'`). Prefer adding a nullable `task_id UUID REFERENCES tasks(id)` column to the `notes` table for simplicity.
+- `weblinks` - has `domain_id`, `project_id`. Same situation as notes - add nullable `task_id UUID REFERENCES tasks(id)`.
+- `file_mappings` - polymorphic junction: `file_id, context_type, context_id`. Already supports `context_type='task'`. Files tab should query `file_mappings WHERE context_type='task' AND context_id={task_id}` joined to `files`.
+- `lists` - has `domain_id`, `project_id`. Add nullable `task_id UUID REFERENCES tasks(id)`.
+- `decisions` - has `domain_id`, `project_id`. Add nullable `task_id UUID REFERENCES tasks(id)`.
+- `processes` / `process_runs` - These tables exist in the R1 schema but process CRUD is NOT yet built. The Processes tab should show: (a) a way to apply a process template to this task (create a process_run with context), and (b) list existing process_runs linked to this task. For now, since process CRUD doesn't exist yet, create the tab structure with an empty state placeholder that says "Process management coming soon" and a TODO comment in the code.
+- `contact_tasks` - junction table already exists with columns: `contact_id, task_id, role, created_at`. This is the Contacts + Roles tab data source.
+
+**What to build:**
+
+1. **Migration SQL** - Create a migration file at `/opt/lifeos/migrations/` that adds:
+   - `ALTER TABLE notes ADD COLUMN task_id UUID REFERENCES tasks(id);`
+   - `ALTER TABLE weblinks ADD COLUMN task_id UUID REFERENCES tasks(id);`
+   - `ALTER TABLE lists ADD COLUMN task_id UUID REFERENCES tasks(id);`
+   - `ALTER TABLE decisions ADD COLUMN task_id UUID REFERENCES tasks(id);`
+   - Create indexes on these new FK columns.
+   - Apply to `lifeos_dev` database via: `docker exec -i lifeos-db psql -U postgres -d lifeos_dev < /opt/lifeos/migrations/NNNN_task_detail_tabs.sql`
+
+2. **Router** (`routers/tasks.py`) - Modify the task detail GET handler:
+   - Accept `tab` query parameter (default: "overview")
+   - Tabs: overview, notes, weblinks, files, lists, decisions, processes, contacts
+   - For each tab, query the relevant data and pass to template context
+   - For contacts tab: query `contact_tasks` joined to `contacts` WHERE `task_id = {id}`
+   - For files tab: query `file_mappings` WHERE `context_type='task' AND context_id={id}` joined to `files`
+   - For notes/weblinks/lists/decisions: query WHERE `task_id = {id} AND is_deleted = false`
+
+3. **Template** (`templates/task_detail.html`) - Restructure to match `project_detail.html` tab pattern:
+   - Keep existing task header (title, metadata, action buttons including timer)
+   - Add tab-strip below header with all tab names
+   - Active tab highlighted via CSS class
+   - Tab links use `?tab=tabname` pattern
+   - Each tab section wrapped in Jinja2 `{% if tab == 'notes' %}...{% endif %}` blocks
+   - Overview tab contains what's currently shown (description, subtasks, metadata)
+   - Each entity tab shows a list of related items with an "+ Add" button
+   - Contacts tab shows contact name + role with ability to add/remove
+
+4. **Contact + Role management on tasks:**
+   - Add endpoint `POST /tasks/{task_id}/contacts/add` accepting `contact_id` and `role` form fields. Insert into `contact_tasks`.
+   - Add endpoint `POST /tasks/{task_id}/contacts/{contact_id}/remove` to delete from `contact_tasks`.
+   - The contacts tab should show a form with a contact dropdown (all non-deleted contacts) and a role text input, plus a list of currently linked contacts with remove buttons.
+   - Role should be a free-text field (not a fixed set yet - we'll define role sets later).
+
+5. **Update note/weblink/list/decision create forms** to accept optional `task_id` and pre-fill it when creating from within a task detail page. The "+ Add" buttons on each tab should link to the respective create form with `?task_id={task_id}` pre-filled.
+
+**Do NOT:**
+- Touch production database or files
+- Build full process CRUD (just placeholder tab)
+- Change the existing task list page (`tasks.html`)
+- Add any npm/frontend build tooling
+
+**Test:** After implementation, verify at `https://lifeos-dev.invixiom.com/tasks/{any_task_id}` that all tabs render, switching works via URL param, and the contacts add/remove flow works.
+
+---
+
+## PROMPT 2: Project Detail Page - Add Missing Tabs
+
+**Context:** The project detail page at `/projects/{project_id}` already has a working tabbed layout with tabs for Tasks, Notes, Links (weblinks). It needs additional tabs for: Files, Lists, Processes, Contacts + Roles.
+
+**Codebase facts:**
+- Template: `templates/project_detail.html` (already has tab-strip pattern)
+- Router: `routers/projects.py` (the detail GET handler already accepts `?tab=` param)
+- Existing tabs: tasks, notes, links/weblinks
+- `file_mappings` supports `context_type='project'` already
+- `contact_projects` junction table exists: `contact_id, project_id, role, created_at`
+- `lists` table has `project_id` FK already
+- Process CRUD not yet built
+
+**What to build:**
+
+1. **Router** (`routers/projects.py`) - Extend the detail handler:
+   - Add tab cases for: files, lists, processes, contacts
+   - Files: query `file_mappings WHERE context_type='project' AND context_id={project_id}` joined to `files`
+   - Lists: query `lists WHERE project_id={id} AND is_deleted=false`
+   - Processes: placeholder (empty state)
+   - Contacts: query `contact_projects` joined to `contacts` WHERE `project_id={id}`
+
+2. **Template** (`templates/project_detail.html`) - Add new tabs to existing tab-strip:
+   - Files tab: list of attached files with upload link (`/files/upload?context_type=project&context_id={project_id}`)
+   - Lists tab: list of project lists with link to create (`/lists/create?project_id={project_id}`)
+   - Processes tab: empty state placeholder "Process management coming soon"
+   - Contacts tab: same pattern as Task contacts - dropdown + role input + list with remove
+
+3. **Contact + Role management on projects:**
+   - `POST /projects/{project_id}/contacts/add` - insert into `contact_projects`
+   - `POST /projects/{project_id}/contacts/{contact_id}/remove` - delete from `contact_projects`
+   - Same UI pattern as task contacts tab
+
+**Do NOT:**
+- Modify existing working tabs (tasks, notes, links)
+- Build process CRUD
+
+**Test:** Verify at `https://lifeos-dev.invixiom.com/projects/{any_project_id}` that new tabs appear and function.
+
+---
+
+## PROMPT 3: Meeting Detail Page - Add Tabs
+
+**Context:** The meeting detail page at `/meetings/{meeting_id}` exists but may not have the full tabbed layout. It needs tabs for: Notes, Weblinks, Files, Lists, Processes, Contacts + Roles. Meetings already have an action items / tasks relationship via the `meeting_tasks` junction table.
+
+**Codebase facts:**
+- Template: `templates/meeting_detail.html`
+- Router: `routers/meetings.py`
+- `contact_meetings` junction exists: `contact_id, meeting_id, role, created_at` (role values: organizer|attendee|optional)
+- `meeting_tasks` junction exists: `meeting_id, task_id, source` (source: discussed|action_item)
+- `meetings` table has `notes_body` column for inline meeting notes
+- Notes, weblinks, lists don't have a `meeting_id` FK column
+
+**What to build:**
+
+1. **Migration SQL** - Add to same or new migration file:
+   - `ALTER TABLE notes ADD COLUMN meeting_id UUID REFERENCES meetings(id);`
+   - `ALTER TABLE weblinks ADD COLUMN meeting_id UUID REFERENCES meetings(id);`
+   - `ALTER TABLE lists ADD COLUMN meeting_id UUID REFERENCES meetings(id);`
+   - Indexes on new columns.
+   - Apply to `lifeos_dev`.
+
+2. **Router** (`routers/meetings.py`) - Add/extend detail handler with `?tab=` param:
+   - Tabs: overview (existing content: agenda, notes_body, action items), notes, weblinks, files, lists, processes, contacts
+   - Query patterns same as tasks/projects for each tab type
+   - Files via `file_mappings WHERE context_type='meeting'`
+   - Contacts via `contact_meetings` joined to `contacts`
+
+3. **Template** (`templates/meeting_detail.html`) - Restructure to tab layout matching project_detail.html pattern:
+   - Overview tab: existing meeting content (agenda, meeting notes, action items list)
+   - All other tabs: same list + add pattern as task/project detail
+
+4. **Contact + Role management on meetings:**
+   - `POST /meetings/{meeting_id}/contacts/add` - insert into `contact_meetings`, role defaults to "attendee"
+   - `POST /meetings/{meeting_id}/contacts/{contact_id}/remove` - delete from `contact_meetings`
+   - Role dropdown with predefined values: organizer, attendee, optional
+
+**Test:** Verify at `https://lifeos-dev.invixiom.com/meetings/{any_meeting_id}`.
+
+---
+
+## PROMPT 4: Lists Page - Dynamic Domain/Project Filter + Contact Roles
+
+**Context:** The lists page at `/lists/` has domain and project dropdown filters. Currently the project dropdown shows ALL projects regardless of which domain is selected. It should filter dynamically.
+
+**Codebase facts:**
+- Template: `templates/lists.html`
+- Router: `routers/lists.py` (or wherever list CRUD lives)
+- The filter uses HTML `<select>` elements that auto-submit on change (pattern from `app.js`)
+- `projects` table has `domain_id` FK (nullable - some projects may have domain_id = NULL via unassigned area)
+- `areas` table has `domain_id` FK
+- `contact_lists` junction exists: `contact_id, list_id, role, created_at`
+
+**What to build:**
+
+1. **Dynamic project filtering by domain** - Two approaches, pick the simpler one:
+   - **Option A (recommended - vanilla JS):** Add a small JS block to `lists.html` (or `app.js`) that intercepts the domain dropdown `change` event. When domain changes, fetch projects for that domain via a new lightweight API endpoint `GET /api/projects?domain_id={id}` that returns JSON `[{id, name}]`. Rebuild the project `<select>` options dynamically. Include projects where `domain_id` matches OR where `domain_id IS NULL` (unassigned). If no domain selected, show all projects.
+   - **Option B (server-side only):** On domain change, the form auto-submits (existing behavior). The router filters the project dropdown options server-side based on the selected domain_id and passes filtered projects to the template. This is simpler but causes a page reload.
+   - Go with Option A for better UX. Create the API endpoint in the lists router or a shared API router.
+
+2. **Contact + Role management on lists:**
+   - On the list detail page (`list_detail.html`), add a Contacts section (or tab if it has tabs).
+   - `POST /lists/{list_id}/contacts/add` - insert into `contact_lists`
+   - `POST /lists/{list_id}/contacts/{contact_id}/remove` - delete from `contact_lists`
+   - Same UI pattern: contact dropdown + role text input + list with remove buttons.
+
+**Test:** Go to `https://lifeos-dev.invixiom.com/lists/`, select a domain, verify the project dropdown updates to only show projects in that domain plus unassigned ones. Test adding/removing contacts on a list detail page.
+
+---
+
+## PROMPT 5: Eisenhower Page - Dynamic Height + Filters
+
+**Context:** The Eisenhower matrix page at `/eisenhower/` displays tasks in a 2x2 grid (Important+Urgent, Important+Not Urgent, Not Important+Urgent, Not Important+Not Urgent). Currently the quadrant cards have a fixed minimum height which wastes space or clips content.
+
+**Codebase facts:**
+- Template: `templates/eisenhower.html` (if it exists) or it may be part of another template
+- Router: `routers/eisenhower.py` or may be in `routers/tasks.py`
+- CSS in `static/style.css`
+- Current quadrant logic: priority 1-2 = Important, 3-4 = Not Important. Due date <= 7 days = Urgent, > 7 days or null = Not Urgent.
+- Tasks are filtered: only `status IN ('open', 'in_progress', 'blocked')` and `is_deleted = false`
+
+**What to build:**
+
+1. **Dynamic height for quadrant cards:**
+   - Remove any `min-height` or fixed `height` CSS on the Eisenhower quadrant containers.
+   - Use CSS that allows quadrants to grow with content: `min-height: 200px` (reasonable minimum) but no `max-height` restriction. Or use CSS Grid with `grid-template-rows: auto auto` so rows size to content.
+   - Each card within a quadrant should be compact (task title, priority dot, due date - single line or two lines max).
+   - If a quadrant has many tasks, it grows. If empty, it shows a small empty state.
+
+2. **Add filters:**
+   - Add a filter bar above the 2x2 grid with dropdowns for:
+     - **Domain** - filter tasks by domain_id
+     - **Project** - filter tasks by project_id (dynamic based on domain selection, same pattern as Prompt 4)
+     - **Status** - filter by status (open, in_progress, blocked)
+     - **Context** - filter by context (GTD execution context from context_types table)
+   - Filters use query parameters: `/eisenhower/?domain_id=X&project_id=Y&status=Z&context=W`
+   - Router applies these filters to the task query before distributing into quadrants.
+   - Use the same auto-submit-on-change pattern used elsewhere in the app.
+
+**Test:** Verify at `https://lifeos-dev.invixiom.com/eisenhower/` that quadrants resize with content and filters narrow the displayed tasks.
+
+---
+
+## PROMPT 6: Focus Page - Add Domain/Area/Project Filters
+
+**Context:** The focus page at `/focus/` shows the daily focus list (tasks selected for today). Currently there are no filters to narrow which available tasks are shown for adding to focus.
+
+**Codebase facts:**
+- Template: `templates/focus.html`
+- Router: `routers/focus.py`
+- The page has two sections: (1) Today's focus items (tasks already added), (2) Available tasks to add
+- `daily_focus` table: `id, task_id, focus_date, completed, sort_order, is_deleted, created_at`
+- Tasks have `domain_id`, `project_id` FKs. Tasks also have `area_id` FK.
+
+**What to build:**
+
+1. **Filter bar for available tasks section:**
+   - Add dropdowns above the "Available Tasks" section for: Domain, Area (filtered by selected domain), Project (filtered by selected domain/area)
+   - Same dynamic filtering pattern as Prompts 4 and 5
+   - Filters apply only to the "available tasks to add" list, NOT to the already-focused items
+   - Query params: `/focus/?domain_id=X&area_id=Y&project_id=Z&focus_date=YYYY-MM-DD`
+
+2. **Router changes:**
+   - Accept domain_id, area_id, project_id query params
+   - Apply as WHERE clauses when querying available (unfocused) tasks
+   - Pass filter values + dropdown options to template context
+
+**Test:** Verify at `https://lifeos-dev.invixiom.com/focus/` that filter dropdowns appear and narrow the available tasks list.
+
+---
+
+## PROMPT 7: Change History (Recently Changed Items)
+
+**Context:** We need a "Change History" view so the user can see recently modified items across the entire system. Every table in Life OS has `created_at` and `updated_at` TIMESTAMPTZ columns (except `time_entries` which is missing `updated_at`). This gives us a simple approach: query `updated_at` across all entity tables and show a reverse-chronological feed.
+
+**Codebase facts:**
+- All main entity tables have `updated_at`: domains, areas, projects, tasks, notes, contacts, meetings, decisions, lists, weblinks, appointments, links, files, processes, capture
+- `time_entries` does NOT have `updated_at` - exclude from change history
+- BaseRepository handles all CRUD and sets `updated_at = now()` on every update
+- Sidebar navigation is built in `core/sidebar.py`
+
+**What to build:**
+
+1. **New router:** Create `routers/history.py` with prefix `/history`
+   - `GET /history/` - renders the change history page
+   - Query: For each entity table, `SELECT id, 'entity_type' as type, title/name as label, updated_at, created_at FROM {table} WHERE is_deleted = false ORDER BY updated_at DESC LIMIT 20`
+   - Union all results, sort by `updated_at DESC`, take top 50 (or paginate)
+   - For each item, determine if it was "created" (updated_at = created_at or within 1 second) or "modified"
+   - Pass to template as a list of `{type, id, label, updated_at, action}` dicts
+
+2. **Template:** Create `templates/history.html`
+   - Page title: "Change History" or "Recent Changes"
+   - Filter by: entity type dropdown, date range
+   - Each row shows: timestamp, action icon (created/modified), entity type badge, item name as clickable link to detail page, relative time ("2 minutes ago", "yesterday")
+   - Use the standard list-row styling
+
+3. **Sidebar link:** Add "History" to the sidebar navigation in `core/sidebar.py` (or `base.html` directly), in the utility section near Search/Capture/Admin.
+
+4. **Register router** in `main.py`: `app.include_router(history.router)`
+
+**Architecture note:** This is NOT a full audit log with field-level diffs. It's a simple "what changed recently" view derived from `updated_at` timestamps. A full audit log (with before/after values) would require triggers or middleware - defer that to a later phase.
+
+**Test:** Verify at `https://lifeos-dev.invixiom.com/history/` that recently created/modified items appear in reverse chronological order with working links.
+
+---
+
+## PROMPT 8: Fix Search - Partial Word Matching
+
+**Context:** The global search currently uses PostgreSQL `tsvector/tsquery` full-text search. This is great for natural language search but does NOT support partial word matching. Searching for "Sys" does not return items containing "System" because tsquery requires complete lexemes.
+
+**Codebase facts:**
+- Search router: `routers/search.py`
+- API endpoint: `GET /search/api?q=X&entity_type=Y&limit=Z`
+- Page endpoint: `GET /search/?q=X`
+- Every searchable table has a `search_vector TSVECTOR` column with GIN index
+- Search triggers maintain the tsvector automatically
+- Current query pattern likely uses `plainto_tsquery('english', query)` or `to_tsquery`
+
+**The fix:**
+
+The search needs to support partial prefix matching. PostgreSQL supports this via `:*` suffix on tsquery terms.
+
+1. **Modify the search query building** in `routers/search.py`:
+   - Instead of `plainto_tsquery('english', query)`, build a prefix query
+   - For a search term like "Sys", construct: `to_tsquery('english', 'Sys:*')`
+   - For multi-word queries like "Sys Admin", construct: `to_tsquery('english', 'Sys:* & Admin:*')` (AND all terms with prefix matching)
+   - Implementation: split the query string on whitespace, strip non-alphanumeric chars from each term, append `:*` to each, join with ` & `
+   - Handle edge cases: empty query, single character (skip search for < 2 chars), special characters
+
+2. **Also add an ILIKE fallback** for when tsvector doesn't match (tsvector strips stop words and stems, so very short or unusual terms might not match):
+   - After the tsvector query, if results are sparse (< 3 results), do a supplemental `WHERE title ILIKE '%{query}%' OR name ILIKE '%{query}%'` query
+   - Deduplicate results (tsvector results first, then ILIKE additions)
+   - This ensures "Sys" matches "System" even if the stemmer does something unexpected
+
+3. **Update the search query for EACH entity** that's searched. The pattern should be consistent - build a helper function like:
+   ```python
+   def build_search_condition(query: str):
+       terms = query.strip().split()
+       if not terms:
+           return None
+       tsquery_str = ' & '.join(f"{term}:*" for term in terms if len(term) >= 2)
+       return tsquery_str
+   ```
+
+**Do NOT:**
+- Change the search_vector triggers or GIN indexes (they're fine)
+- Add any new database tables
+- Change the search UI/template (just the backend query logic)
+
+**Test:** Go to `https://lifeos-dev.invixiom.com/search/?q=Sys` and verify it returns items containing "System", "Systematic", "Sys" etc. Test with "Inv" to match "Invoice", "Investment" etc.
+
+---
+
+## General Notes for All Prompts
+
+- **Git:** After each prompt's changes are verified working, run: `cd /opt/lifeos/dev && git add . && git commit -m "descriptive message" && git push origin main`
+- **Database migrations:** Always apply to `lifeos_dev` only. Command pattern: `docker exec -i lifeos-db psql -U postgres -d lifeos_dev < migration_file.sql`
+- **Restart if needed:** `docker restart lifeos-dev` (though hot reload should handle most changes)
+- **Logs:** `docker logs lifeos-dev --tail 30` to debug errors
+- **Contact role pattern:** For now, roles are free-text on tasks/projects/lists. On meetings, roles are constrained to: organizer, attendee, optional. This will be standardized later with a defined role set.
+- **Empty states:** Every tab/section that can be empty should show a clean empty state message with a CTA button to add the first item.
diff --git a/main.py b/main.py
index 66cb615..6deb1bd 100644
--- a/main.py
+++ b/main.py
@@ -43,6 +43,7 @@ from routers import (
     calendar as calendar_router,
     time_budgets as time_budgets_router,
     eisenhower as eisenhower_router,
+    history as history_router,
 )
 
 
@@ -201,3 +202,4 @@ app.include_router(processes_router.router)
 app.include_router(calendar_router.router)
 app.include_router(time_budgets_router.router)
 app.include_router(eisenhower_router.router)
+app.include_router(history_router.router)
diff --git a/project-docs/lifeos-system-design-document.md b/project-docs/lifeos-system-design-document.md
new file mode 100644
index 0000000..5054128
--- /dev/null
+++ b/project-docs/lifeos-system-design-document.md
@@ -0,0 +1,2068 @@
+# Life OS - Comprehensive System Design Document
+
+**Version:** 1.0
+**Date:** 2026-03-02
+**Purpose:** Complete rebuild reference. Contains everything needed to reconstruct this system from ground zero.
+
+---
+
+# Part 1: System Overview
+
+## 1. Project Identity & Purpose
+
+Life OS is a **single-user personal productivity web application**. It is a unified system for managing every dimension of personal productivity: tasks, projects, notes, contacts, meetings, decisions, time tracking, file management, and more.
+
+**Design Philosophy:**
+- **KISS.** Simple wins. Complexity must earn its place.
+- **Logical deletes everywhere.** No data permanently destroyed without admin confirmation.
+- **Generic over specific.** Shared base code. Config-driven where possible.
+- **Consistent patterns.** Every list, form, detail view follows identical conventions.
+- **Search is first-class.** Every entity gets PostgreSQL full-text search via tsvector/tsquery.
+- **Context travels with navigation.** Drill-down pre-fills context into create forms.
+- **Single source of truth.** One system for everything.
+
+**Live URL:** `https://lifeos-dev.invixiom.com`
+**Server:** defiant-01, 46.225.166.142, Ubuntu 24.04
+**Repository:** `github.com/mdombaugh/lifeos-dev` (main branch)
+
+---
+
+## 2. Architecture Overview
+
+Life OS is a **server-rendered monolith**. There is no SPA, no frontend framework, and no build pipeline.
+
+**Key Architectural Decisions:**
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| Rendering | Server-side (Jinja2) | Simplicity; no JS framework to maintain |
+| Data mutations | HTML form POST with 303 redirect (PRG) | Standard web pattern; no XHR/fetch for data ops |
+| JavaScript role | UI state only (sidebar, search, timer, theme) | Minimal client JS; zero fetch for data changes |
+| ORM | None. Raw SQL via `text()` | Full control; no migration tooling needed |
+| CRUD abstraction | Generic BaseRepository class | One class handles all 48 tables |
+| Deletion | Soft delete everywhere | `is_deleted` + `deleted_at`; admin trash for recovery |
+| Search | PostgreSQL tsvector/tsquery | Built-in, no external search service |
+| Authentication | None (single user) | Phase 3 roadmap item |
+| CSRF | None (single user) | Not needed for single-user system |
+
+**Request Flow:**
+```
+Browser → Nginx (SSL termination) → Docker container (uvicorn) → FastAPI router
+  → BaseRepository / raw SQL → PostgreSQL → Jinja2 template → HTML response
+```
+
+**Data Mutation Flow (PRG Pattern):**
+```
+Browser submits HTML <form> via POST → Router processes Form() params
+  → BaseRepository.create/update/soft_delete → 303 redirect → GET page
+```
+
+---
+
+## 3. Technology Stack
+
+Every dependency with exact version:
+
+### Python Dependencies (requirements.txt)
+
+| Package | Version | Purpose |
+|---------|---------|---------|
+| fastapi | 0.115.6 | Web framework (async) |
+| uvicorn[standard] | 0.34.0 | ASGI server with hot reload |
+| sqlalchemy[asyncio] | 2.0.36 | SQL toolkit (async engine, `text()` only - NO ORM models) |
+| asyncpg | 0.30.0 | PostgreSQL async driver |
+| jinja2 | 3.1.4 | Template engine |
+| python-multipart | 0.0.18 | Form data parsing |
+| python-dotenv | 1.0.1 | Environment variable loading |
+| pydantic | 2.10.3 | Data validation (FastAPI dependency) |
+| pyyaml | 6.0.2 | Configuration parsing |
+| aiofiles | 24.1.0 | Async file I/O for uploads |
+
+### Infrastructure
+
+| Component | Version | Purpose |
+|-----------|---------|---------|
+| Python | 3.12-slim (Docker) | Application runtime |
+| PostgreSQL | 16-alpine (Docker) | Database (3 databases: dev, prod, test) |
+| Nginx | Host-level (Ubuntu) | Reverse proxy, SSL termination |
+| Docker | Host-level | Container runtime |
+| Let's Encrypt | Auto-renew | SSL certificates |
+
+### Frontend (Zero Build)
+
+| Component | Source | Purpose |
+|-----------|--------|---------|
+| Vanilla CSS | `/static/style.css` | All styling, ~1200 lines |
+| Vanilla JS | `/static/app.js` | UI interactions only, ~190 lines |
+| DM Sans | Google Fonts CDN | Body font |
+| JetBrains Mono | Google Fonts CDN | Code/monospace font |
+
+**Hard Rules:**
+- No npm. No React. No Tailwind. No build tools.
+- No fetch/XHR for data mutations. Forms use standard POST with 303 redirect.
+- JavaScript handles ONLY: sidebar collapse, search modal, timer display, theme toggle, mobile nav, filter auto-submit, delete confirmation.
+
+---
+
+# Part 2: Infrastructure
+
+## 4. Server & Network Topology
+
+**Server:** defiant-01 (46.225.166.142)
+**OS:** Ubuntu 24.04
+**Network:** `lifeos_network` (Docker bridge, 172.21.0.0/16)
+
+```
+                    Internet
+                       │
+                       ▼
+              ┌────────────────┐
+              │  Nginx (host)  │  SSL termination
+              │  Port 80/443   │
+              └───────┬────────┘
+                      │
+         ┌────────────┴────────────┐
+         │                         │
+         ▼                         ▼
+┌─────────────────┐     ┌──────────────────┐
+│  lifeos-dev     │     │  lifeos-prod     │
+│  Port 8003      │     │  Port 8002       │
+│  (hot reload)   │     │  (not yet deployed)
+└────────┬────────┘     └────────┬─────────┘
+         │                       │
+         └───────────┬───────────┘
+                     ▼
+            ┌─────────────────┐
+            │   lifeos-db     │
+            │   PostgreSQL 16 │
+            │   Port 5432     │
+            │   (internal)    │
+            └─────────────────┘
+```
+
+---
+
+## 5. Docker Configuration
+
+### Dockerfile
+
+```dockerfile
+FROM python:3.12-slim
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+RUN mkdir -p /opt/lifeos/files
+
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"]
+```
+
+### Container Run Commands
+
+**Dev Container (hot reload, volume mount):**
+```bash
+docker run -d \
+  --name lifeos-dev \
+  --network lifeos_network \
+  --restart unless-stopped \
+  --env-file .env \
+  -p 8003:8003 \
+  -v /opt/lifeos/dev/files:/opt/lifeos/files/dev \
+  -v /opt/lifeos/dev:/app \
+  lifeos-app \
+  uvicorn main:app --host 0.0.0.0 --port 8003 --workers 1 --reload
+```
+
+The volume mount `-v /opt/lifeos/dev:/app` means any file change on the host is immediately visible inside the container. Combined with `--reload`, uvicorn detects changes and restarts automatically. No container rebuild needed.
+
+**Database Container:**
+```bash
+docker run -d \
+  --name lifeos-db \
+  --network lifeos_network \
+  --restart unless-stopped \
+  -e POSTGRES_PASSWORD=UCTOQDZiUhN8U \
+  -v lifeos_pgdata:/var/lib/postgresql/data \
+  postgres:16-alpine
+```
+
+### Environment Variables (.env)
+
+```
+DATABASE_URL=postgresql+asyncpg://postgres:UCTOQDZiUhN8U@lifeos-db:5432/lifeos_dev
+FILE_STORAGE_PATH=/opt/lifeos/files/dev
+ENVIRONMENT=development
+```
+
+---
+
+## 6. Nginx & SSL
+
+**Config location:** `/etc/nginx/sites-available/invixiom`
+
+**Domain routing:**
+- `lifeos-dev.invixiom.com` → `localhost:8003` (dev)
+- `lifeos.invixiom.com` → `localhost:8002` (prod, pending)
+
+**SSL certificate path:** `/etc/letsencrypt/live/kasm.invixiom.com-0001/`
+
+Note: The cert uses the `kasm.invixiom.com-0001` path (not `kasm.invixiom.com`). This is a known quirk of the Let's Encrypt renewal structure on this server.
+
+---
+
+## 7. Database Configuration
+
+**Three databases in lifeos-db:**
+
+| Database | Purpose | Used By |
+|----------|---------|---------|
+| `lifeos_dev` | Active development | lifeos-dev container |
+| `lifeos_prod` | Production data (DO NOT TOUCH) | lifeos-prod container |
+| `lifeos_test` | Test suite | pytest via `tests/conftest.py` |
+
+**Connection pooling (SQLAlchemy):**
+```python
+engine = create_async_engine(
+    DATABASE_URL,
+    echo=os.getenv("ENVIRONMENT") == "development",
+    pool_size=5,
+    max_overflow=10,
+    pool_pre_ping=True,
+)
+```
+
+**Session management:**
+```python
+async_session_factory = async_sessionmaker(
+    engine, class_=AsyncSession, expire_on_commit=False,
+)
+
+async def get_db():
+    async with async_session_factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+```
+
+---
+
+# Part 3: Database Schema
+
+## 8. Schema Conventions
+
+Every table follows these universal conventions:
+
+### Standard Column Set
+```sql
+id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+-- [entity-specific columns]
+tags            TEXT[],                              -- Array of string tags
+sort_order      INT NOT NULL DEFAULT 0,              -- Manual ordering
+is_deleted      BOOL NOT NULL DEFAULT false,          -- Soft delete flag
+deleted_at      TIMESTAMPTZ,                          -- When soft-deleted
+created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),   -- Auto-set on insert
+updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()    -- Auto-set on update
+```
+
+### Searchable Tables Add
+```sql
+search_vector   TSVECTOR                              -- Full-text search column
+-- Plus GIN index:
+CREATE INDEX idx_tablename_search ON tablename USING GIN(search_vector);
+-- Plus trigger:
+CREATE TRIGGER trg_tablename_search
+    BEFORE INSERT OR UPDATE ON tablename
+    FOR EACH ROW EXECUTE FUNCTION update_tablename_search();
+```
+
+### Soft Delete Pattern
+- `is_deleted = false` filter applied automatically by BaseRepository
+- `deleted_at` timestamp records when deletion occurred
+- `soft_delete()` sets both fields
+- `restore()` clears both fields
+- `permanent_delete()` does actual SQL DELETE (admin only)
+
+### Foreign Key Conventions
+- Required parent references use `ON DELETE CASCADE`
+- Optional references use `ON DELETE SET NULL`
+- Junction tables use composite PKs with CASCADE on both sides
+
+---
+
+## 9. Core Entity Tables (31 tables)
+
+### domains
+Life areas at the highest level (e.g., "Career", "Health", "Family").
+```sql
+CREATE TABLE domains (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name            TEXT NOT NULL,
+    color           TEXT,                    -- Hex color for UI badges
+    description     TEXT,
+    icon            TEXT,
+    sort_order      INT NOT NULL DEFAULT 0,
+    is_deleted      BOOL NOT NULL DEFAULT false,
+    deleted_at      TIMESTAMPTZ,
+    search_vector   TSVECTOR,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_domains_search ON domains USING GIN(search_vector);
+CREATE INDEX idx_domains_sort ON domains USING btree(sort_order);
+```
+**Search trigger:** Indexes `name`.
+
+### areas
+Subcategories within domains (e.g., "Software Engineering" under "Career").
+```sql
+CREATE TABLE areas (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    domain_id       UUID NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
+    name            TEXT NOT NULL,
+    description     TEXT,
+    icon            TEXT,
+    color           TEXT,
+    status          TEXT NOT NULL DEFAULT 'active',
+    sort_order      INT NOT NULL DEFAULT 0,
+    is_deleted      BOOL NOT NULL DEFAULT false,
+    deleted_at      TIMESTAMPTZ,
+    search_vector   TSVECTOR,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_areas_search ON areas USING GIN(search_vector);
+CREATE INDEX idx_areas_sort ON areas USING btree(domain_id, sort_order);
+```
+**Search trigger:** Indexes `name`, `description`.
+
+### projects
+Concrete initiatives with status tracking and timelines.
+```sql
+CREATE TABLE projects (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    domain_id       UUID NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
+    area_id         UUID REFERENCES areas(id) ON DELETE SET NULL,
+    name            TEXT NOT NULL,
+    description     TEXT,
+    status          TEXT NOT NULL DEFAULT 'active',  -- active|on_hold|completed|archived
+    priority        INT NOT NULL DEFAULT 3,           -- 1=critical, 2=high, 3=normal, 4=low
+    start_date      DATE,
+    target_date     DATE,
+    completed_at    TIMESTAMPTZ,
+    color           TEXT,
+    tags            TEXT[],
+    sort_order      INT NOT NULL DEFAULT 0,
+    is_deleted      BOOL NOT NULL DEFAULT false,
+    deleted_at      TIMESTAMPTZ,
+    search_vector   TSVECTOR,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_projects_search ON projects USING GIN(search_vector);
+CREATE INDEX idx_projects_sort ON projects USING btree(domain_id, sort_order);
+CREATE INDEX idx_projects_area_sort ON projects USING btree(area_id, sort_order);
+CREATE INDEX idx_projects_status ON projects USING btree(status);
+```
+**Search trigger:** Indexes `name`, `description`, `tags`.
+
+### tasks
+The core work unit. Supports subtasks, contexts, time estimates, and status workflow.
+```sql
+CREATE TABLE tasks (
+    id                     UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    domain_id              UUID REFERENCES domains(id) ON DELETE CASCADE,
+    area_id                UUID REFERENCES areas(id) ON DELETE SET NULL,
+    project_id             UUID REFERENCES projects(id) ON DELETE SET NULL,
+    release_id             UUID REFERENCES releases(id) ON DELETE SET NULL,
+    parent_id              UUID REFERENCES tasks(id) ON DELETE SET NULL,  -- Subtask support
+    title                  TEXT NOT NULL,
+    description            TEXT,
+    priority               INT NOT NULL DEFAULT 3,           -- 1=critical..4=low
+    status                 TEXT NOT NULL DEFAULT 'open',     -- open|in_progress|blocked|done|cancelled
+    due_date               DATE,
+    deadline               TIMESTAMPTZ,
+    recurrence             TEXT,
+    estimated_minutes      INT,
+    energy_required        TEXT,                              -- high|medium|low
+    context                TEXT,                              -- @home, @office, @errands, etc.
+    is_custom_context      BOOL NOT NULL DEFAULT false,
+    waiting_for_contact_id UUID REFERENCES contacts(id) ON DELETE SET NULL,
+    waiting_since          DATE,
+    import_batch_id        UUID,
+    tags                   TEXT[],
+    sort_order             INT NOT NULL DEFAULT 0,
+    is_deleted             BOOL NOT NULL DEFAULT false,
+    deleted_at             TIMESTAMPTZ,
+    completed_at           TIMESTAMPTZ,
+    search_vector          TSVECTOR,
+    created_at             TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at             TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_tasks_search ON tasks USING GIN(search_vector);
+CREATE INDEX idx_tasks_status ON tasks USING btree(status);
+CREATE INDEX idx_tasks_priority ON tasks USING btree(priority);
+CREATE INDEX idx_tasks_due_date ON tasks USING btree(due_date);
+CREATE INDEX idx_tasks_domain_sort ON tasks USING btree(domain_id, sort_order);
+CREATE INDEX idx_tasks_project_sort ON tasks USING btree(project_id, sort_order);
+CREATE INDEX idx_tasks_parent_sort ON tasks USING btree(parent_id, sort_order);
+```
+**Search trigger:** Indexes `title`, `description`, `tags`.
+
+### notes
+Markdown-based notes linked to domains, projects, tasks, meetings, or folders.
+```sql
+CREATE TABLE notes (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    domain_id       UUID REFERENCES domains(id) ON DELETE CASCADE,
+    project_id      UUID REFERENCES projects(id) ON DELETE SET NULL,
+    folder_id       UUID REFERENCES note_folders(id) ON DELETE SET NULL,
+    meeting_id      UUID REFERENCES meetings(id) ON DELETE SET NULL,
+    task_id         UUID REFERENCES tasks(id) ON DELETE SET NULL,
+    title           TEXT NOT NULL,
+    body            TEXT,
+    content_format  TEXT NOT NULL DEFAULT 'rich',
+    is_meeting_note BOOL NOT NULL DEFAULT false,
+    tags            TEXT[],
+    sort_order      INT NOT NULL DEFAULT 0,
+    is_deleted      BOOL NOT NULL DEFAULT false,
+    deleted_at      TIMESTAMPTZ,
+    search_vector   TSVECTOR,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_notes_search ON notes USING GIN(search_vector);
+CREATE INDEX idx_notes_task_id ON notes USING btree(task_id);
+```
+**Search trigger:** Indexes `title`, `body`, `tags`.
+
+### note_folders
+Hierarchical folder system for organizing notes.
+```sql
+CREATE TABLE note_folders (
+    id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    parent_id      UUID REFERENCES note_folders(id) ON DELETE CASCADE,
+    name           TEXT NOT NULL,
+    auto_generated BOOL NOT NULL DEFAULT false,
+    sort_order     INT NOT NULL DEFAULT 0,
+    is_deleted     BOOL NOT NULL DEFAULT false,
+    deleted_at     TIMESTAMPTZ,
+    created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at     TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### lists
+Checklists and general-purpose lists linked to domains, projects, tasks, or meetings.
+```sql
+CREATE TABLE lists (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    domain_id     UUID REFERENCES domains(id) ON DELETE CASCADE,
+    area_id       UUID REFERENCES areas(id) ON DELETE SET NULL,
+    project_id    UUID REFERENCES projects(id) ON DELETE SET NULL,
+    task_id       UUID REFERENCES tasks(id) ON DELETE SET NULL,
+    meeting_id    UUID REFERENCES meetings(id) ON DELETE SET NULL,
+    name          TEXT NOT NULL,
+    list_type     TEXT NOT NULL DEFAULT 'checklist',
+    description   TEXT,
+    tags          TEXT[],
+    sort_order    INT NOT NULL DEFAULT 0,
+    is_deleted    BOOL NOT NULL DEFAULT false,
+    deleted_at    TIMESTAMPTZ,
+    search_vector TSVECTOR,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_lists_search ON lists USING GIN(search_vector);
+CREATE INDEX idx_lists_task_id ON lists USING btree(task_id);
+CREATE INDEX idx_lists_meeting_id ON lists USING btree(meeting_id);
+```
+**Search trigger:** Indexes `name`, `description`, `tags`.
+
+### list_items
+Individual items within a list. Supports nesting via `parent_item_id`.
+```sql
+CREATE TABLE list_items (
+    id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    list_id        UUID NOT NULL REFERENCES lists(id) ON DELETE CASCADE,
+    parent_item_id UUID REFERENCES list_items(id) ON DELETE SET NULL,
+    content        TEXT NOT NULL,
+    completed      BOOL NOT NULL DEFAULT false,
+    completed_at   TIMESTAMPTZ,
+    sort_order     INT NOT NULL DEFAULT 0,
+    is_deleted     BOOL NOT NULL DEFAULT false,
+    deleted_at     TIMESTAMPTZ,
+    created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at     TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_list_items_sort ON list_items USING btree(list_id, sort_order);
+CREATE INDEX idx_list_items_parent_sort ON list_items USING btree(parent_item_id, sort_order);
+```
+
+### links
+Quick-access bookmarks organized by domain/area/project.
+```sql
+CREATE TABLE links (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    domain_id     UUID REFERENCES domains(id) ON DELETE CASCADE,
+    area_id       UUID REFERENCES areas(id) ON DELETE SET NULL,
+    project_id    UUID REFERENCES projects(id) ON DELETE SET NULL,
+    label         TEXT NOT NULL,
+    url           TEXT NOT NULL,
+    description   TEXT,
+    tags          TEXT[],
+    sort_order    INT NOT NULL DEFAULT 0,
+    is_deleted    BOOL NOT NULL DEFAULT false,
+    deleted_at    TIMESTAMPTZ,
+    search_vector TSVECTOR,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_links_search ON links USING GIN(search_vector);
+```
+**Search trigger:** Indexes `label`, `url`, `description`, `tags`.
+
+### files
+Uploaded file metadata. Actual files stored on disk at `FILE_STORAGE_PATH`.
+```sql
+CREATE TABLE files (
+    id                UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    filename          TEXT NOT NULL,          -- Stored filename (UUID-based)
+    original_filename TEXT NOT NULL,          -- User's original filename
+    storage_path      TEXT NOT NULL,          -- Full disk path
+    mime_type         TEXT,
+    size_bytes        INT,
+    description       TEXT,
+    tags              TEXT[],
+    sort_order        INT NOT NULL DEFAULT 0,
+    is_deleted        BOOL NOT NULL DEFAULT false,
+    deleted_at        TIMESTAMPTZ,
+    search_vector     TSVECTOR,
+    created_at        TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at        TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_files_search ON files USING GIN(search_vector);
+```
+**Search trigger:** Indexes `original_filename`, `description`, `tags`.
+
+### weblinks
+Similar to links but with task/meeting association and folder organization.
+```sql
+CREATE TABLE weblinks (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    label         TEXT NOT NULL,
+    url           TEXT NOT NULL,
+    description   TEXT,
+    task_id       UUID REFERENCES tasks(id) ON DELETE SET NULL,
+    meeting_id    UUID REFERENCES meetings(id) ON DELETE SET NULL,
+    tags          TEXT[],
+    sort_order    INT NOT NULL DEFAULT 0,
+    is_deleted    BOOL NOT NULL DEFAULT false,
+    deleted_at    TIMESTAMPTZ,
+    search_vector TSVECTOR,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_weblinks_search ON weblinks USING GIN(search_vector);
+CREATE INDEX idx_weblinks_task_id ON weblinks USING btree(task_id);
+CREATE INDEX idx_weblinks_meeting_id ON weblinks USING btree(meeting_id);
+```
+**Search trigger:** Indexes `label`, `url`, `description`, `tags`.
+
+### weblink_folders
+Hierarchical folder system for organizing weblinks.
+```sql
+CREATE TABLE weblink_folders (
+    id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    parent_id      UUID REFERENCES weblink_folders(id) ON DELETE CASCADE,
+    name           TEXT NOT NULL,
+    auto_generated BOOL NOT NULL DEFAULT false,
+    sort_order     INT NOT NULL DEFAULT 0,
+    is_deleted     BOOL NOT NULL DEFAULT false,
+    deleted_at     TIMESTAMPTZ,
+    created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at     TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_weblink_folders_sort ON weblink_folders USING btree(parent_id, sort_order);
+```
+
+### contacts
+People linked to tasks, projects, meetings, and decisions.
+```sql
+CREATE TABLE contacts (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    first_name    TEXT NOT NULL,
+    last_name     TEXT,
+    company       TEXT,
+    role          TEXT,
+    email         TEXT,
+    phone         TEXT,
+    notes         TEXT,
+    tags          TEXT[],
+    sort_order    INT NOT NULL DEFAULT 0,
+    is_deleted    BOOL NOT NULL DEFAULT false,
+    deleted_at    TIMESTAMPTZ,
+    search_vector TSVECTOR,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_contacts_search ON contacts USING GIN(search_vector);
+```
+**Search trigger:** Indexes `first_name`, `last_name`, `company`, `email`, `tags`.
+
+### appointments
+Calendar events with start/end times and recurrence.
+```sql
+CREATE TABLE appointments (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    title         TEXT NOT NULL,
+    description   TEXT,
+    location      TEXT,
+    start_at      TIMESTAMPTZ NOT NULL,
+    end_at        TIMESTAMPTZ,
+    all_day       BOOL NOT NULL DEFAULT false,
+    recurrence    TEXT,
+    tags          TEXT[],
+    sort_order    INT NOT NULL DEFAULT 0,
+    is_deleted    BOOL NOT NULL DEFAULT false,
+    deleted_at    TIMESTAMPTZ,
+    search_vector TSVECTOR,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_appointments_search ON appointments USING GIN(search_vector);
+CREATE INDEX idx_appointments_start ON appointments USING btree(start_at);
+```
+**Search trigger:** Indexes `title`, `description`, `location`, `tags`.
+
+### meetings
+Meetings with agenda, transcript, notes, and linked action items.
+```sql
+CREATE TABLE meetings (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    parent_id     UUID REFERENCES meetings(id) ON DELETE SET NULL,  -- Recurring meeting series
+    title         TEXT NOT NULL,
+    meeting_date  DATE NOT NULL,
+    start_at      TIMESTAMPTZ,
+    end_at        TIMESTAMPTZ,
+    location      TEXT,
+    status        TEXT NOT NULL DEFAULT 'scheduled',  -- scheduled|completed|cancelled
+    priority      INT,
+    recurrence    TEXT,
+    agenda        TEXT,
+    transcript    TEXT,
+    notes_body    TEXT,
+    tags          TEXT[],
+    sort_order    INT NOT NULL DEFAULT 0,
+    is_deleted    BOOL NOT NULL DEFAULT false,
+    deleted_at    TIMESTAMPTZ,
+    search_vector TSVECTOR,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_meetings_search ON meetings USING GIN(search_vector);
+CREATE INDEX idx_meetings_date ON meetings USING btree(meeting_date);
+```
+**Search trigger:** Indexes `title`, `agenda`, `notes_body`, `tags`.
+
+### decisions
+Decision records with rationale, impact, status, and optional supersession chain.
+```sql
+CREATE TABLE decisions (
+    id               UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    title            TEXT NOT NULL,
+    rationale        TEXT,
+    status           TEXT NOT NULL DEFAULT 'proposed',  -- proposed|accepted|rejected|superseded
+    impact           TEXT NOT NULL DEFAULT 'medium',    -- low|medium|high
+    decided_at       DATE,
+    task_id          UUID REFERENCES tasks(id) ON DELETE SET NULL,
+    meeting_id       UUID REFERENCES meetings(id) ON DELETE SET NULL,
+    superseded_by_id UUID REFERENCES decisions(id) ON DELETE SET NULL,
+    tags             TEXT[],
+    sort_order       INT NOT NULL DEFAULT 0,
+    is_deleted       BOOL NOT NULL DEFAULT false,
+    deleted_at       TIMESTAMPTZ,
+    search_vector    TSVECTOR,
+    created_at       TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at       TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_decisions_search ON decisions USING GIN(search_vector);
+CREATE INDEX idx_decisions_task_id ON decisions USING btree(task_id);
+```
+**Search trigger:** Indexes `title`, `rationale`, `tags`.
+
+### time_entries
+Time tracking records. **Note:** No `updated_at` column - this is a known exception.
+```sql
+CREATE TABLE time_entries (
+    id               UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    task_id          UUID NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    start_at         TIMESTAMPTZ NOT NULL,
+    end_at           TIMESTAMPTZ,           -- NULL = timer is running
+    duration_minutes INT,
+    notes            TEXT,
+    is_deleted       BOOL NOT NULL DEFAULT false,
+    deleted_at       TIMESTAMPTZ,
+    created_at       TIMESTAMPTZ NOT NULL DEFAULT now()
+    -- NO updated_at column! BaseRepository.soft_delete() will fail. Use direct SQL.
+);
+CREATE INDEX idx_time_entries_task ON time_entries USING btree(task_id);
+```
+
+### time_blocks
+Scheduled time blocks for planning (distinct from time_entries which track actual work).
+```sql
+CREATE TABLE time_blocks (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    task_id    UUID REFERENCES tasks(id) ON DELETE SET NULL,
+    title      TEXT NOT NULL,
+    context    TEXT,
+    energy     TEXT,
+    start_at   TIMESTAMPTZ NOT NULL,
+    end_at     TIMESTAMPTZ NOT NULL,
+    is_deleted BOOL NOT NULL DEFAULT false,
+    deleted_at TIMESTAMPTZ,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### time_budgets
+Weekly hour allocations per domain with effective dating.
+```sql
+CREATE TABLE time_budgets (
+    id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    domain_id      UUID NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
+    weekly_hours   NUMERIC NOT NULL,
+    effective_from DATE NOT NULL,
+    sort_order     INT NOT NULL DEFAULT 0,
+    is_deleted     BOOL NOT NULL DEFAULT false,
+    deleted_at     TIMESTAMPTZ,
+    created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at     TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### daily_focus
+Links tasks to specific dates as "focus items" for that day.
+```sql
+CREATE TABLE daily_focus (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    focus_date DATE NOT NULL,
+    task_id    UUID NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    slot       INT,
+    completed  BOOL NOT NULL DEFAULT false,
+    note       TEXT,
+    sort_order INT NOT NULL DEFAULT 0,
+    is_deleted BOOL NOT NULL DEFAULT false,
+    deleted_at TIMESTAMPTZ,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_daily_focus_date ON daily_focus USING btree(focus_date);
+```
+
+### processes
+Template definitions for repeatable workflows/checklists.
+```sql
+CREATE TABLE processes (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name          TEXT NOT NULL,
+    description   TEXT,
+    process_type  TEXT NOT NULL DEFAULT 'checklist',  -- workflow|checklist
+    category      TEXT,
+    status        TEXT NOT NULL DEFAULT 'draft',       -- draft|active|archived
+    tags          TEXT[],
+    sort_order    INT NOT NULL DEFAULT 0,
+    is_deleted    BOOL NOT NULL DEFAULT false,
+    deleted_at    TIMESTAMPTZ,
+    search_vector TSVECTOR,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_processes_search ON processes USING GIN(search_vector);
+```
+**Search trigger:** Indexes `name`, `description`, `tags`.
+
+### process_steps
+Individual steps within a process template.
+```sql
+CREATE TABLE process_steps (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    process_id      UUID NOT NULL REFERENCES processes(id) ON DELETE CASCADE,
+    title           TEXT NOT NULL,
+    instructions    TEXT,
+    expected_output TEXT,
+    estimated_days  INT,
+    context         TEXT,
+    sort_order      INT NOT NULL DEFAULT 0,
+    is_deleted      BOOL NOT NULL DEFAULT false,
+    deleted_at      TIMESTAMPTZ,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### process_runs
+Instances of running a process. Copies steps as immutable snapshots.
+```sql
+CREATE TABLE process_runs (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    process_id      UUID NOT NULL REFERENCES processes(id) ON DELETE CASCADE,
+    title           TEXT NOT NULL,
+    status          TEXT NOT NULL DEFAULT 'not_started',  -- not_started|in_progress|completed|cancelled
+    process_type    TEXT NOT NULL,
+    task_generation TEXT NOT NULL DEFAULT 'all_at_once',  -- all_at_once|step_by_step
+    project_id      UUID REFERENCES projects(id) ON DELETE SET NULL,
+    contact_id      UUID REFERENCES contacts(id) ON DELETE SET NULL,
+    started_at      TIMESTAMPTZ,
+    completed_at    TIMESTAMPTZ,
+    sort_order      INT NOT NULL DEFAULT 0,
+    is_deleted      BOOL NOT NULL DEFAULT false,
+    deleted_at      TIMESTAMPTZ,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### process_run_steps
+Immutable step copies within a run, with completion tracking.
+```sql
+CREATE TABLE process_run_steps (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    run_id          UUID NOT NULL REFERENCES process_runs(id) ON DELETE CASCADE,
+    title           TEXT NOT NULL,
+    instructions    TEXT,
+    status          TEXT NOT NULL DEFAULT 'pending',  -- pending|in_progress|completed|skipped
+    completed_by_id UUID REFERENCES contacts(id) ON DELETE SET NULL,
+    completed_at    TIMESTAMPTZ,
+    notes           TEXT,
+    sort_order      INT NOT NULL DEFAULT 0,
+    is_deleted      BOOL NOT NULL DEFAULT false,
+    deleted_at      TIMESTAMPTZ,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### capture
+Quick-capture inbox for unprocessed thoughts/items.
+```sql
+CREATE TABLE capture (
+    id                UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    raw_text          TEXT NOT NULL,
+    processed         BOOL NOT NULL DEFAULT false,
+    converted_to_type TEXT,          -- task|note|project|contact|decision|weblink|list_item
+    converted_to_id   UUID,
+    area_id           UUID REFERENCES areas(id) ON DELETE SET NULL,
+    project_id        UUID REFERENCES projects(id) ON DELETE SET NULL,
+    list_id           UUID REFERENCES lists(id) ON DELETE SET NULL,
+    import_batch_id   UUID,
+    sort_order        INT NOT NULL DEFAULT 0,
+    is_deleted        BOOL NOT NULL DEFAULT false,
+    deleted_at        TIMESTAMPTZ,
+    created_at        TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at        TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_capture_processed ON capture USING btree(processed);
+```
+
+### context_types
+System-defined context labels for tasks (e.g., @home, @office, @errands).
+```sql
+CREATE TABLE context_types (
+    id          SERIAL PRIMARY KEY,
+    value       TEXT NOT NULL UNIQUE,
+    label       TEXT NOT NULL,
+    description TEXT,
+    is_system   BOOL NOT NULL DEFAULT true,
+    sort_order  INT NOT NULL DEFAULT 0,
+    is_deleted  BOOL NOT NULL DEFAULT false,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### reminders
+Future-scheduled reminders linked to any entity type.
+```sql
+CREATE TABLE reminders (
+    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    entity_type TEXT NOT NULL,
+    entity_id   UUID NOT NULL,
+    remind_at   TIMESTAMPTZ NOT NULL,
+    note        TEXT,
+    delivered   BOOL NOT NULL DEFAULT false,
+    is_deleted  BOOL NOT NULL DEFAULT false,
+    deleted_at  TIMESTAMPTZ,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX idx_reminders_entity ON reminders USING btree(entity_type, entity_id);
+```
+
+### dependencies
+Generic dependency relationships between any entity types. Supports cycle detection (Phase 2).
+```sql
+CREATE TABLE dependencies (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    blocker_type    TEXT NOT NULL,
+    blocker_id      UUID NOT NULL,
+    dependent_type  TEXT NOT NULL,
+    dependent_id    UUID NOT NULL,
+    dependency_type TEXT NOT NULL DEFAULT 'finish_to_start',
+    lag_days        INT NOT NULL DEFAULT 0,
+    note            TEXT,
+    is_deleted      BOOL NOT NULL DEFAULT false,
+    deleted_at      TIMESTAMPTZ,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (blocker_type, blocker_id, dependent_type, dependent_id, dependency_type),
+    CHECK (NOT (blocker_type = dependent_type AND blocker_id = dependent_id))
+);
+CREATE INDEX idx_dependencies_blocker ON dependencies USING btree(blocker_type, blocker_id);
+CREATE INDEX idx_dependencies_dependent ON dependencies USING btree(dependent_type, dependent_id);
+```
+
+### releases
+Versioned release milestones spanning multiple projects.
+```sql
+CREATE TABLE releases (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name          TEXT NOT NULL,
+    version_label TEXT,
+    description   TEXT,
+    status        TEXT NOT NULL DEFAULT 'planned',  -- planned|in_progress|released|cancelled
+    target_date   DATE,
+    released_at   DATE,
+    release_notes TEXT,
+    tags          TEXT[],
+    sort_order    INT NOT NULL DEFAULT 0,
+    is_deleted    BOOL NOT NULL DEFAULT false,
+    deleted_at    TIMESTAMPTZ,
+    search_vector TSVECTOR,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+**Search trigger:** Indexes `name`, `description`, `version_label`, `tags`.
+
+### milestones
+Date-based checkpoints within releases or projects.
+```sql
+CREATE TABLE milestones (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    release_id   UUID REFERENCES releases(id) ON DELETE SET NULL,
+    project_id   UUID REFERENCES projects(id) ON DELETE SET NULL,
+    name         TEXT NOT NULL,
+    target_date  DATE NOT NULL,
+    completed_at DATE,
+    sort_order   INT NOT NULL DEFAULT 0,
+    is_deleted   BOOL NOT NULL DEFAULT false,
+    deleted_at   TIMESTAMPTZ,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### task_templates
+Reusable task templates with preset fields.
+```sql
+CREATE TABLE task_templates (
+    id                UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name              TEXT NOT NULL,
+    description       TEXT,
+    priority          INT,
+    estimated_minutes INT,
+    energy_required   TEXT,
+    context           TEXT,
+    tags              TEXT[],
+    sort_order        INT NOT NULL DEFAULT 0,
+    is_deleted        BOOL NOT NULL DEFAULT false,
+    deleted_at        TIMESTAMPTZ,
+    created_at        TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at        TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### task_template_items
+Individual sub-items within a task template.
+```sql
+CREATE TABLE task_template_items (
+    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    template_id UUID NOT NULL REFERENCES task_templates(id) ON DELETE CASCADE,
+    title       TEXT NOT NULL,
+    sort_order  INT NOT NULL DEFAULT 0,
+    is_deleted  BOOL NOT NULL DEFAULT false,
+    deleted_at  TIMESTAMPTZ,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+---
+
+## 10. Junction Tables (16 tables)
+
+All junction tables use composite primary keys and CASCADE deletes on both sides.
+
+```sql
+-- Note <-> Project (many-to-many)
+CREATE TABLE note_projects (
+    note_id    UUID NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+    project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    is_primary BOOL NOT NULL DEFAULT false,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (note_id, project_id)
+);
+
+-- Note <-> Note (wiki-style links)
+CREATE TABLE note_links (
+    source_note_id UUID NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+    target_note_id UUID NOT NULL REFERENCES notes(id) ON DELETE CASCADE,
+    created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (source_note_id, target_note_id)
+);
+
+-- File <-> Any Entity (polymorphic mapping)
+CREATE TABLE file_mappings (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    file_id      UUID NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    context_type TEXT NOT NULL,     -- 'task', 'project', 'note', etc.
+    context_id   UUID NOT NULL,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (file_id, context_type, context_id)
+);
+CREATE INDEX idx_file_mappings_context ON file_mappings USING btree(context_type, context_id);
+
+-- Release <-> Project
+CREATE TABLE release_projects (
+    release_id UUID NOT NULL REFERENCES releases(id) ON DELETE CASCADE,
+    project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (release_id, project_id)
+);
+
+-- Release <-> Domain
+CREATE TABLE release_domains (
+    release_id UUID NOT NULL REFERENCES releases(id) ON DELETE CASCADE,
+    domain_id  UUID NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (release_id, domain_id)
+);
+
+-- Contact <-> Task
+CREATE TABLE contact_tasks (
+    contact_id UUID NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    task_id    UUID NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    role       TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (contact_id, task_id)
+);
+
+-- Contact <-> Project
+CREATE TABLE contact_projects (
+    contact_id UUID NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    role       TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (contact_id, project_id)
+);
+
+-- Contact <-> List
+CREATE TABLE contact_lists (
+    contact_id UUID NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    list_id    UUID NOT NULL REFERENCES lists(id) ON DELETE CASCADE,
+    role       TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (contact_id, list_id)
+);
+
+-- Contact <-> List Item
+CREATE TABLE contact_list_items (
+    contact_id   UUID NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    list_item_id UUID NOT NULL REFERENCES list_items(id) ON DELETE CASCADE,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (contact_id, list_item_id)
+);
+
+-- Contact <-> Appointment
+CREATE TABLE contact_appointments (
+    contact_id     UUID NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    appointment_id UUID NOT NULL REFERENCES appointments(id) ON DELETE CASCADE,
+    role           TEXT,
+    created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (contact_id, appointment_id)
+);
+
+-- Contact <-> Meeting
+CREATE TABLE contact_meetings (
+    contact_id UUID NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    meeting_id UUID NOT NULL REFERENCES meetings(id) ON DELETE CASCADE,
+    role       TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (contact_id, meeting_id)
+);
+
+-- Decision <-> Project
+CREATE TABLE decision_projects (
+    decision_id UUID NOT NULL REFERENCES decisions(id) ON DELETE CASCADE,
+    project_id  UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (decision_id, project_id)
+);
+
+-- Decision <-> Contact
+CREATE TABLE decision_contacts (
+    decision_id UUID NOT NULL REFERENCES decisions(id) ON DELETE CASCADE,
+    contact_id  UUID NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    role        TEXT,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (decision_id, contact_id)
+);
+
+-- Meeting <-> Task (action items)
+CREATE TABLE meeting_tasks (
+    meeting_id UUID NOT NULL REFERENCES meetings(id) ON DELETE CASCADE,
+    task_id    UUID NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    source     TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (meeting_id, task_id)
+);
+
+-- Process Run Step <-> Task
+CREATE TABLE process_run_tasks (
+    run_step_id UUID NOT NULL REFERENCES process_run_steps(id) ON DELETE CASCADE,
+    task_id     UUID NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (run_step_id, task_id)
+);
+
+-- Folder <-> Weblink
+CREATE TABLE folder_weblinks (
+    folder_id  UUID NOT NULL REFERENCES weblink_folders(id) ON DELETE CASCADE,
+    weblink_id UUID NOT NULL REFERENCES weblinks(id) ON DELETE CASCADE,
+    sort_order INT NOT NULL DEFAULT 0,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (folder_id, weblink_id)
+);
+```
+
+---
+
+## 11. Database Functions & Triggers
+
+### Search Vector Update Functions
+
+15 entity-specific search functions, each following the same pattern. The function builds a tsvector from relevant text columns and stores it in `search_vector`.
+
+**Pattern:**
+```sql
+CREATE OR REPLACE FUNCTION update_{table}_search() RETURNS TRIGGER AS $$
+BEGIN
+    NEW.search_vector := to_tsvector('pg_catalog.english',
+        coalesce(NEW.{col1}, '') || ' ' || coalesce(NEW.{col2}, '') || ' ' ||
+        coalesce(array_to_string(NEW.tags, ' '), ''));
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER trg_{table}_search
+    BEFORE INSERT OR UPDATE ON {table}
+    FOR EACH ROW EXECUTE FUNCTION update_{table}_search();
+```
+
+**Per-table indexed columns:**
+
+| Function | Table | Indexed Columns |
+|----------|-------|----------------|
+| `update_domains_search` | domains | name |
+| `update_areas_search` | areas | name, description |
+| `update_projects_search` | projects | name, description, tags |
+| `update_tasks_search` | tasks | title, description, tags |
+| `update_notes_search` | notes | title, body, tags |
+| `update_contacts_search` | contacts | first_name, last_name, company, email, tags |
+| `update_meetings_search` | meetings | title, agenda, notes_body, tags |
+| `update_decisions_search` | decisions | title, rationale, tags |
+| `update_links_search` | links | label, url, description, tags |
+| `update_weblinks_search` | weblinks | label, url, description, tags |
+| `update_files_search` | files | original_filename, description, tags |
+| `update_lists_search` | lists | name, description, tags |
+| `update_appointments_search` | appointments | title, description, location, tags |
+| `update_processes_search` | processes | name, description, tags |
+| `update_releases_search` | releases | name, description, version_label, tags |
+
+There is also a generic `update_search_vector()` function as a fallback that attempts to index `title`, `description`, `name`, and `tags` with exception handling for missing columns.
+
+---
+
+## 12. Entity Relationship Map
+
+```
+domains (1)─────────────┬──────(M) areas
+    │                    │           │
+    │                    │           └──(M) projects ◄──── areas.area_id
+    │                    │                  │
+    ├──(M) projects      │                  ├──(M) tasks
+    ├──(M) tasks         │                  ├──(M) notes
+    ├──(M) notes         │                  ├──(M) links
+    ├──(M) links         │                  ├──(M) lists
+    ├──(M) lists         │                  └──(M) milestones
+    └──(M) time_budgets  │
+                         │
+tasks ──────────────────┬──(M) time_entries
+    │                    ├──(M) daily_focus
+    │                    ├──(M) notes (via task_id)
+    │                    ├──(M) lists (via task_id)
+    │                    ├──(M) weblinks (via task_id)
+    │                    ├──(M) decisions (via task_id)
+    │                    ├──(M) subtasks (self-ref via parent_id)
+    │                    └──(M) time_blocks
+    │
+contacts ───────────────┬──(M) contact_tasks ──── tasks
+    │                    ├──(M) contact_projects ── projects
+    │                    ├──(M) contact_meetings ── meetings
+    │                    ├──(M) contact_appointments ── appointments
+    │                    ├──(M) contact_lists ──── lists
+    │                    └──(M) decision_contacts ── decisions
+    │
+meetings ───────────────┬──(M) meeting_tasks ──── tasks
+    │                    ├──(M) contact_meetings ── contacts
+    │                    ├──(M) notes (via meeting_id)
+    │                    ├──(M) lists (via meeting_id)
+    │                    ├──(M) weblinks (via meeting_id)
+    │                    └──(M) decisions (via meeting_id)
+    │
+processes ──────────────┬──(M) process_steps
+    │                    └──(M) process_runs
+    │                              ├──(M) process_run_steps
+    │                              └──(M) process_run_tasks ── tasks
+    │
+files ──────────────────── file_mappings ──── (polymorphic: any entity)
+    │
+releases ───────────────┬──(M) release_projects ── projects
+    │                    ├──(M) release_domains ── domains
+    │                    ├──(M) tasks (via release_id)
+    │                    └──(M) milestones
+```
+
+---
+
+# Part 4: Backend Application
+
+## 13. Application Bootstrap (main.py)
+
+### Initialization Flow
+
+```python
+# 1. Load environment variables
+load_dotenv()
+
+# 2. Create FastAPI app with lifespan
+app = FastAPI(title="Life OS", version="1.0.0", lifespan=lifespan)
+
+# 3. Mount static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# 4. Add ASGI middleware for environment context
+app.add_middleware(RequestContextMiddleware)
+
+# 5. Define dashboard route (/)
+# 6. Define health check (/health)
+# 7. Include all 23 routers
+```
+
+### Lifespan Handler
+```python
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    ok = await check_db()  # Verify DB connectivity at startup
+    print("Database connection OK" if ok else "WARNING: Database check failed")
+    yield
+```
+
+### RequestContextMiddleware
+Pure ASGI middleware (not BaseHTTPMiddleware, which causes TaskGroup issues with asyncpg):
+```python
+class RequestContextMiddleware:
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "http":
+            scope.setdefault("state", {})["environment"] = self.environment
+        await self.app(scope, receive, send)
+```
+
+### Dashboard Route (/)
+The dashboard queries:
+1. Today's focus items (daily_focus JOIN tasks, projects, domains)
+2. Overdue tasks (due_date < today, not done/cancelled, limit 10)
+3. Upcoming tasks (due in next 7 days, limit 10)
+4. Task stats (open count, done this week, in progress)
+
+### Router Registration Order
+23 routers included in this order:
+1. domains, areas, projects, tasks, notes, links
+2. focus, capture, contacts, search, admin, lists
+3. files, meetings, decisions, weblinks
+4. appointments, time_tracking, processes, calendar
+5. time_budgets, eisenhower, history
+
+---
+
+## 14. Core Modules
+
+### database.py - Connection Management
+
+**Engine Configuration:**
+```python
+engine = create_async_engine(
+    DATABASE_URL,
+    echo=(ENVIRONMENT == "development"),  # SQL logging in dev
+    pool_size=5,
+    max_overflow=10,
+    pool_pre_ping=True,  # Verify connections before use
+)
+```
+
+**Session Factory:**
+```python
+async_session_factory = async_sessionmaker(
+    engine, class_=AsyncSession, expire_on_commit=False,
+)
+```
+
+**get_db() Dependency:**
+FastAPI dependency that yields an async session with auto-commit/rollback:
+```python
+async def get_db():
+    async with async_session_factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+```
+
+### base_repository.py - Generic CRUD
+
+The `BaseRepository` class provides all CRUD operations for any table. It uses raw SQL via `text()` - no ORM models.
+
+**Constructor:** `BaseRepository(table_name: str, db: AsyncSession)`
+
+**Methods:**
+
+| Method | Signature | Behavior |
+|--------|-----------|----------|
+| `list()` | `(filters, sort, sort_dir, page, per_page, include_deleted)` | SELECT with auto `is_deleted=false` filter. Supports pagination, sorting, and key-value filters. Special filter values: `None` → `IS NULL`, `"__notnull__"` → `IS NOT NULL`. |
+| `count()` | `(filters, include_deleted)` | COUNT with same filter logic |
+| `get()` | `(id: UUID)` | SELECT by ID. Validates UUID format. Returns dict or None. |
+| `create()` | `(data: dict)` | INSERT with auto `created_at`, `updated_at`, `is_deleted=false`. Coerces ISO date strings to Python date/datetime (required by asyncpg). Returns full row. |
+| `update()` | `(id: UUID, data: dict)` | UPDATE with auto `updated_at`. **Nullable fields gotcha:** Only fields listed in `nullable_fields` set can be set to NULL. All other NULL values are silently skipped. |
+| `soft_delete()` | `(id: UUID)` | Sets `is_deleted=true`, `deleted_at=now()`, `updated_at=now()` |
+| `restore()` | `(id: UUID)` | Sets `is_deleted=false`, `deleted_at=NULL`, `updated_at=now()` |
+| `permanent_delete()` | `(id: UUID)` | Actual SQL DELETE. Admin only. |
+| `bulk_soft_delete()` | `(ids: list[str])` | Batch soft delete |
+| `list_deleted()` | `()` | Lists all soft-deleted rows, ordered by deleted_at DESC |
+| `reorder()` | `(id_order: list[str])` | Updates sort_order based on position (10, 20, 30...) |
+
+**Nullable Fields Set:**
+```python
+nullable_fields = {
+    "description", "notes", "body", "area_id", "project_id",
+    "parent_id", "parent_item_id", "release_id", "due_date", "deadline", "tags",
+    "context", "folder_id", "meeting_id", "completed_at",
+    "waiting_for_contact_id", "waiting_since", "color",
+    "rationale", "decided_at", "superseded_by_id",
+    "start_at", "end_at", "location", "agenda", "transcript", "notes_body",
+    "priority", "recurrence", "mime_type",
+    "category", "instructions", "expected_output", "estimated_days",
+    "contact_id", "started_at",
+    "weekly_hours", "effective_from",
+    "task_id", "meeting_id",
+}
+```
+
+**Date Coercion:**
+asyncpg requires native Python `date`/`datetime` objects, not strings. The `_coerce_value()` helper auto-converts ISO format strings (`YYYY-MM-DD`, `YYYY-MM-DDTHH:MM`) to Python types.
+
+### sidebar.py - Navigation Data
+
+Builds the domain > area > project tree for the sidebar. Called by every route.
+
+```python
+async def get_sidebar_data(db: AsyncSession) -> dict:
+    # Returns:
+    {
+        "domain_tree": [
+            {
+                "id": UUID, "name": str, "color": str,
+                "areas": [
+                    {"id": UUID, "name": str, "projects": [...]}
+                ],
+                "standalone_projects": [...]  # Projects with no area
+            }
+        ],
+        "capture_count": int,   # Unprocessed capture items
+        "focus_count": int,     # Incomplete focus items for today
+    }
+```
+
+---
+
+## 15. Router Pattern
+
+Every router follows this exact structure:
+
+```python
+from fastapi import APIRouter, Request, Form, Depends
+from fastapi.responses import RedirectResponse
+from fastapi.templating import Jinja2Templates
+from core.base_repository import BaseRepository
+from core.database import get_db
+from core.sidebar import get_sidebar_data
+
+router = APIRouter(prefix='/things', tags=['things'])
+templates = Jinja2Templates(directory='templates')
+
+# LIST - GET /things/
+@router.get('/')
+async def list_things(request: Request, db=Depends(get_db)):
+    repo = BaseRepository("things", db)
+    items = await repo.list()
+    sidebar = await get_sidebar_data(db)
+    return templates.TemplateResponse('things.html', {
+        'request': request, 'items': items, 'sidebar': sidebar,
+        'page_title': 'Things', 'active_nav': 'things',
+    })
+
+# CREATE FORM - GET /things/create
+@router.get('/create')
+async def create_form(request: Request, db=Depends(get_db)):
+    sidebar = await get_sidebar_data(db)
+    return templates.TemplateResponse('thing_form.html', {
+        'request': request, 'item': None, 'sidebar': sidebar,
+    })
+
+# CREATE - POST /things/create
+@router.post('/create')
+async def create_thing(request: Request, db=Depends(get_db),
+                       title: str = Form(...), description: str = Form(None)):
+    repo = BaseRepository("things", db)
+    item = await repo.create({'title': title, 'description': description})
+    return RedirectResponse(url=f'/things/{item["id"]}', status_code=303)
+
+# DETAIL - GET /things/{id}
+@router.get('/{thing_id}')
+async def detail(request: Request, thing_id: str, db=Depends(get_db)):
+    repo = BaseRepository("things", db)
+    item = await repo.get(thing_id)
+    if not item:
+        return RedirectResponse(url='/things', status_code=303)
+    sidebar = await get_sidebar_data(db)
+    return templates.TemplateResponse('thing_detail.html', {
+        'request': request, 'item': item, 'sidebar': sidebar,
+    })
+
+# EDIT FORM - GET /things/{id}/edit
+@router.get('/{thing_id}/edit')
+async def edit_form(request: Request, thing_id: str, db=Depends(get_db)):
+    repo = BaseRepository("things", db)
+    item = await repo.get(thing_id)
+    sidebar = await get_sidebar_data(db)
+    return templates.TemplateResponse('thing_form.html', {
+        'request': request, 'item': item, 'sidebar': sidebar,
+    })
+
+# EDIT - POST /things/{id}/edit
+@router.post('/{thing_id}/edit')
+async def edit_thing(request: Request, thing_id: str, db=Depends(get_db),
+                     title: str = Form(...), description: str = Form(None)):
+    repo = BaseRepository("things", db)
+    await repo.update(thing_id, {'title': title, 'description': description})
+    return RedirectResponse(url=f'/things/{thing_id}', status_code=303)
+
+# DELETE - POST /things/{id}/delete
+@router.post('/{thing_id}/delete')
+async def delete_thing(request: Request, thing_id: str, db=Depends(get_db)):
+    repo = BaseRepository("things", db)
+    await repo.soft_delete(thing_id)
+    return RedirectResponse(url='/things', status_code=303)
+```
+
+**Every route MUST call `get_sidebar_data(db)` and pass `sidebar` to the template.**
+
+---
+
+## 16. Router Reference (23 routers)
+
+### Standard CRUD Routers
+
+These follow the exact pattern above (list, create form, create, detail, edit form, edit, delete):
+
+| Router | Prefix | Table | Extra Endpoints |
+|--------|--------|-------|-----------------|
+| domains | /domains | domains | - |
+| areas | /areas | areas | - |
+| projects | /projects | projects | `GET /api/by-domain` (JSON, for dynamic dropdowns) |
+| notes | /notes | notes | - |
+| links | /links | links | - |
+| contacts | /contacts | contacts | - |
+| lists | /lists | lists | `POST /{id}/items/add`, `POST /items/{id}/toggle`, `POST /items/{id}/delete` |
+| meetings | /meetings | meetings | `POST /{id}/create-action` (create task from meeting) |
+| decisions | /decisions | decisions | - |
+| weblinks | /weblinks | weblinks | `POST /folders/create`, folder management |
+| appointments | /appointments | appointments | - |
+| processes | /processes | processes | `POST /{id}/steps/add`, `POST /steps/{id}/edit`, `POST /{id}/start-run` |
+| time_budgets | /time-budgets | time_budgets | - |
+
+### Specialized Routers
+
+**tasks** (`/tasks`) - Most complex router:
+- Standard CRUD (list, create, detail, edit, delete)
+- `POST /quick-add` - Minimal task creation (title + domain_id only)
+- `POST /{id}/toggle` - Toggle done/open status
+- `POST /{id}/complete` - Mark as done with completed_at
+- `GET /` with filters: status, priority, domain_id, project_id, sort, context
+- Detail page with tabs: overview, notes, weblinks, files, lists, decisions, contacts
+- `POST /{id}/contacts/add` - Link contact to task
+- `POST /{id}/contacts/{contact_id}/remove` - Unlink contact
+
+**focus** (`/focus`) - Daily focus management:
+- `GET /` - Show today's focus + available tasks
+- `POST /add` - Add task to focus (task_id + focus_date)
+- `POST /{id}/toggle` - Toggle focus item complete
+- `POST /{id}/remove` - Remove from focus
+
+**capture** (`/capture`) - Quick capture inbox:
+- `GET /` - List unprocessed captures
+- `POST /add` - Create capture (raw_text, supports multi-line splitting)
+- `GET /{id}/convert` - Show conversion options
+- `POST /{id}/convert/{type}` - Convert to task/note/project/contact/decision/weblink/list_item
+- `POST /{id}/dismiss` - Mark as processed without converting
+- `POST /batch/{batch_id}/undo` - Undo batch conversion
+
+**search** (`/search`) - Global search:
+- `GET /` - Search page with HTML results
+- `GET /api` - JSON search API for modal (returns `{results: [...]}`)
+- Searches across configurable `SEARCH_ENTITIES` dict
+- Uses tsvector/tsquery with `plainto_tsquery()` for safety
+
+**admin** (`/admin`) - Trash management:
+- `GET /trash` - List soft-deleted items across all entities
+- `POST /trash/{table}/{id}/restore` - Restore soft-deleted item
+- `POST /trash/{table}/{id}/permanent-delete` - Hard delete
+- `POST /trash/empty` - Empty all trash
+
+**time_tracking** (`/time`) - Timer and time log:
+- `GET /` - Time log page with day filter
+- `POST /start` - Start timer for task (auto-stops any running timer)
+- `POST /stop` - Stop running timer
+- `POST /manual` - Create manual time entry
+- `GET /running` - JSON endpoint returning running timer state
+- `POST /{id}/delete` - Delete time entry (uses direct SQL, no BaseRepository)
+
+**calendar** (`/calendar`) - Read-only unified calendar:
+- `GET /` - Month view combining appointments, meetings, and tasks with due dates
+- Query params: `year`, `month`
+
+**eisenhower** (`/eisenhower`) - Eisenhower matrix view:
+- `GET /` - 2x2 grid classifying tasks by priority (1-2=important) and urgency (due <=7 days)
+- Query params: `domain_id`, `project_id`, `status`, `context`
+
+**history** (`/history`) - Change history feed:
+- `GET /` - Reverse-chronological feed of recently modified items across all entities
+- Query params: `entity_type` filter
+
+---
+
+## 17. Business Logic
+
+### Timer Constraints
+- **Only one timer can run at a time.** Starting a new timer auto-stops any running timer.
+- Running timer detected by: `SELECT * FROM time_entries WHERE end_at IS NULL AND is_deleted = false`
+- Stop sets `end_at = now()` and computes `duration_minutes`
+- The topbar timer pill polls `/time/running` every 30 seconds
+
+### Capture Conversions
+- Multi-line `raw_text` is split on newlines, creating multiple capture items
+- Each line in a batch gets the same `import_batch_id`
+- Single-line captures get no batch_id
+- Conversion creates the target entity and marks capture as `processed=true`
+- Batch undo reverses all conversions for a batch_id
+
+### Task Status Transitions
+- Toggle: `open` ↔ `done` (sets/clears `completed_at`)
+- Complete action: Sets `status=done`, `completed_at=now()`
+- Edit can change to any valid status
+- Setting status to `done` auto-sets `completed_at`
+- Setting status from `done` to anything else clears `completed_at`
+
+### Focus Sync
+- Adding a task to daily_focus doesn't change its status
+- Toggling a focus item as complete marks `completed=true` on the daily_focus row
+- Focus items for today are shown on the dashboard
+
+### Search Algorithm
+- Uses PostgreSQL `plainto_tsquery('english', query)` for safe query parsing
+- Searches `search_vector @@ query` with tsvector ranking
+- Results grouped by entity type with configurable display columns
+- No special characters interpreted (safe from injection)
+
+---
+
+## 18. Key Enums & Constants
+
+| Field | Valid Values | Default |
+|-------|-------------|---------|
+| Task status | `open`, `in_progress`, `blocked`, `done`, `cancelled` | `open` |
+| Task priority | `1` (critical), `2` (high), `3` (normal), `4` (low) | `3` |
+| Project status | `active`, `on_hold`, `completed`, `archived` | `active` |
+| Meeting status | `scheduled`, `completed`, `cancelled` | `scheduled` |
+| Decision status | `proposed`, `accepted`, `rejected`, `superseded` | `proposed` |
+| Decision impact | `low`, `medium`, `high` | `medium` |
+| Process type | `workflow`, `checklist` | `checklist` |
+| Process status | `draft`, `active`, `archived` | `draft` |
+| Process run status | `not_started`, `in_progress`, `completed`, `cancelled` | `not_started` |
+| Run step status | `pending`, `in_progress`, `completed`, `skipped` | `pending` |
+| Task generation | `all_at_once`, `step_by_step` | `all_at_once` |
+| Release status | `planned`, `in_progress`, `released`, `cancelled` | `planned` |
+| Area status | `active` (default) | `active` |
+| Content format | `rich` (default) | `rich` |
+
+---
+
+# Part 5: Frontend
+
+## 19. Template Architecture
+
+All templates live in `/opt/lifeos/dev/templates/` and extend `base.html`.
+
+### base.html Shell Structure
+```
+<html data-theme="dark">
+  <head>
+    <link rel="stylesheet" href="/static/style.css">
+    <link href="fonts.googleapis.com/css2?DM+Sans+JetBrains+Mono">
+  </head>
+  <body>
+    <div class="app-layout">
+      <aside class="sidebar">
+        <div class="sidebar-header">LifeOS logo</div>
+        <nav class="sidebar-nav">
+          [14 quick-access links with SVG icons]
+          [Domain tree: domain > area > project hierarchy]
+          [Admin section: History, Trash, Manage, Theme toggle]
+        </nav>
+      </aside>
+      <main class="main-content">
+        <header class="topbar">
+          [DEV badge if development]
+          [Timer pill (hidden by default)]
+          [Quick capture form]
+          [Search trigger button]
+        </header>
+        <div class="page-content">
+          {% block content %}{% endblock %}
+        </div>
+      </main>
+    </div>
+    [Search modal overlay]
+    [Mobile bottom nav bar]
+    [Mobile more panel overlay]
+    <script src="/static/app.js"></script>
+  </body>
+</html>
+```
+
+### Template Inventory (51 files)
+
+**Core:** base.html, dashboard.html
+**List views (18):** tasks, notes, projects, contacts, areas, domains, links, lists, meetings, decisions, weblinks, appointments, time_entries, files, processes, process_runs, capture, time_budgets
+**Detail views (9):** task_detail, project_detail, note_detail, contact_detail, meeting_detail, appointment_detail, decision_detail, process_run_detail, list_detail
+**Forms (15):** task_form, note_form, project_form, contact_form, area_form, domain_form, link_form, list_form, meeting_form, decision_form, weblink_form, weblink_folder_form, appointment_form, processes_form, time_budgets_form
+**Specialized (7):** focus, calendar, eisenhower, search, trash, history, capture_convert
+**File management (2):** file_preview, file_upload
+
+---
+
+## 20. CSS Design System
+
+### Design Tokens (Custom Properties)
+
+**Dark Theme (`[data-theme="dark"]`):**
+```css
+--bg: #0D0E13;           --surface: #14161F;       --surface2: #1A1D28;
+--surface3: #222533;     --border: #252836;        --border-light: #2E3244;
+--text: #DDE1F5;         --text-secondary: #9CA3C4; --muted: #5A6080;
+--accent: #4F6EF7;       --accent-hover: #6380FF;   --accent-soft: rgba(79,110,247,.12);
+--green: #22C98A;        --green-soft: rgba(34,201,138,.12);
+--amber: #F5A623;        --amber-soft: rgba(245,166,35,.12);
+--red: #F05252;          --red-soft: rgba(240,82,82,.12);
+--purple: #9B7FF5;       --purple-soft: rgba(155,127,245,.12);
+--shadow: 0 2px 8px rgba(0,0,0,.3);
+--shadow-lg: 0 8px 32px rgba(0,0,0,.4);
+```
+
+**Light Theme (`[data-theme="light"]`):**
+```css
+--bg: #F0F2F8;           --surface: #FFFFFF;       --surface2: #F7F8FC;
+--text: #171926;         --muted: #8892B0;
+/* Same accent/semantic colors with adjusted soft variants */
+```
+
+**Root Variables (theme-independent):**
+```css
+--font-body: 'DM Sans', -apple-system, sans-serif;
+--font-mono: 'JetBrains Mono', monospace;
+--radius: 8px; --radius-sm: 4px; --radius-lg: 12px;
+--sidebar-width: 260px; --topbar-height: 52px;
+--transition: 150ms ease;
+```
+
+### Color Usage by Context
+
+| Context | Color |
+|---------|-------|
+| Priority 1 (Critical) | `--red` |
+| Priority 2 (High) | `--amber` |
+| Priority 3 (Normal) | `--accent` |
+| Priority 4 (Low) | `--muted` |
+| Status: open | `--accent` |
+| Status: in_progress | `--amber` |
+| Status: blocked | `--red` |
+| Status: done/completed | `--green` |
+| Status: cancelled/archived | `--muted` |
+| Status: on_hold | `--purple` |
+| Calendar: appointments | `--amber` |
+| Calendar: meetings | `--purple` |
+| Calendar: tasks | `--accent` |
+
+### Responsive Breakpoint
+
+**Single breakpoint: `max-width: 768px`**
+
+Mobile overrides:
+- Sidebar: `display: none`
+- Main content: `margin-left: 0`
+- Form grid: 1 column
+- Dashboard grid: 1 column
+- Page content: `padding: 16px`
+- Mobile bottom nav: `display: flex` (56px fixed bottom)
+- Body: `padding-bottom: 60px`
+
+---
+
+## 21. JavaScript Interactions (app.js, ~190 lines)
+
+All JS runs on `DOMContentLoaded`. No framework. No build step.
+
+### Theme Toggle
+- Reads/saves theme to `localStorage['lifeos-theme']`
+- Sets `data-theme` attribute on `<html>`
+- Toggle function called from sidebar button
+
+### Sidebar Domain Collapse
+- Click `.domain-header` → toggle `.collapsed` on `.domain-children`
+- State persisted per domain in `localStorage['sidebar-{domainId}']`
+- Restored on page load
+
+### Filter Auto-Submit
+- Any `<select data-auto-submit>` → on `change`, submits parent `<form>`
+
+### Delete Confirmation
+- Any `<form data-confirm="message">` → on `submit`, shows `confirm()` dialog
+
+### Search Modal
+- **Open:** Cmd/Ctrl+K or click search trigger
+- **Close:** Escape key or click backdrop
+- **Live search:** 200ms debounce, fetches `/search/api?q={query}&limit=8`
+- **Navigation:** Arrow keys move `.active` class through results, Enter navigates
+- **Results:** Grouped by entity type, shows name + context + status badge
+- **HTML escaping:** `escHtml()` helper for safe rendering
+
+### Timer Pill
+- **Poll:** `/time/running` every 30 seconds
+- **Display:** If running, shows task name + elapsed time (h:mm:ss)
+- **Update:** 1-second interval updates elapsed display client-side
+- **State:** `timerStartAt` (Date), `timerInterval` (setInterval ID)
+
+### Mobile More Panel
+- `#mobMoreBtn` click → toggle `.open` on `#mobMore` + `#mobOverlay`
+- Overlay click → close panel
+
+---
+
+## 22. Page Patterns
+
+### List View Pattern
+```
+Page Header (title + count + "New" button)
+  └── Quick Add form (optional, for tasks)
+  └── Filters bar (select dropdowns with auto-submit)
+  └── Card
+        └── List rows (checkbox + priority dot + title + tags + meta + status + actions)
+  └── Empty state (if no items)
+```
+
+### Form View Pattern
+```
+Breadcrumb (entity list > "New"/"Edit")
+  └── Page Header
+  └── Card
+        └── Form (grid: 2 columns on desktop, 1 on mobile)
+              └── Form groups (label + input/select/textarea)
+              └── Full-width fields (description, tags)
+              └── Form actions (Submit + Cancel)
+```
+
+### Detail View Pattern
+```
+Breadcrumb (domain > project > item)
+  └── Detail Header (title + action buttons)
+  └── Detail Meta (status + priority + domain + project + dates)
+  └── Description card (if exists)
+  └── Tags row (if exists)
+  └── Tab Strip (overview, notes, weblinks, files, lists, etc.)
+  └── Tab Content (varies by tab)
+  └── Footer metadata (created/completed timestamps)
+```
+
+---
+
+## 23. Responsive & Mobile
+
+### Desktop Layout
+- Fixed sidebar (260px) + flexible main content
+- Sticky topbar (52px)
+- Two-column form grids
+- Hover states reveal action buttons on list rows
+
+### Mobile Layout (< 768px)
+- Sidebar hidden
+- Bottom nav bar (56px) with 5 items: Home, Focus, Tasks, Capture, More
+- "More" button opens slide-up panel with remaining navigation
+- Forms collapse to single column
+- Quick capture input expands to full width
+- Font-size: 16px on inputs to prevent iOS zoom
+- Touch targets: min 44px height for buttons
+
+---
+
+# Part 6: Testing
+
+## 24. Test Architecture
+
+The test suite uses **dynamic introspection** - it discovers routes from the live FastAPI app at runtime. No hardcoded routes.
+
+### Test Files
+
+| File | Lines | Purpose |
+|------|-------|---------|
+| `conftest.py` | 361 | Fixtures, seed data, client setup |
+| `registry.py` | 67 | Route discovery, classification, seed mapping |
+| `introspect.py` | 357 | Route introspection engine |
+| `form_factory.py` | 204 | Automatic form data generation |
+| `test_smoke_dynamic.py` | 76 | Auto-parametrized GET tests |
+| `test_crud_dynamic.py` | 168 | Auto-parametrized POST tests |
+| `test_business_logic.py` | 2,635 | Hand-written behavioral tests |
+| `route_report.py` | 65 | CLI route dump utility |
+| `run_tests.sh` | 23 | Test runner script |
+
+### Introspection Engine (introspect.py)
+
+Walks the live FastAPI app and extracts metadata for every route:
+- Path, methods, endpoint name
+- Route kind classification (LIST, DETAIL, CREATE, EDIT, DELETE, TOGGLE, ACTION, etc.)
+- Form fields with names, types, required/optional status, defaults
+- Query parameters
+- File upload detection
+
+### Route Registry (registry.py)
+
+Classifies routes into buckets for parametrized tests:
+- `GET_NO_PARAMS`: All GET routes without path parameters
+- `GET_WITH_PARAMS`: All GET routes with `{id}` placeholders
+- `POST_CREATE`: Routes ending in `/create`
+- `POST_EDIT`: Routes ending in `/{id}/edit`
+- `POST_DELETE`: Routes ending in `/{id}/delete`
+- `POST_ACTION`: All other POST routes
+
+Maps route prefixes to seed data via `PREFIX_TO_SEED`.
+
+### Form Factory (form_factory.py)
+
+Generates valid POST form data automatically from introspected Form fields using multi-level heuristics:
+1. FK fields → seed UUIDs
+2. Date/time fields → generated dynamically
+3. Field name patterns → 40+ hardcoded values
+4. Type-based fallback
+5. Required string fallback
+
+### Seed Data (conftest.py)
+
+Session-scoped fixture inserts 19 fixed-UUID entities:
+- Core: domain, area, project, task
+- CRM: contact, meeting, decision, appointment
+- Content: note, list, link, weblink, weblink_folder
+- System: capture, focus, process, process_step, process_run, time_budget, file
+
+Fixed UUIDs (e.g., `a0000000-0000-0000-0000-000000000001`) ensure stable references.
+
+---
+
+## 25. Test Suite Reference
+
+### Test Types
+
+**Smoke Tests** (`test_smoke_dynamic.py`):
+- Verify all GET endpoints return 200
+- Test detail routes with valid and invalid UUIDs
+- Auto-parametrized from introspected routes
+
+**CRUD Tests** (`test_crud_dynamic.py`):
+- Verify POST create/edit/delete routes redirect (303)
+- Auto-generate form data via form_factory
+- Test order: create → edit → action → delete
+
+**Business Logic Tests** (`test_business_logic.py`):
+- 10+ test classes, ~50 tests total
+- Timer constraints, task filtering, status transitions
+- Capture conversions, meeting relationships
+- Admin trash lifecycle, soft delete behavior
+- Search behavior, sidebar integrity, focus workflow
+
+### Running Tests
+
+```bash
+docker exec lifeos-dev bash /app/tests/run_tests.sh          # Full suite
+docker exec lifeos-dev bash /app/tests/run_tests.sh smoke    # GET endpoints
+docker exec lifeos-dev bash /app/tests/run_tests.sh crud     # POST endpoints
+docker exec lifeos-dev bash /app/tests/run_tests.sh logic    # Business logic
+docker exec lifeos-dev bash /app/tests/run_tests.sh report   # Route dump
+docker exec lifeos-dev bash /app/tests/run_tests.sh fast     # Smoke, stop first fail
+docker exec lifeos-dev bash /app/tests/run_tests.sh -k "timer"  # Keyword filter
+```
+
+### Resetting Test DB After Schema Changes
+
+```bash
+docker exec lifeos-db psql -U postgres -c "DROP DATABASE IF EXISTS lifeos_test;"
+docker exec lifeos-db psql -U postgres -c "CREATE DATABASE lifeos_test;"
+docker exec lifeos-db pg_dump -U postgres -d lifeos_dev --schema-only -f /tmp/s.sql
+docker exec lifeos-db psql -U postgres -d lifeos_test -f /tmp/s.sql -q
+```
+
+---
+
+# Part 7: Operations
+
+## 26. Deployment & Hot Reload
+
+The dev container uses a volume mount (`-v /opt/lifeos/dev:/app`) plus uvicorn `--reload`. This means:
+
+1. Edit any file in `/opt/lifeos/dev/` on the host
+2. Uvicorn detects the change and restarts automatically
+3. No container rebuild needed
+4. No deploy script needed
+
+**Verification after changes:**
+```bash
+docker logs lifeos-dev --tail 10   # Check for import/syntax errors
+curl -s -o /dev/null -w "%{http_code}" http://localhost:8003/  # Should be 200
+```
+
+---
+
+## 27. Backup & Restore
+
+### Backup
+```bash
+mkdir -p /opt/lifeos/backups
+docker exec lifeos-db pg_dump -U postgres -d lifeos_dev -Fc -f /tmp/lifeos_dev_backup.dump
+docker cp lifeos-db:/tmp/lifeos_dev_backup.dump /opt/lifeos/backups/lifeos_dev_$(date +%Y%m%d_%H%M%S).dump
+```
+
+### Restore
+```bash
+docker exec lifeos-db psql -U postgres -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'lifeos_dev' AND pid <> pg_backend_pid();"
+docker exec lifeos-db psql -U postgres -c "DROP DATABASE lifeos_dev;"
+docker exec lifeos-db psql -U postgres -c "CREATE DATABASE lifeos_dev;"
+docker cp /opt/lifeos/backups/FILENAME.dump lifeos-db:/tmp/restore.dump
+docker exec lifeos-db pg_restore -U postgres -d lifeos_dev /tmp/restore.dump
+docker restart lifeos-dev
+```
+
+---
+
+## 28. Build Roadmap
+
+### Current State (as of 2026-03-02)
+- **Phase 1, Tier 3 complete.** All 6 Tier 3 features built.
+- 23 routers, 51 templates, 48 database tables
+- 121+ discovered routes
+
+### What's Built
+Core CRUD for: domains, areas, projects, tasks, notes, links, focus, capture, contacts, search, admin/trash, lists, files, meetings, decisions, weblinks, appointments, time_tracking, processes, calendar, time_budgets, eisenhower, history.
+
+Working features: collapsible sidebar nav tree, task filtering/sorting/priority/status/context, daily focus, markdown notes, file uploads with preview, global search (Cmd/K) via tsvector, admin trash with restore, time tracking with topbar timer pill, timer play/stop on task rows and detail pages, unified calendar view, Eisenhower matrix, time budgets with actual vs budgeted, process templates with runs, change history feed.
+
+### Remaining Roadmap
+
+**Tier 4:**
+- Releases/milestones CRUD
+- Task dependencies (DAG with cycle detection)
+- Task templates
+- Note wiki-linking
+- Note folders
+- Bulk actions
+- CSV export
+- Drag-to-reorder
+- Reminders
+- Dashboard metrics
+
+**Phase 2:**
+- DAG visualization
+- MCP/AI gateway (dual: MCP + OpenAI function calling)
+- Note version history
+
+**Phase 3:**
+- Mobile improvements
+- Authentication
+- Browser extension
+
+---
+
+## Known Traps & Gotchas
+
+1. **`time_entries` has no `updated_at` column.** BaseRepository.soft_delete() will fail. Use direct SQL for delete/restore on this table.
+
+2. **Junction tables use raw SQL, not BaseRepository.** They have composite PKs and no `id` column.
+
+3. **Timer constraint:** Only one timer at a time. `time_entries WHERE end_at IS NULL` detects running timer.
+
+4. **Nullable fields in BaseRepository:** If a form field should allow NULL, add it to the `nullable_fields` set. Otherwise `update()` silently skips null values.
+
+5. **Schema .sql files may be stale.** Always verify against live DB with `\d table_name`.
+
+6. **No pagination.** All list views load all rows. Fine at current data volume.
+
+7. **No CSRF protection.** Single-user system.
+
+8. **SSL cert path** uses `kasm.invixiom.com-0001` (not `kasm.invixiom.com`).
+
+9. **Test suite not fully green.** Async event loop fixes and seed data corrections are in progress.
+
+10. **asyncpg requires native Python types.** ISO date strings must be converted to `date`/`datetime` objects before passing to queries. BaseRepository's `_coerce_value()` handles this automatically.
+
+---
+
+*Document generated 2026-03-02. This is the single source of truth for rebuilding the Life OS system from ground zero.*
diff --git a/routers/decisions.py b/routers/decisions.py
index 5447b65..1bcc907 100644
--- a/routers/decisions.py
+++ b/routers/decisions.py
@@ -56,6 +56,7 @@ async def list_decisions(
 async def create_form(
     request: Request,
     meeting_id: Optional[str] = None,
+    task_id: Optional[str] = None,
     db: AsyncSession = Depends(get_db),
 ):
     sidebar = await get_sidebar_data(db)
@@ -72,6 +73,7 @@ async def create_form(
         "page_title": "New Decision", "active_nav": "decisions",
         "item": None,
         "prefill_meeting_id": meeting_id or "",
+        "prefill_task_id": task_id or "",
     })
 
 
@@ -84,6 +86,7 @@ async def create_decision(
     impact: str = Form("medium"),
     decided_at: Optional[str] = Form(None),
     meeting_id: Optional[str] = Form(None),
+    task_id: Optional[str] = Form(None),
     tags: Optional[str] = Form(None),
     db: AsyncSession = Depends(get_db),
 ):
@@ -96,10 +99,14 @@ async def create_decision(
         data["decided_at"] = decided_at
     if meeting_id and meeting_id.strip():
         data["meeting_id"] = meeting_id
+    if task_id and task_id.strip():
+        data["task_id"] = task_id
     if tags and tags.strip():
         data["tags"] = [t.strip() for t in tags.split(",") if t.strip()]
 
     decision = await repo.create(data)
+    if task_id and task_id.strip():
+        return RedirectResponse(url=f"/tasks/{task_id}?tab=decisions", status_code=303)
     return RedirectResponse(url=f"/decisions/{decision['id']}", status_code=303)
 
 
diff --git a/routers/eisenhower.py b/routers/eisenhower.py
index 45dbf96..e2e0eba 100644
--- a/routers/eisenhower.py
+++ b/routers/eisenhower.py
@@ -4,8 +4,10 @@ from fastapi import APIRouter, Request, Depends
 from fastapi.templating import Jinja2Templates
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import text
+from typing import Optional
 
 from core.database import get_db
+from core.base_repository import BaseRepository
 from core.sidebar import get_sidebar_data
 
 router = APIRouter(prefix="/eisenhower", tags=["eisenhower"])
@@ -15,11 +17,36 @@ templates = Jinja2Templates(directory="templates")
 @router.get("/")
 async def eisenhower_matrix(
     request: Request,
+    domain_id: Optional[str] = None,
+    project_id: Optional[str] = None,
+    status: Optional[str] = None,
+    context: Optional[str] = None,
     db: AsyncSession = Depends(get_db),
 ):
     sidebar = await get_sidebar_data(db)
 
-    result = await db.execute(text("""
+    where_clauses = [
+        "t.is_deleted = false",
+        "t.status IN ('open', 'in_progress', 'blocked')",
+    ]
+    params = {}
+
+    if domain_id:
+        where_clauses.append("t.domain_id = :domain_id")
+        params["domain_id"] = domain_id
+    if project_id:
+        where_clauses.append("t.project_id = :project_id")
+        params["project_id"] = project_id
+    if status:
+        where_clauses.append("t.status = :status")
+        params["status"] = status
+    if context:
+        where_clauses.append("t.context = :context")
+        params["context"] = context
+
+    where_sql = " AND ".join(where_clauses)
+
+    result = await db.execute(text(f"""
         SELECT t.id, t.title, t.priority, t.status, t.due_date,
                t.context, t.estimated_minutes,
                p.name as project_name,
@@ -27,10 +54,9 @@ async def eisenhower_matrix(
         FROM tasks t
         LEFT JOIN projects p ON t.project_id = p.id
         LEFT JOIN domains d ON t.domain_id = d.id
-        WHERE t.is_deleted = false
-          AND t.status IN ('open', 'in_progress', 'blocked')
+        WHERE {where_sql}
         ORDER BY t.priority, t.due_date NULLS LAST, t.title
-    """))
+    """), params)
     tasks = [dict(r._mapping) for r in result]
 
     # Classify into quadrants
@@ -39,10 +65,10 @@ async def eisenhower_matrix(
     urgent_cutoff = today + timedelta(days=7)
 
     quadrants = {
-        "do_first": [],       # Urgent + Important
-        "schedule": [],       # Not Urgent + Important
-        "delegate": [],       # Urgent + Not Important
-        "eliminate": [],      # Not Urgent + Not Important
+        "do_first": [],
+        "schedule": [],
+        "delegate": [],
+        "eliminate": [],
     }
 
     for t in tasks:
@@ -64,6 +90,17 @@ async def eisenhower_matrix(
     counts = {k: len(v) for k, v in quadrants.items()}
     total = sum(counts.values())
 
+    # Filter options
+    domains_repo = BaseRepository("domains", db)
+    domains = await domains_repo.list()
+    projects_repo = BaseRepository("projects", db)
+    projects = await projects_repo.list()
+
+    result = await db.execute(text(
+        "SELECT value, label FROM context_types WHERE is_deleted = false ORDER BY sort_order"
+    ))
+    context_types = [dict(r._mapping) for r in result]
+
     return templates.TemplateResponse("eisenhower.html", {
         "request": request,
         "sidebar": sidebar,
@@ -71,6 +108,13 @@ async def eisenhower_matrix(
         "counts": counts,
         "total": total,
         "today": today,
+        "domains": domains,
+        "projects": projects,
+        "context_types": context_types,
+        "current_domain_id": domain_id or "",
+        "current_project_id": project_id or "",
+        "current_status": status or "",
+        "current_context": context or "",
         "page_title": "Eisenhower Matrix",
         "active_nav": "eisenhower",
     })
diff --git a/routers/focus.py b/routers/focus.py
index 7609f6e..2382b74 100644
--- a/routers/focus.py
+++ b/routers/focus.py
@@ -17,7 +17,14 @@ templates = Jinja2Templates(directory="templates")
 
 
 @router.get("/")
-async def focus_view(request: Request, focus_date: Optional[str] = None, db: AsyncSession = Depends(get_db)):
+async def focus_view(
+    request: Request,
+    focus_date: Optional[str] = None,
+    domain_id: Optional[str] = None,
+    area_id: Optional[str] = None,
+    project_id: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+):
     sidebar = await get_sidebar_data(db)
     target_date = date.fromisoformat(focus_date) if focus_date else date.today()
 
@@ -36,30 +43,57 @@ async def focus_view(request: Request, focus_date: Optional[str] = None, db: Asy
     items = [dict(r._mapping) for r in result]
 
     # Available tasks to add (open, not already in today's focus)
-    result = await db.execute(text("""
+    avail_where = [
+        "t.is_deleted = false",
+        "t.status NOT IN ('done', 'cancelled')",
+        "t.id NOT IN (SELECT task_id FROM daily_focus WHERE focus_date = :target_date AND is_deleted = false)",
+    ]
+    avail_params = {"target_date": target_date}
+
+    if domain_id:
+        avail_where.append("t.domain_id = :domain_id")
+        avail_params["domain_id"] = domain_id
+    if area_id:
+        avail_where.append("t.area_id = :area_id")
+        avail_params["area_id"] = area_id
+    if project_id:
+        avail_where.append("t.project_id = :project_id")
+        avail_params["project_id"] = project_id
+
+    avail_sql = " AND ".join(avail_where)
+
+    result = await db.execute(text(f"""
         SELECT t.id, t.title, t.priority, t.due_date,
                p.name as project_name, d.name as domain_name
         FROM tasks t
         LEFT JOIN projects p ON t.project_id = p.id
         LEFT JOIN domains d ON t.domain_id = d.id
-        WHERE t.is_deleted = false AND t.status NOT IN ('done', 'cancelled')
-            AND t.id NOT IN (
-                SELECT task_id FROM daily_focus
-                WHERE focus_date = :target_date AND is_deleted = false
-            )
+        WHERE {avail_sql}
         ORDER BY t.priority ASC, t.due_date ASC NULLS LAST
         LIMIT 50
-    """), {"target_date": target_date})
+    """), avail_params)
     available_tasks = [dict(r._mapping) for r in result]
 
     # Estimated total minutes
     total_est = sum(i.get("estimated_minutes") or 0 for i in items)
 
+    # Filter options
+    domains_repo = BaseRepository("domains", db)
+    domains = await domains_repo.list()
+    areas_repo = BaseRepository("areas", db)
+    areas = await areas_repo.list()
+    projects_repo = BaseRepository("projects", db)
+    projects = await projects_repo.list()
+
     return templates.TemplateResponse("focus.html", {
         "request": request, "sidebar": sidebar,
         "items": items, "available_tasks": available_tasks,
         "focus_date": target_date,
         "total_estimated": total_est,
+        "domains": domains, "areas": areas, "projects": projects,
+        "current_domain_id": domain_id or "",
+        "current_area_id": area_id or "",
+        "current_project_id": project_id or "",
         "page_title": "Daily Focus", "active_nav": "focus",
     })
 
diff --git a/routers/history.py b/routers/history.py
new file mode 100644
index 0000000..36c42f5
--- /dev/null
+++ b/routers/history.py
@@ -0,0 +1,91 @@
+"""Change History: reverse-chronological feed of recently modified items."""
+
+from fastapi import APIRouter, Request, Depends
+from fastapi.templating import Jinja2Templates
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import text
+from typing import Optional
+from datetime import datetime, timezone
+
+from core.database import get_db
+from core.sidebar import get_sidebar_data
+
+router = APIRouter(prefix="/history", tags=["history"])
+templates = Jinja2Templates(directory="templates")
+
+# Entity configs: (table, label_column, type_label, url_prefix)
+HISTORY_ENTITIES = [
+    ("domains", "name", "Domain", "/domains"),
+    ("areas", "name", "Area", "/areas"),
+    ("projects", "name", "Project", "/projects"),
+    ("tasks", "title", "Task", "/tasks"),
+    ("notes", "title", "Note", "/notes"),
+    ("contacts", "first_name", "Contact", "/contacts"),
+    ("meetings", "title", "Meeting", "/meetings"),
+    ("decisions", "title", "Decision", "/decisions"),
+    ("lists", "name", "List", "/lists"),
+    ("weblinks", "label", "Weblink", "/weblinks"),
+    ("appointments", "title", "Appointment", "/appointments"),
+    ("links", "label", "Link", "/links"),
+    ("files", "original_filename", "File", "/files"),
+    ("capture", "content", "Capture", "/capture"),
+]
+
+
+@router.get("/")
+async def history_view(
+    request: Request,
+    entity_type: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+):
+    sidebar = await get_sidebar_data(db)
+
+    all_items = []
+
+    for table, label_col, type_label, url_prefix in HISTORY_ENTITIES:
+        if entity_type and entity_type != table:
+            continue
+
+        try:
+            result = await db.execute(text(f"""
+                SELECT id, {label_col} as label, updated_at, created_at
+                FROM {table}
+                WHERE is_deleted = false
+                ORDER BY updated_at DESC
+                LIMIT 20
+            """))
+            for r in result:
+                row = dict(r._mapping)
+                # Determine action
+                action = "created"
+                if row["updated_at"] and row["created_at"]:
+                    diff = abs((row["updated_at"] - row["created_at"]).total_seconds())
+                    if diff > 1:
+                        action = "modified"
+
+                all_items.append({
+                    "type": table,
+                    "type_label": type_label,
+                    "id": str(row["id"]),
+                    "label": str(row["label"] or "Untitled")[:80],
+                    "url": f"{url_prefix}/{row['id']}",
+                    "updated_at": row["updated_at"],
+                    "action": action,
+                })
+        except Exception:
+            continue
+
+    # Sort by updated_at descending, take top 50
+    all_items.sort(key=lambda x: x["updated_at"] or datetime.min.replace(tzinfo=timezone.utc), reverse=True)
+    all_items = all_items[:50]
+
+    # Build entity type options for filter
+    type_options = [{"value": t[0], "label": t[2]} for t in HISTORY_ENTITIES]
+
+    return templates.TemplateResponse("history.html", {
+        "request": request, "sidebar": sidebar,
+        "items": all_items,
+        "type_options": type_options,
+        "current_type": entity_type or "",
+        "page_title": "Change History", "active_nav": "history",
+    })
diff --git a/routers/lists.py b/routers/lists.py
index a4ccd2a..7f35306 100644
--- a/routers/lists.py
+++ b/routers/lists.py
@@ -70,6 +70,8 @@ async def create_form(
     request: Request,
     domain_id: Optional[str] = None,
     project_id: Optional[str] = None,
+    task_id: Optional[str] = None,
+    meeting_id: Optional[str] = None,
     db: AsyncSession = Depends(get_db),
 ):
     sidebar = await get_sidebar_data(db)
@@ -87,6 +89,8 @@ async def create_form(
         "item": None,
         "prefill_domain_id": domain_id or "",
         "prefill_project_id": project_id or "",
+        "prefill_task_id": task_id or "",
+        "prefill_meeting_id": meeting_id or "",
     })
 
 
@@ -97,6 +101,8 @@ async def create_list(
     domain_id: str = Form(...),
     area_id: Optional[str] = Form(None),
     project_id: Optional[str] = Form(None),
+    task_id: Optional[str] = Form(None),
+    meeting_id: Optional[str] = Form(None),
     list_type: str = Form("checklist"),
     description: Optional[str] = Form(None),
     tags: Optional[str] = Form(None),
@@ -112,10 +118,18 @@ async def create_list(
         data["area_id"] = area_id
     if project_id and project_id.strip():
         data["project_id"] = project_id
+    if task_id and task_id.strip():
+        data["task_id"] = task_id
+    if meeting_id and meeting_id.strip():
+        data["meeting_id"] = meeting_id
     if tags and tags.strip():
         data["tags"] = [t.strip() for t in tags.split(",") if t.strip()]
 
     new_list = await repo.create(data)
+    if task_id and task_id.strip():
+        return RedirectResponse(url=f"/tasks/{task_id}?tab=lists", status_code=303)
+    if meeting_id and meeting_id.strip():
+        return RedirectResponse(url=f"/meetings/{meeting_id}?tab=lists", status_code=303)
     return RedirectResponse(url=f"/lists/{new_list['id']}", status_code=303)
 
 
@@ -156,10 +170,28 @@ async def list_detail(list_id: str, request: Request, db: AsyncSession = Depends
         if pid:
             child_map.setdefault(str(pid), []).append(i)
 
+    # Contacts linked to this list
+    result = await db.execute(text("""
+        SELECT c.*, cl.role, cl.created_at as linked_at
+        FROM contacts c
+        JOIN contact_lists cl ON cl.contact_id = c.id
+        WHERE cl.list_id = :lid AND c.is_deleted = false
+        ORDER BY c.first_name
+    """), {"lid": list_id})
+    contacts = [dict(r._mapping) for r in result]
+
+    # All contacts for add dropdown
+    result = await db.execute(text("""
+        SELECT id, first_name, last_name FROM contacts
+        WHERE is_deleted = false ORDER BY first_name
+    """))
+    all_contacts = [dict(r._mapping) for r in result]
+
     return templates.TemplateResponse("list_detail.html", {
         "request": request, "sidebar": sidebar, "item": item,
         "domain": domain, "project": project,
         "list_items": top_items, "child_map": child_map,
+        "contacts": contacts, "all_contacts": all_contacts,
         "page_title": item["name"], "active_nav": "lists",
     })
 
@@ -273,3 +305,30 @@ async def edit_item(
     repo = BaseRepository("list_items", db)
     await repo.update(item_id, {"content": content})
     return RedirectResponse(url=f"/lists/{list_id}", status_code=303)
+
+
+# ---- Contact linking ----
+
+@router.post("/{list_id}/contacts/add")
+async def add_contact(
+    list_id: str,
+    contact_id: str = Form(...),
+    role: Optional[str] = Form(None),
+    db: AsyncSession = Depends(get_db),
+):
+    await db.execute(text("""
+        INSERT INTO contact_lists (contact_id, list_id, role)
+        VALUES (:cid, :lid, :role) ON CONFLICT DO NOTHING
+    """), {"cid": contact_id, "lid": list_id, "role": role if role and role.strip() else None})
+    return RedirectResponse(url=f"/lists/{list_id}", status_code=303)
+
+
+@router.post("/{list_id}/contacts/{contact_id}/remove")
+async def remove_contact(
+    list_id: str, contact_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    await db.execute(text(
+        "DELETE FROM contact_lists WHERE contact_id = :cid AND list_id = :lid"
+    ), {"cid": contact_id, "lid": list_id})
+    return RedirectResponse(url=f"/lists/{list_id}", status_code=303)
diff --git a/routers/meetings.py b/routers/meetings.py
index 2e907cc..96d4e08 100644
--- a/routers/meetings.py
+++ b/routers/meetings.py
@@ -107,61 +107,118 @@ async def create_meeting(
 
 
 @router.get("/{meeting_id}")
-async def meeting_detail(meeting_id: str, request: Request, db: AsyncSession = Depends(get_db)):
+async def meeting_detail(
+    meeting_id: str, request: Request,
+    tab: str = "overview",
+    db: AsyncSession = Depends(get_db),
+):
     repo = BaseRepository("meetings", db)
     sidebar = await get_sidebar_data(db)
     item = await repo.get(meeting_id)
     if not item:
         return RedirectResponse(url="/meetings", status_code=303)
 
-    # Action items (tasks linked to this meeting)
-    result = await db.execute(text("""
-        SELECT t.*, mt.source,
-               d.name as domain_name, d.color as domain_color,
-               p.name as project_name
-        FROM meeting_tasks mt
-        JOIN tasks t ON mt.task_id = t.id
-        LEFT JOIN domains d ON t.domain_id = d.id
-        LEFT JOIN projects p ON t.project_id = p.id
-        WHERE mt.meeting_id = :mid AND t.is_deleted = false
-        ORDER BY t.sort_order, t.created_at
-    """), {"mid": meeting_id})
-    action_items = [dict(r._mapping) for r in result]
+    # Overview data (always needed for overview tab)
+    action_items = []
+    decisions = []
+    domains = []
+    tab_data = []
+    all_contacts = []
 
-    # Notes linked to this meeting
-    result = await db.execute(text("""
-        SELECT * FROM notes
-        WHERE meeting_id = :mid AND is_deleted = false
-        ORDER BY created_at
-    """), {"mid": meeting_id})
-    meeting_notes = [dict(r._mapping) for r in result]
+    if tab == "overview":
+        # Action items
+        result = await db.execute(text("""
+            SELECT t.*, mt.source,
+                   d.name as domain_name, d.color as domain_color,
+                   p.name as project_name
+            FROM meeting_tasks mt
+            JOIN tasks t ON mt.task_id = t.id
+            LEFT JOIN domains d ON t.domain_id = d.id
+            LEFT JOIN projects p ON t.project_id = p.id
+            WHERE mt.meeting_id = :mid AND t.is_deleted = false
+            ORDER BY t.sort_order, t.created_at
+        """), {"mid": meeting_id})
+        action_items = [dict(r._mapping) for r in result]
 
-    # Decisions from this meeting
-    result = await db.execute(text("""
-        SELECT * FROM decisions
-        WHERE meeting_id = :mid AND is_deleted = false
-        ORDER BY created_at
-    """), {"mid": meeting_id})
-    decisions = [dict(r._mapping) for r in result]
+        # Decisions from this meeting
+        result = await db.execute(text("""
+            SELECT * FROM decisions
+            WHERE meeting_id = :mid AND is_deleted = false
+            ORDER BY created_at
+        """), {"mid": meeting_id})
+        decisions = [dict(r._mapping) for r in result]
 
-    # Attendees
-    result = await db.execute(text("""
-        SELECT c.*, cm.role FROM contact_meetings cm
-        JOIN contacts c ON cm.contact_id = c.id
-        WHERE cm.meeting_id = :mid AND c.is_deleted = false
-        ORDER BY c.first_name
-    """), {"mid": meeting_id})
-    attendees = [dict(r._mapping) for r in result]
+        # Domains for action item creation
+        domains_repo = BaseRepository("domains", db)
+        domains = await domains_repo.list()
 
-    # Domains for action item creation
-    domains_repo = BaseRepository("domains", db)
-    domains = await domains_repo.list()
+    elif tab == "notes":
+        result = await db.execute(text("""
+            SELECT * FROM notes
+            WHERE meeting_id = :mid AND is_deleted = false
+            ORDER BY updated_at DESC
+        """), {"mid": meeting_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "weblinks":
+        result = await db.execute(text("""
+            SELECT * FROM weblinks
+            WHERE meeting_id = :mid AND is_deleted = false
+            ORDER BY sort_order, label
+        """), {"mid": meeting_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "files":
+        result = await db.execute(text("""
+            SELECT f.* FROM files f
+            JOIN file_mappings fm ON fm.file_id = f.id
+            WHERE fm.context_type = 'meeting' AND fm.context_id = :mid AND f.is_deleted = false
+            ORDER BY f.created_at DESC
+        """), {"mid": meeting_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "lists":
+        result = await db.execute(text("""
+            SELECT l.*,
+                (SELECT count(*) FROM list_items li WHERE li.list_id = l.id AND li.is_deleted = false) as item_count
+            FROM lists l
+            WHERE l.meeting_id = :mid AND l.is_deleted = false
+            ORDER BY l.sort_order, l.created_at DESC
+        """), {"mid": meeting_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "contacts":
+        result = await db.execute(text("""
+            SELECT c.*, cm.role, cm.created_at as linked_at
+            FROM contacts c
+            JOIN contact_meetings cm ON cm.contact_id = c.id
+            WHERE cm.meeting_id = :mid AND c.is_deleted = false
+            ORDER BY c.first_name
+        """), {"mid": meeting_id})
+        tab_data = [dict(r._mapping) for r in result]
+        result = await db.execute(text("""
+            SELECT id, first_name, last_name FROM contacts
+            WHERE is_deleted = false ORDER BY first_name
+        """))
+        all_contacts = [dict(r._mapping) for r in result]
+
+    # Tab counts
+    counts = {}
+    for count_tab, count_sql in [
+        ("notes", "SELECT count(*) FROM notes WHERE meeting_id = :mid AND is_deleted = false"),
+        ("weblinks", "SELECT count(*) FROM weblinks WHERE meeting_id = :mid AND is_deleted = false"),
+        ("files", "SELECT count(*) FROM files f JOIN file_mappings fm ON fm.file_id = f.id WHERE fm.context_type = 'meeting' AND fm.context_id = :mid AND f.is_deleted = false"),
+        ("lists", "SELECT count(*) FROM lists WHERE meeting_id = :mid AND is_deleted = false"),
+        ("contacts", "SELECT count(*) FROM contacts c JOIN contact_meetings cm ON cm.contact_id = c.id WHERE cm.meeting_id = :mid AND c.is_deleted = false"),
+    ]:
+        result = await db.execute(text(count_sql), {"mid": meeting_id})
+        counts[count_tab] = result.scalar() or 0
 
     return templates.TemplateResponse("meeting_detail.html", {
         "request": request, "sidebar": sidebar, "item": item,
-        "action_items": action_items, "meeting_notes": meeting_notes,
-        "decisions": decisions, "attendees": attendees,
-        "domains": domains,
+        "action_items": action_items, "decisions": decisions,
+        "domains": domains, "tab": tab, "tab_data": tab_data,
+        "all_contacts": all_contacts, "counts": counts,
         "page_title": item["title"], "active_nav": "meetings",
     })
 
@@ -266,3 +323,30 @@ async def create_action_item(
     """), {"mid": meeting_id, "tid": task["id"]})
 
     return RedirectResponse(url=f"/meetings/{meeting_id}", status_code=303)
+
+
+# ---- Contact linking ----
+
+@router.post("/{meeting_id}/contacts/add")
+async def add_contact(
+    meeting_id: str,
+    contact_id: str = Form(...),
+    role: str = Form("attendee"),
+    db: AsyncSession = Depends(get_db),
+):
+    await db.execute(text("""
+        INSERT INTO contact_meetings (contact_id, meeting_id, role)
+        VALUES (:cid, :mid, :role) ON CONFLICT DO NOTHING
+    """), {"cid": contact_id, "mid": meeting_id, "role": role if role and role.strip() else "attendee"})
+    return RedirectResponse(url=f"/meetings/{meeting_id}?tab=contacts", status_code=303)
+
+
+@router.post("/{meeting_id}/contacts/{contact_id}/remove")
+async def remove_contact(
+    meeting_id: str, contact_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    await db.execute(text(
+        "DELETE FROM contact_meetings WHERE contact_id = :cid AND meeting_id = :mid"
+    ), {"cid": contact_id, "mid": meeting_id})
+    return RedirectResponse(url=f"/meetings/{meeting_id}?tab=contacts", status_code=303)
diff --git a/routers/notes.py b/routers/notes.py
index 7cd1145..cce03a7 100644
--- a/routers/notes.py
+++ b/routers/notes.py
@@ -61,6 +61,8 @@ async def create_form(
     request: Request,
     domain_id: Optional[str] = None,
     project_id: Optional[str] = None,
+    task_id: Optional[str] = None,
+    meeting_id: Optional[str] = None,
     db: AsyncSession = Depends(get_db),
 ):
     sidebar = await get_sidebar_data(db)
@@ -75,6 +77,8 @@ async def create_form(
         "item": None,
         "prefill_domain_id": domain_id or "",
         "prefill_project_id": project_id or "",
+        "prefill_task_id": task_id or "",
+        "prefill_meeting_id": meeting_id or "",
     })
 
 
@@ -84,6 +88,8 @@ async def create_note(
     title: str = Form(...),
     domain_id: str = Form(...),
     project_id: Optional[str] = Form(None),
+    task_id: Optional[str] = Form(None),
+    meeting_id: Optional[str] = Form(None),
     body: Optional[str] = Form(None),
     content_format: str = Form("rich"),
     tags: Optional[str] = Form(None),
@@ -96,9 +102,17 @@ async def create_note(
     }
     if project_id and project_id.strip():
         data["project_id"] = project_id
+    if task_id and task_id.strip():
+        data["task_id"] = task_id
+    if meeting_id and meeting_id.strip():
+        data["meeting_id"] = meeting_id
     if tags and tags.strip():
         data["tags"] = [t.strip() for t in tags.split(",") if t.strip()]
     note = await repo.create(data)
+    if task_id and task_id.strip():
+        return RedirectResponse(url=f"/tasks/{task_id}?tab=notes", status_code=303)
+    if meeting_id and meeting_id.strip():
+        return RedirectResponse(url=f"/meetings/{meeting_id}?tab=notes", status_code=303)
     return RedirectResponse(url=f"/notes/{note['id']}", status_code=303)
 
 
diff --git a/routers/projects.py b/routers/projects.py
index f53b99c..fe998d5 100644
--- a/routers/projects.py
+++ b/routers/projects.py
@@ -2,7 +2,7 @@
 
 from fastapi import APIRouter, Request, Form, Depends
 from fastapi.templating import Jinja2Templates
-from fastapi.responses import RedirectResponse
+from fastapi.responses import RedirectResponse, JSONResponse
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import text
 from typing import Optional
@@ -15,6 +15,27 @@ router = APIRouter(prefix="/projects", tags=["projects"])
 templates = Jinja2Templates(directory="templates")
 
 
+@router.get("/api/by-domain")
+async def api_projects_by_domain(
+    domain_id: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+):
+    """JSON API: return projects filtered by domain_id for dynamic dropdowns."""
+    if domain_id:
+        result = await db.execute(text("""
+            SELECT id, name FROM projects
+            WHERE is_deleted = false AND (domain_id = :did OR domain_id IS NULL)
+            ORDER BY name
+        """), {"did": domain_id})
+    else:
+        result = await db.execute(text("""
+            SELECT id, name FROM projects
+            WHERE is_deleted = false ORDER BY name
+        """))
+    projects = [{"id": str(r.id), "name": r.name} for r in result]
+    return JSONResponse(content=projects)
+
+
 @router.get("/")
 async def list_projects(
     request: Request,
@@ -151,7 +172,7 @@ async def project_detail(
         row = result.first()
         area = dict(row._mapping) if row else None
 
-    # Tasks for this project
+    # Tasks for this project (always needed for progress bar)
     result = await db.execute(text("""
         SELECT t.*, d.name as domain_name, d.color as domain_color
         FROM tasks t
@@ -161,29 +182,92 @@ async def project_detail(
     """), {"pid": project_id})
     tasks = [dict(r._mapping) for r in result]
 
-    # Notes
-    result = await db.execute(text("""
-        SELECT * FROM notes WHERE project_id = :pid AND is_deleted = false
-        ORDER BY sort_order, created_at DESC
-    """), {"pid": project_id})
-    notes = [dict(r._mapping) for r in result]
-
-    # Links
-    result = await db.execute(text("""
-        SELECT * FROM links WHERE project_id = :pid AND is_deleted = false
-        ORDER BY sort_order, created_at
-    """), {"pid": project_id})
-    links = [dict(r._mapping) for r in result]
-
     # Progress
     total = len(tasks)
     done = len([t for t in tasks if t["status"] == "done"])
     progress = round((done / total * 100) if total > 0 else 0)
 
+    # Tab-specific data
+    notes = []
+    links = []
+    tab_data = []
+    all_contacts = []
+
+    if tab == "notes":
+        result = await db.execute(text("""
+            SELECT * FROM notes WHERE project_id = :pid AND is_deleted = false
+            ORDER BY sort_order, created_at DESC
+        """), {"pid": project_id})
+        notes = [dict(r._mapping) for r in result]
+
+    elif tab == "links":
+        result = await db.execute(text("""
+            SELECT * FROM links WHERE project_id = :pid AND is_deleted = false
+            ORDER BY sort_order, created_at
+        """), {"pid": project_id})
+        links = [dict(r._mapping) for r in result]
+
+    elif tab == "files":
+        result = await db.execute(text("""
+            SELECT f.* FROM files f
+            JOIN file_mappings fm ON fm.file_id = f.id
+            WHERE fm.context_type = 'project' AND fm.context_id = :pid AND f.is_deleted = false
+            ORDER BY f.created_at DESC
+        """), {"pid": project_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "lists":
+        result = await db.execute(text("""
+            SELECT l.*,
+                (SELECT count(*) FROM list_items li WHERE li.list_id = l.id AND li.is_deleted = false) as item_count
+            FROM lists l
+            WHERE l.project_id = :pid AND l.is_deleted = false
+            ORDER BY l.sort_order, l.created_at DESC
+        """), {"pid": project_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "decisions":
+        result = await db.execute(text("""
+            SELECT d.* FROM decisions d
+            JOIN decision_projects dp ON dp.decision_id = d.id
+            WHERE dp.project_id = :pid AND d.is_deleted = false
+            ORDER BY d.created_at DESC
+        """), {"pid": project_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "contacts":
+        result = await db.execute(text("""
+            SELECT c.*, cp.role, cp.created_at as linked_at
+            FROM contacts c
+            JOIN contact_projects cp ON cp.contact_id = c.id
+            WHERE cp.project_id = :pid AND c.is_deleted = false
+            ORDER BY c.first_name
+        """), {"pid": project_id})
+        tab_data = [dict(r._mapping) for r in result]
+        result = await db.execute(text("""
+            SELECT id, first_name, last_name FROM contacts
+            WHERE is_deleted = false ORDER BY first_name
+        """))
+        all_contacts = [dict(r._mapping) for r in result]
+
+    # Tab counts
+    counts = {}
+    for count_tab, count_sql in [
+        ("notes", "SELECT count(*) FROM notes WHERE project_id = :pid AND is_deleted = false"),
+        ("links", "SELECT count(*) FROM links WHERE project_id = :pid AND is_deleted = false"),
+        ("files", "SELECT count(*) FROM files f JOIN file_mappings fm ON fm.file_id = f.id WHERE fm.context_type = 'project' AND fm.context_id = :pid AND f.is_deleted = false"),
+        ("lists", "SELECT count(*) FROM lists WHERE project_id = :pid AND is_deleted = false"),
+        ("decisions", "SELECT count(*) FROM decisions d JOIN decision_projects dp ON dp.decision_id = d.id WHERE dp.project_id = :pid AND d.is_deleted = false"),
+        ("contacts", "SELECT count(*) FROM contacts c JOIN contact_projects cp ON cp.contact_id = c.id WHERE cp.project_id = :pid AND c.is_deleted = false"),
+    ]:
+        result = await db.execute(text(count_sql), {"pid": project_id})
+        counts[count_tab] = result.scalar() or 0
+
     return templates.TemplateResponse("project_detail.html", {
         "request": request, "sidebar": sidebar, "item": item,
         "domain": domain, "area": area,
         "tasks": tasks, "notes": notes, "links": links,
+        "tab_data": tab_data, "all_contacts": all_contacts, "counts": counts,
         "progress": progress, "task_count": total, "done_count": done,
         "tab": tab,
         "page_title": item["name"], "active_nav": "projects",
@@ -246,3 +330,30 @@ async def delete_project(project_id: str, db: AsyncSession = Depends(get_db)):
     repo = BaseRepository("projects", db)
     await repo.soft_delete(project_id)
     return RedirectResponse(url="/projects", status_code=303)
+
+
+# ---- Contact linking ----
+
+@router.post("/{project_id}/contacts/add")
+async def add_contact(
+    project_id: str,
+    contact_id: str = Form(...),
+    role: Optional[str] = Form(None),
+    db: AsyncSession = Depends(get_db),
+):
+    await db.execute(text("""
+        INSERT INTO contact_projects (contact_id, project_id, role)
+        VALUES (:cid, :pid, :role) ON CONFLICT DO NOTHING
+    """), {"cid": contact_id, "pid": project_id, "role": role if role and role.strip() else None})
+    return RedirectResponse(url=f"/projects/{project_id}?tab=contacts", status_code=303)
+
+
+@router.post("/{project_id}/contacts/{contact_id}/remove")
+async def remove_contact(
+    project_id: str, contact_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    await db.execute(text(
+        "DELETE FROM contact_projects WHERE contact_id = :cid AND project_id = :pid"
+    ), {"cid": contact_id, "pid": project_id})
+    return RedirectResponse(url=f"/projects/{project_id}?tab=contacts", status_code=303)
diff --git a/routers/search.py b/routers/search.py
index c33bd84..89ff9a4 100644
--- a/routers/search.py
+++ b/routers/search.py
@@ -1,5 +1,6 @@
 """Global search: Cmd/K modal, tsvector full-text search across all entities."""
 
+import re
 from fastapi import APIRouter, Request, Depends, Query
 from fastapi.templating import Jinja2Templates
 from fastapi.responses import JSONResponse
@@ -14,174 +15,162 @@ router = APIRouter(prefix="/search", tags=["search"])
 templates = Jinja2Templates(directory="templates")
 
 
-# Entity search configs: (table, title_col, subtitle_query, url_pattern, icon)
+def build_prefix_tsquery(query: str) -> Optional[str]:
+    """Build a prefix-matching tsquery string from user input.
+    'Sys Admin' -> 'Sys:* & Admin:*'
+    Returns None if no valid terms.
+    """
+    terms = query.strip().split()
+    # Keep only alphanumeric terms >= 2 chars
+    clean = [re.sub(r'[^\w]', '', t) for t in terms]
+    clean = [t for t in clean if len(t) >= 2]
+    if not clean:
+        return None
+    return " & ".join(f"{t}:*" for t in clean)
+
+
+# Entity search configs
+# Each has: type, label, table, name_col, joins, extra_cols, url, icon
 SEARCH_ENTITIES = [
     {
-        "type": "tasks",
-        "label": "Tasks",
-        "query": """
-            SELECT t.id, t.title as name, t.status,
-                   d.name as domain_name, p.name as project_name,
-                   ts_rank(t.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM tasks t
-            LEFT JOIN domains d ON t.domain_id = d.id
-            LEFT JOIN projects p ON t.project_id = p.id
-            WHERE t.is_deleted = false AND t.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/tasks/{id}",
-        "icon": "task",
+        "type": "tasks", "label": "Tasks", "table": "tasks", "alias": "t",
+        "name_col": "t.title", "status_col": "t.status",
+        "joins": "LEFT JOIN domains d ON t.domain_id = d.id LEFT JOIN projects p ON t.project_id = p.id",
+        "domain_col": "d.name", "project_col": "p.name",
+        "url": "/tasks/{id}", "icon": "task",
     },
     {
-        "type": "projects",
-        "label": "Projects",
-        "query": """
-            SELECT p.id, p.name, p.status,
-                   d.name as domain_name, NULL as project_name,
-                   ts_rank(p.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM projects p
-            LEFT JOIN domains d ON p.domain_id = d.id
-            WHERE p.is_deleted = false AND p.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/projects/{id}",
-        "icon": "project",
+        "type": "projects", "label": "Projects", "table": "projects", "alias": "p",
+        "name_col": "p.name", "status_col": "p.status",
+        "joins": "LEFT JOIN domains d ON p.domain_id = d.id",
+        "domain_col": "d.name", "project_col": "NULL",
+        "url": "/projects/{id}", "icon": "project",
     },
     {
-        "type": "notes",
-        "label": "Notes",
-        "query": """
-            SELECT n.id, n.title as name, NULL as status,
-                   d.name as domain_name, p.name as project_name,
-                   ts_rank(n.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM notes n
-            LEFT JOIN domains d ON n.domain_id = d.id
-            LEFT JOIN projects p ON n.project_id = p.id
-            WHERE n.is_deleted = false AND n.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/notes/{id}",
-        "icon": "note",
+        "type": "notes", "label": "Notes", "table": "notes", "alias": "n",
+        "name_col": "n.title", "status_col": "NULL",
+        "joins": "LEFT JOIN domains d ON n.domain_id = d.id LEFT JOIN projects p ON n.project_id = p.id",
+        "domain_col": "d.name", "project_col": "p.name",
+        "url": "/notes/{id}", "icon": "note",
     },
     {
-        "type": "contacts",
-        "label": "Contacts",
-        "query": """
-            SELECT c.id, (c.first_name || ' ' || coalesce(c.last_name, '')) as name,
-                   NULL as status, c.company as domain_name, NULL as project_name,
-                   ts_rank(c.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM contacts c
-            WHERE c.is_deleted = false AND c.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/contacts/{id}",
-        "icon": "contact",
+        "type": "contacts", "label": "Contacts", "table": "contacts", "alias": "c",
+        "name_col": "(c.first_name || ' ' || coalesce(c.last_name, ''))", "status_col": "NULL",
+        "joins": "",
+        "domain_col": "c.company", "project_col": "NULL",
+        "url": "/contacts/{id}", "icon": "contact",
     },
     {
-        "type": "links",
-        "label": "Links",
-        "query": """
-            SELECT l.id, l.label as name, NULL as status,
-                   d.name as domain_name, p.name as project_name,
-                   ts_rank(l.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM links l
-            LEFT JOIN domains d ON l.domain_id = d.id
-            LEFT JOIN projects p ON l.project_id = p.id
-            WHERE l.is_deleted = false AND l.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/links",
-        "icon": "link",
+        "type": "links", "label": "Links", "table": "links", "alias": "l",
+        "name_col": "l.label", "status_col": "NULL",
+        "joins": "LEFT JOIN domains d ON l.domain_id = d.id LEFT JOIN projects p ON l.project_id = p.id",
+        "domain_col": "d.name", "project_col": "p.name",
+        "url": "/links", "icon": "link",
     },
     {
-        "type": "lists",
-        "label": "Lists",
-        "query": """
-            SELECT l.id, l.name, NULL as status,
-                   d.name as domain_name, p.name as project_name,
-                   ts_rank(l.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM lists l
-            LEFT JOIN domains d ON l.domain_id = d.id
-            LEFT JOIN projects p ON l.project_id = p.id
-            WHERE l.is_deleted = false AND l.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/lists/{id}",
-        "icon": "list",
+        "type": "lists", "label": "Lists", "table": "lists", "alias": "l",
+        "name_col": "l.name", "status_col": "NULL",
+        "joins": "LEFT JOIN domains d ON l.domain_id = d.id LEFT JOIN projects p ON l.project_id = p.id",
+        "domain_col": "d.name", "project_col": "p.name",
+        "url": "/lists/{id}", "icon": "list",
     },
     {
-        "type": "meetings",
-        "label": "Meetings",
-        "query": """
-            SELECT m.id, m.title as name, m.status,
-                   NULL as domain_name, NULL as project_name,
-                   ts_rank(m.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM meetings m
-            WHERE m.is_deleted = false AND m.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/meetings/{id}",
-        "icon": "meeting",
+        "type": "meetings", "label": "Meetings", "table": "meetings", "alias": "m",
+        "name_col": "m.title", "status_col": "m.status",
+        "joins": "",
+        "domain_col": "NULL", "project_col": "NULL",
+        "url": "/meetings/{id}", "icon": "meeting",
     },
     {
-        "type": "decisions",
-        "label": "Decisions",
-        "query": """
-            SELECT d.id, d.title as name, d.status,
-                   NULL as domain_name, NULL as project_name,
-                   ts_rank(d.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM decisions d
-            WHERE d.is_deleted = false AND d.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/decisions/{id}",
-        "icon": "decision",
+        "type": "decisions", "label": "Decisions", "table": "decisions", "alias": "d",
+        "name_col": "d.title", "status_col": "d.status",
+        "joins": "",
+        "domain_col": "NULL", "project_col": "NULL",
+        "url": "/decisions/{id}", "icon": "decision",
     },
     {
-        "type": "weblinks",
-        "label": "Weblinks",
-        "query": """
-            SELECT w.id, w.label as name, NULL as status,
-                   NULL as domain_name, NULL as project_name,
-                   ts_rank(w.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM weblinks w
-            WHERE w.is_deleted = false AND w.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/weblinks",
-        "icon": "weblink",
+        "type": "weblinks", "label": "Weblinks", "table": "weblinks", "alias": "w",
+        "name_col": "w.label", "status_col": "NULL",
+        "joins": "",
+        "domain_col": "NULL", "project_col": "NULL",
+        "url": "/weblinks", "icon": "weblink",
     },
     {
-        "type": "processes",
-        "label": "Processes",
-        "query": """
-            SELECT p.id, p.name, p.status,
-                   p.category as domain_name, NULL as project_name,
-                   ts_rank(p.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM processes p
-            WHERE p.is_deleted = false AND p.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/processes/{id}",
-        "icon": "process",
+        "type": "processes", "label": "Processes", "table": "processes", "alias": "p",
+        "name_col": "p.name", "status_col": "p.status",
+        "joins": "",
+        "domain_col": "p.category", "project_col": "NULL",
+        "url": "/processes/{id}", "icon": "process",
     },
     {
-        "type": "appointments",
-        "label": "Appointments",
-        "query": """
-            SELECT a.id, a.title as name, NULL as status,
-                   a.location as domain_name, NULL as project_name,
-                   ts_rank(a.search_vector, websearch_to_tsquery('english', :q)) as rank
-            FROM appointments a
-            WHERE a.is_deleted = false AND a.search_vector @@ websearch_to_tsquery('english', :q)
-            ORDER BY rank DESC LIMIT :lim
-        """,
-        "url": "/appointments/{id}",
-        "icon": "appointment",
+        "type": "appointments", "label": "Appointments", "table": "appointments", "alias": "a",
+        "name_col": "a.title", "status_col": "NULL",
+        "joins": "",
+        "domain_col": "a.location", "project_col": "NULL",
+        "url": "/appointments/{id}", "icon": "appointment",
     },
 ]
 
 
+async def _search_entity(entity: dict, q: str, tsquery_str: str, limit: int, db: AsyncSession) -> list[dict]:
+    """Search a single entity using prefix tsquery, with ILIKE fallback."""
+    a = entity["alias"]
+    results = []
+    seen_ids = set()
+
+    # 1. tsvector prefix search
+    if tsquery_str:
+        sql = f"""
+            SELECT {a}.id, {entity['name_col']} as name, {entity['status_col']} as status,
+                   {entity['domain_col']} as domain_name, {entity['project_col']} as project_name,
+                   ts_rank({a}.search_vector, to_tsquery('english', :tsq)) as rank
+            FROM {entity['table']} {a}
+            {entity['joins']}
+            WHERE {a}.is_deleted = false AND {a}.search_vector @@ to_tsquery('english', :tsq)
+            ORDER BY rank DESC LIMIT :lim
+        """
+        try:
+            result = await db.execute(text(sql), {"tsq": tsquery_str, "lim": limit})
+            for r in result:
+                row = dict(r._mapping)
+                results.append(row)
+                seen_ids.add(str(row["id"]))
+        except Exception:
+            pass
+
+    # 2. ILIKE fallback if < 3 tsvector results
+    if len(results) < 3:
+        ilike_param = f"%{q.strip()}%"
+        remaining = limit - len(results)
+        if remaining > 0:
+            # Build exclusion for already-found IDs
+            exclude_sql = ""
+            params = {"ilike_q": ilike_param, "lim2": remaining}
+            if seen_ids:
+                id_placeholders = ", ".join(f":ex_{i}" for i in range(len(seen_ids)))
+                exclude_sql = f"AND {a}.id NOT IN ({id_placeholders})"
+                for i, sid in enumerate(seen_ids):
+                    params[f"ex_{i}"] = sid
+
+            sql2 = f"""
+                SELECT {a}.id, {entity['name_col']} as name, {entity['status_col']} as status,
+                       {entity['domain_col']} as domain_name, {entity['project_col']} as project_name,
+                       0.0 as rank
+                FROM {entity['table']} {a}
+                {entity['joins']}
+                WHERE {a}.is_deleted = false AND {entity['name_col']} ILIKE :ilike_q {exclude_sql}
+                ORDER BY {entity['name_col']} LIMIT :lim2
+            """
+            try:
+                result = await db.execute(text(sql2), params)
+                for r in result:
+                    results.append(dict(r._mapping))
+            except Exception:
+                pass
+
+    return results
+
+
 @router.get("/api")
 async def search_api(
     q: str = Query("", min_length=1),
@@ -190,33 +179,30 @@ async def search_api(
     db: AsyncSession = Depends(get_db),
 ):
     """JSON search endpoint for the Cmd/K modal."""
-    if not q or not q.strip():
+    if not q or not q.strip() or len(q.strip()) < 2:
         return JSONResponse({"results": [], "query": q})
 
+    tsquery_str = build_prefix_tsquery(q)
+
     results = []
     entities = SEARCH_ENTITIES
     if entity_type:
         entities = [e for e in entities if e["type"] == entity_type]
 
     for entity in entities:
-        try:
-            result = await db.execute(text(entity["query"]), {"q": q.strip(), "lim": limit})
-            rows = [dict(r._mapping) for r in result]
-            for row in rows:
-                results.append({
-                    "type": entity["type"],
-                    "type_label": entity["label"],
-                    "id": str(row["id"]),
-                    "name": row["name"],
-                    "status": row.get("status"),
-                    "context": " / ".join(filter(None, [row.get("domain_name"), row.get("project_name")])),
-                    "url": entity["url"].format(id=row["id"]),
-                    "rank": float(row.get("rank", 0)),
-                    "icon": entity["icon"],
-                })
-        except Exception:
-            # Table might not have search_vector yet, skip silently
-            continue
+        rows = await _search_entity(entity, q, tsquery_str, limit, db)
+        for row in rows:
+            results.append({
+                "type": entity["type"],
+                "type_label": entity["label"],
+                "id": str(row["id"]),
+                "name": row["name"],
+                "status": row.get("status"),
+                "context": " / ".join(filter(None, [row.get("domain_name"), row.get("project_name")])),
+                "url": entity["url"].format(id=row["id"]),
+                "rank": float(row.get("rank", 0)),
+                "icon": entity["icon"],
+            })
 
     # Sort all results by rank descending
     results.sort(key=lambda r: r["rank"], reverse=True)
@@ -234,24 +220,22 @@ async def search_page(
     sidebar = await get_sidebar_data(db)
     results = []
 
-    if q and q.strip():
+    if q and q.strip() and len(q.strip()) >= 2:
+        tsquery_str = build_prefix_tsquery(q)
+
         for entity in SEARCH_ENTITIES:
-            try:
-                result = await db.execute(text(entity["query"]), {"q": q.strip(), "lim": 10})
-                rows = [dict(r._mapping) for r in result]
-                for row in rows:
-                    results.append({
-                        "type": entity["type"],
-                        "type_label": entity["label"],
-                        "id": str(row["id"]),
-                        "name": row["name"],
-                        "status": row.get("status"),
-                        "context": " / ".join(filter(None, [row.get("domain_name"), row.get("project_name")])),
-                        "url": entity["url"].format(id=row["id"]),
-                        "icon": entity["icon"],
-                    })
-            except Exception:
-                continue
+            rows = await _search_entity(entity, q, tsquery_str, 10, db)
+            for row in rows:
+                results.append({
+                    "type": entity["type"],
+                    "type_label": entity["label"],
+                    "id": str(row["id"]),
+                    "name": row["name"],
+                    "status": row.get("status"),
+                    "context": " / ".join(filter(None, [row.get("domain_name"), row.get("project_name")])),
+                    "url": entity["url"].format(id=row["id"]),
+                    "icon": entity["icon"],
+                })
 
     return templates.TemplateResponse("search.html", {
         "request": request, "sidebar": sidebar,
diff --git a/routers/tasks.py b/routers/tasks.py
index bdab823..b087fd8 100644
--- a/routers/tasks.py
+++ b/routers/tasks.py
@@ -186,7 +186,11 @@ async def create_task(
 
 
 @router.get("/{task_id}")
-async def task_detail(task_id: str, request: Request, db: AsyncSession = Depends(get_db)):
+async def task_detail(
+    task_id: str, request: Request,
+    tab: str = "overview",
+    db: AsyncSession = Depends(get_db),
+):
     repo = BaseRepository("tasks", db)
     sidebar = await get_sidebar_data(db)
     item = await repo.get(task_id)
@@ -212,19 +216,101 @@ async def task_detail(task_id: str, request: Request, db: AsyncSession = Depends
         row = result.first()
         parent = dict(row._mapping) if row else None
 
-    # Subtasks
-    result = await db.execute(text("""
-        SELECT * FROM tasks WHERE parent_id = :tid AND is_deleted = false
-        ORDER BY sort_order, created_at
-    """), {"tid": task_id})
-    subtasks = [dict(r._mapping) for r in result]
+    # Subtasks (always needed for overview tab)
+    subtasks = []
+    if tab == "overview":
+        result = await db.execute(text("""
+            SELECT * FROM tasks WHERE parent_id = :tid AND is_deleted = false
+            ORDER BY sort_order, created_at
+        """), {"tid": task_id})
+        subtasks = [dict(r._mapping) for r in result]
 
     running_task_id = await get_running_task_id(db)
 
+    # Tab-specific data
+    tab_data = []
+    all_contacts = []
+
+    if tab == "notes":
+        result = await db.execute(text("""
+            SELECT * FROM notes WHERE task_id = :tid AND is_deleted = false
+            ORDER BY updated_at DESC
+        """), {"tid": task_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "weblinks":
+        result = await db.execute(text("""
+            SELECT * FROM weblinks WHERE task_id = :tid AND is_deleted = false
+            ORDER BY sort_order, label
+        """), {"tid": task_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "files":
+        result = await db.execute(text("""
+            SELECT f.* FROM files f
+            JOIN file_mappings fm ON fm.file_id = f.id
+            WHERE fm.context_type = 'task' AND fm.context_id = :tid AND f.is_deleted = false
+            ORDER BY f.created_at DESC
+        """), {"tid": task_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "lists":
+        result = await db.execute(text("""
+            SELECT l.*,
+                (SELECT count(*) FROM list_items li WHERE li.list_id = l.id AND li.is_deleted = false) as item_count
+            FROM lists l
+            WHERE l.task_id = :tid AND l.is_deleted = false
+            ORDER BY l.sort_order, l.created_at DESC
+        """), {"tid": task_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "decisions":
+        result = await db.execute(text("""
+            SELECT * FROM decisions WHERE task_id = :tid AND is_deleted = false
+            ORDER BY created_at DESC
+        """), {"tid": task_id})
+        tab_data = [dict(r._mapping) for r in result]
+
+    elif tab == "contacts":
+        result = await db.execute(text("""
+            SELECT c.*, ct.role, ct.created_at as linked_at
+            FROM contacts c
+            JOIN contact_tasks ct ON ct.contact_id = c.id
+            WHERE ct.task_id = :tid AND c.is_deleted = false
+            ORDER BY c.first_name
+        """), {"tid": task_id})
+        tab_data = [dict(r._mapping) for r in result]
+        # All contacts for add dropdown
+        result = await db.execute(text("""
+            SELECT id, first_name, last_name FROM contacts
+            WHERE is_deleted = false ORDER BY first_name
+        """))
+        all_contacts = [dict(r._mapping) for r in result]
+
+    # Tab counts for badges
+    counts = {}
+    for count_tab, count_sql in [
+        ("notes", "SELECT count(*) FROM notes WHERE task_id = :tid AND is_deleted = false"),
+        ("weblinks", "SELECT count(*) FROM weblinks WHERE task_id = :tid AND is_deleted = false"),
+        ("files", "SELECT count(*) FROM files f JOIN file_mappings fm ON fm.file_id = f.id WHERE fm.context_type = 'task' AND fm.context_id = :tid AND f.is_deleted = false"),
+        ("lists", "SELECT count(*) FROM lists WHERE task_id = :tid AND is_deleted = false"),
+        ("decisions", "SELECT count(*) FROM decisions WHERE task_id = :tid AND is_deleted = false"),
+        ("contacts", "SELECT count(*) FROM contacts c JOIN contact_tasks ct ON ct.contact_id = c.id WHERE ct.task_id = :tid AND c.is_deleted = false"),
+    ]:
+        result = await db.execute(text(count_sql), {"tid": task_id})
+        counts[count_tab] = result.scalar() or 0
+
+    # Subtask count for overview badge
+    result = await db.execute(text(
+        "SELECT count(*) FROM tasks WHERE parent_id = :tid AND is_deleted = false"
+    ), {"tid": task_id})
+    counts["overview"] = result.scalar() or 0
+
     return templates.TemplateResponse("task_detail.html", {
         "request": request, "sidebar": sidebar, "item": item,
         "domain": domain, "project": project, "parent": parent,
-        "subtasks": subtasks,
+        "subtasks": subtasks, "tab": tab, "tab_data": tab_data,
+        "all_contacts": all_contacts, "counts": counts,
         "running_task_id": running_task_id,
         "page_title": item["title"], "active_nav": "tasks",
     })
@@ -368,3 +454,30 @@ async def quick_add(
     await repo.create(data)
     referer = request.headers.get("referer", "/tasks")
     return RedirectResponse(url=referer, status_code=303)
+
+
+# ---- Contact linking ----
+
+@router.post("/{task_id}/contacts/add")
+async def add_contact(
+    task_id: str,
+    contact_id: str = Form(...),
+    role: Optional[str] = Form(None),
+    db: AsyncSession = Depends(get_db),
+):
+    await db.execute(text("""
+        INSERT INTO contact_tasks (contact_id, task_id, role)
+        VALUES (:cid, :tid, :role) ON CONFLICT DO NOTHING
+    """), {"cid": contact_id, "tid": task_id, "role": role if role and role.strip() else None})
+    return RedirectResponse(url=f"/tasks/{task_id}?tab=contacts", status_code=303)
+
+
+@router.post("/{task_id}/contacts/{contact_id}/remove")
+async def remove_contact(
+    task_id: str, contact_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    await db.execute(text(
+        "DELETE FROM contact_tasks WHERE contact_id = :cid AND task_id = :tid"
+    ), {"cid": contact_id, "tid": task_id})
+    return RedirectResponse(url=f"/tasks/{task_id}?tab=contacts", status_code=303)
diff --git a/routers/weblinks.py b/routers/weblinks.py
index 3971967..baad7bb 100644
--- a/routers/weblinks.py
+++ b/routers/weblinks.py
@@ -78,6 +78,8 @@ async def list_weblinks(
 async def create_form(
     request: Request,
     folder_id: Optional[str] = None,
+    task_id: Optional[str] = None,
+    meeting_id: Optional[str] = None,
     db: AsyncSession = Depends(get_db),
 ):
     sidebar = await get_sidebar_data(db)
@@ -92,6 +94,8 @@ async def create_form(
         "page_title": "New Weblink", "active_nav": "weblinks",
         "item": None,
         "prefill_folder_id": folder_id or "",
+        "prefill_task_id": task_id or "",
+        "prefill_meeting_id": meeting_id or "",
     })
 
 
@@ -102,11 +106,17 @@ async def create_weblink(
     url: str = Form(...),
     description: Optional[str] = Form(None),
     folder_id: Optional[str] = Form(None),
+    task_id: Optional[str] = Form(None),
+    meeting_id: Optional[str] = Form(None),
     tags: Optional[str] = Form(None),
     db: AsyncSession = Depends(get_db),
 ):
     repo = BaseRepository("weblinks", db)
     data = {"label": label, "url": url, "description": description}
+    if task_id and task_id.strip():
+        data["task_id"] = task_id
+    if meeting_id and meeting_id.strip():
+        data["meeting_id"] = meeting_id
     if tags and tags.strip():
         data["tags"] = [t.strip() for t in tags.split(",") if t.strip()]
 
@@ -119,6 +129,10 @@ async def create_weblink(
             VALUES (:fid, :wid) ON CONFLICT DO NOTHING
         """), {"fid": folder_id, "wid": weblink["id"]})
 
+    if task_id and task_id.strip():
+        return RedirectResponse(url=f"/tasks/{task_id}?tab=weblinks", status_code=303)
+    if meeting_id and meeting_id.strip():
+        return RedirectResponse(url=f"/meetings/{meeting_id}?tab=weblinks", status_code=303)
     redirect_url = f"/weblinks?folder_id={folder_id}" if folder_id and folder_id.strip() else "/weblinks"
     return RedirectResponse(url=redirect_url, status_code=303)
 
diff --git a/static/style.css b/static/style.css
index 4d22214..5284987 100644
--- a/static/style.css
+++ b/static/style.css
@@ -1451,9 +1451,8 @@ a:hover { color: var(--accent-hover); }
 .eisenhower-grid {
     display: grid;
     grid-template-columns: 32px 1fr 1fr;
-    grid-template-rows: 1fr 1fr auto;
+    grid-template-rows: auto auto auto;
     gap: 12px;
-    min-height: 60vh;
 }
 
 .eisenhower-y-label {
@@ -1488,9 +1487,9 @@ a:hover { color: var(--accent-hover); }
     border: 1px solid var(--border);
     border-radius: var(--radius-lg);
     padding: 16px;
+    min-height: 200px;
     display: flex;
     flex-direction: column;
-    overflow: hidden;
 }
 
 .eisenhower-q1 { border-top: 3px solid var(--red); }
diff --git a/templates/base.html b/templates/base.html
index aa237da..ed306a7 100644
--- a/templates/base.html
+++ b/templates/base.html
@@ -131,6 +131,10 @@
             </div>
 
             <div class="nav-section" style="margin-top: auto; padding-bottom: 12px;">
+                <a href="/history" class="nav-item {{ 'active' if active_nav == 'history' }}">
+                    <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
+                    History
+                </a>
                 <a href="/admin/trash" class="nav-item {{ 'active' if active_nav == 'trash' }}">
                     <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>
                     Trash
diff --git a/templates/decision_form.html b/templates/decision_form.html
index 2e9d117..6a7c2a3 100644
--- a/templates/decision_form.html
+++ b/templates/decision_form.html
@@ -77,9 +77,10 @@
             </div>
         </div>
 
+        {% if prefill_task_id is defined and prefill_task_id %}<input type="hidden" name="task_id" value="{{ prefill_task_id }}">{% endif %}
         <div class="form-actions">
             <button type="submit" class="btn btn-primary">{{ 'Save Changes' if item else 'Record Decision' }}</button>
-            <a href="{{ '/decisions/' ~ item.id if item else '/decisions' }}" class="btn btn-secondary">Cancel</a>
+            <a href="{{ '/tasks/' ~ prefill_task_id ~ '?tab=decisions' if prefill_task_id is defined and prefill_task_id else ('/decisions/' ~ item.id if item else '/decisions') }}" class="btn btn-secondary">Cancel</a>
         </div>
     </form>
 </div>
diff --git a/templates/eisenhower.html b/templates/eisenhower.html
index 8c0b195..fd27dad 100644
--- a/templates/eisenhower.html
+++ b/templates/eisenhower.html
@@ -5,6 +5,34 @@
     <span class="text-muted">{{ total }} open tasks classified by priority &amp; urgency</span>
 </div>
 
+<!-- Filters -->
+<form class="filters-bar" method="get" action="/eisenhower" id="eis-filters">
+    <select name="domain_id" class="filter-select" id="eis-domain" onchange="this.form.submit()">
+        <option value="">All Domains</option>
+        {% for d in domains %}
+        <option value="{{ d.id }}" {{ 'selected' if current_domain_id == d.id|string }}>{{ d.name }}</option>
+        {% endfor %}
+    </select>
+    <select name="project_id" class="filter-select" id="eis-project" onchange="this.form.submit()">
+        <option value="">All Projects</option>
+        {% for p in projects %}
+        <option value="{{ p.id }}" {{ 'selected' if current_project_id == p.id|string }}>{{ p.name }}</option>
+        {% endfor %}
+    </select>
+    <select name="status" class="filter-select" onchange="this.form.submit()">
+        <option value="">All Statuses</option>
+        <option value="open" {{ 'selected' if current_status == 'open' }}>Open</option>
+        <option value="in_progress" {{ 'selected' if current_status == 'in_progress' }}>In Progress</option>
+        <option value="blocked" {{ 'selected' if current_status == 'blocked' }}>Blocked</option>
+    </select>
+    <select name="context" class="filter-select" onchange="this.form.submit()">
+        <option value="">All Contexts</option>
+        {% for ct in context_types %}
+        <option value="{{ ct.value }}" {{ 'selected' if current_context == ct.value }}>{{ ct.label }}</option>
+        {% endfor %}
+    </select>
+</form>
+
 <div class="eisenhower-grid">
     <!-- Axis labels -->
     <div class="eisenhower-y-label">
@@ -126,4 +154,31 @@
     <div class="eisenhower-x-label">Not Urgent</div>
 </div>
 
+<script>
+(function() {
+    var domainSel = document.getElementById('eis-domain');
+    var projectSel = document.getElementById('eis-project');
+    var currentProjectId = '{{ current_project_id }}';
+    var form = document.getElementById('eis-filters');
+
+    domainSel.addEventListener('change', function() {
+        var did = domainSel.value;
+        if (!did) { form.submit(); return; }
+        fetch('/projects/api/by-domain?domain_id=' + encodeURIComponent(did))
+            .then(function(r) { return r.json(); })
+            .then(function(projects) {
+                projectSel.innerHTML = '<option value="">All Projects</option>';
+                projects.forEach(function(p) {
+                    var opt = document.createElement('option');
+                    opt.value = p.id;
+                    opt.textContent = p.name;
+                    if (p.id === currentProjectId) opt.selected = true;
+                    projectSel.appendChild(opt);
+                });
+                form.submit();
+            })
+            .catch(function() { form.submit(); });
+    });
+})();
+</script>
 {% endblock %}
diff --git a/templates/focus.html b/templates/focus.html
index 20fe9af..5e29cbc 100644
--- a/templates/focus.html
+++ b/templates/focus.html
@@ -37,9 +37,31 @@
 {% endif %}
 
 <!-- Add task to focus -->
-{% if available_tasks %}
 <div class="card mt-4">
     <div class="card-header"><h2 class="card-title">Add to Focus</h2></div>
+
+    <form class="filters-bar" method="get" action="/focus" id="focus-filters" style="padding: 8px 12px; border-bottom: 1px solid var(--border);">
+        <input type="hidden" name="focus_date" value="{{ focus_date }}">
+        <select name="domain_id" class="filter-select" id="focus-domain" onchange="this.form.submit()">
+            <option value="">All Domains</option>
+            {% for d in domains %}
+            <option value="{{ d.id }}" {{ 'selected' if current_domain_id == d.id|string }}>{{ d.name }}</option>
+            {% endfor %}
+        </select>
+        <select name="area_id" class="filter-select" onchange="this.form.submit()">
+            <option value="">All Areas</option>
+            {% for a in areas %}
+            <option value="{{ a.id }}" {{ 'selected' if current_area_id == a.id|string }}>{{ a.name }}</option>
+            {% endfor %}
+        </select>
+        <select name="project_id" class="filter-select" id="focus-project" onchange="this.form.submit()">
+            <option value="">All Projects</option>
+            {% for p in projects %}
+            <option value="{{ p.id }}" {{ 'selected' if current_project_id == p.id|string }}>{{ p.name }}</option>
+            {% endfor %}
+        </select>
+    </form>
+
     {% for t in available_tasks[:15] %}
     <div class="list-row">
         <span class="priority-dot priority-{{ t.priority }}"></span>
@@ -52,7 +74,36 @@
             <button class="btn btn-ghost btn-xs" style="color:var(--green)">+ Focus</button>
         </form>
     </div>
+    {% else %}
+    <div style="padding: 16px; color: var(--muted); font-size: 0.85rem;">No available tasks matching filters</div>
     {% endfor %}
 </div>
-{% endif %}
+
+<script>
+(function() {
+    var domainSel = document.getElementById('focus-domain');
+    var projectSel = document.getElementById('focus-project');
+    var currentProjectId = '{{ current_project_id }}';
+    var form = document.getElementById('focus-filters');
+
+    domainSel.addEventListener('change', function() {
+        var did = domainSel.value;
+        if (!did) { form.submit(); return; }
+        fetch('/projects/api/by-domain?domain_id=' + encodeURIComponent(did))
+            .then(function(r) { return r.json(); })
+            .then(function(projects) {
+                projectSel.innerHTML = '<option value="">All Projects</option>';
+                projects.forEach(function(p) {
+                    var opt = document.createElement('option');
+                    opt.value = p.id;
+                    opt.textContent = p.name;
+                    if (p.id === currentProjectId) opt.selected = true;
+                    projectSel.appendChild(opt);
+                });
+                form.submit();
+            })
+            .catch(function() { form.submit(); });
+    });
+})();
+</script>
 {% endblock %}
diff --git a/templates/history.html b/templates/history.html
new file mode 100644
index 0000000..00e95bf
--- /dev/null
+++ b/templates/history.html
@@ -0,0 +1,32 @@
+{% extends "base.html" %}
+{% block content %}
+<div class="page-header">
+    <h1 class="page-title">Change History<span class="page-count">{{ items|length }}</span></h1>
+</div>
+
+<form class="filters-bar" method="get" action="/history">
+    <select name="entity_type" class="filter-select" onchange="this.form.submit()">
+        <option value="">All Types</option>
+        {% for t in type_options %}
+        <option value="{{ t.value }}" {{ 'selected' if current_type == t.value }}>{{ t.label }}</option>
+        {% endfor %}
+    </select>
+</form>
+
+{% if items %}
+<div class="card mt-3">
+    {% for item in items %}
+    <div class="list-row">
+        <span class="row-tag" style="min-width: 70px; text-align: center;">{{ item.type_label }}</span>
+        <span class="row-title"><a href="{{ item.url }}">{{ item.label }}</a></span>
+        <span class="status-badge {{ 'status-active' if item.action == 'created' else 'status-open' }}">{{ item.action }}</span>
+        <span class="row-meta">{{ item.updated_at.strftime('%Y-%m-%d %H:%M') if item.updated_at else '' }}</span>
+    </div>
+    {% endfor %}
+</div>
+{% else %}
+<div class="empty-state mt-3">
+    <div class="empty-state-text">No recent changes</div>
+</div>
+{% endif %}
+{% endblock %}
diff --git a/templates/list_detail.html b/templates/list_detail.html
index 712a3bb..22ba62c 100644
--- a/templates/list_detail.html
+++ b/templates/list_detail.html
@@ -95,4 +95,38 @@
     <div class="empty-state-text">No items yet. Add one above.</div>
 </div>
 {% endif %}
+
+<!-- Contacts -->
+<div class="card mt-4">
+    <div class="card-header">
+        <h3 class="card-title">Contacts<span class="page-count">{{ contacts|length }}</span></h3>
+    </div>
+    <form action="/lists/{{ item.id }}/contacts/add" method="post" class="flex gap-2 items-end" style="padding: 12px; border-bottom: 1px solid var(--border);">
+        <div class="form-group" style="flex:1; margin:0;">
+            <select name="contact_id" class="form-select" required>
+                <option value="">Select contact...</option>
+                {% for c in all_contacts %}
+                <option value="{{ c.id }}">{{ c.first_name }} {{ c.last_name or '' }}</option>
+                {% endfor %}
+            </select>
+        </div>
+        <div class="form-group" style="flex:1; margin:0;">
+            <input type="text" name="role" class="form-input" placeholder="Role (optional)">
+        </div>
+        <button type="submit" class="btn btn-primary btn-sm">Add</button>
+    </form>
+    {% for c in contacts %}
+    <div class="list-row">
+        <span class="row-title"><a href="/contacts/{{ c.id }}">{{ c.first_name }} {{ c.last_name or '' }}</a></span>
+        {% if c.role %}<span class="row-tag">{{ c.role }}</span>{% endif %}
+        <div class="row-actions">
+            <form action="/lists/{{ item.id }}/contacts/{{ c.id }}/remove" method="post" style="display:inline">
+                <button class="btn btn-ghost btn-xs" title="Remove">Remove</button>
+            </form>
+        </div>
+    </div>
+    {% else %}
+    <div style="padding: 12px; color: var(--muted); font-size: 0.85rem;">No contacts linked</div>
+    {% endfor %}
+</div>
 {% endblock %}
diff --git a/templates/list_form.html b/templates/list_form.html
index b251ce5..4eb4ccd 100644
--- a/templates/list_form.html
+++ b/templates/list_form.html
@@ -73,9 +73,11 @@
             </div>
         </div>
 
+        {% if prefill_task_id is defined and prefill_task_id %}<input type="hidden" name="task_id" value="{{ prefill_task_id }}">{% endif %}
+        {% if prefill_meeting_id is defined and prefill_meeting_id %}<input type="hidden" name="meeting_id" value="{{ prefill_meeting_id }}">{% endif %}
         <div class="form-actions">
             <button type="submit" class="btn btn-primary">{{ 'Save Changes' if item else 'Create List' }}</button>
-            <a href="{{ '/lists/' ~ item.id if item else '/lists' }}" class="btn btn-secondary">Cancel</a>
+            <a href="{{ '/tasks/' ~ prefill_task_id ~ '?tab=lists' if prefill_task_id is defined and prefill_task_id else ('/lists/' ~ item.id if item else '/lists') }}" class="btn btn-secondary">Cancel</a>
         </div>
     </form>
 </div>
diff --git a/templates/lists.html b/templates/lists.html
index 31c7d7e..d36e057 100644
--- a/templates/lists.html
+++ b/templates/lists.html
@@ -6,14 +6,14 @@
 </div>
 
 <!-- Filters -->
-<form class="filters-bar" method="get" action="/lists">
-    <select name="domain_id" class="filter-select" onchange="this.form.submit()">
+<form class="filters-bar" method="get" action="/lists" id="list-filters">
+    <select name="domain_id" class="filter-select" id="domain-filter" onchange="this.form.submit()">
         <option value="">All Domains</option>
         {% for d in domains %}
         <option value="{{ d.id }}" {{ 'selected' if current_domain_id == d.id|string }}>{{ d.name }}</option>
         {% endfor %}
     </select>
-    <select name="project_id" class="filter-select" onchange="this.form.submit()">
+    <select name="project_id" class="filter-select" id="project-filter" onchange="this.form.submit()">
         <option value="">All Projects</option>
         {% for p in projects %}
         <option value="{{ p.id }}" {{ 'selected' if current_project_id == p.id|string }}>{{ p.name }}</option>
@@ -57,4 +57,38 @@
     <a href="/lists/create" class="btn btn-primary">Create First List</a>
 </div>
 {% endif %}
+
+<script>
+(function() {
+    var domainSel = document.getElementById('domain-filter');
+    var projectSel = document.getElementById('project-filter');
+    var currentProjectId = '{{ current_project_id }}';
+
+    domainSel.addEventListener('change', function() {
+        var did = domainSel.value;
+        if (!did) {
+            // No domain filter - submit immediately, server returns all projects
+            document.getElementById('list-filters').submit();
+            return;
+        }
+        // Fetch projects for this domain
+        fetch('/projects/api/by-domain?domain_id=' + encodeURIComponent(did))
+            .then(function(r) { return r.json(); })
+            .then(function(projects) {
+                projectSel.innerHTML = '<option value="">All Projects</option>';
+                projects.forEach(function(p) {
+                    var opt = document.createElement('option');
+                    opt.value = p.id;
+                    opt.textContent = p.name;
+                    if (p.id === currentProjectId) opt.selected = true;
+                    projectSel.appendChild(opt);
+                });
+                document.getElementById('list-filters').submit();
+            })
+            .catch(function() {
+                document.getElementById('list-filters').submit();
+            });
+    });
+})();
+</script>
 {% endblock %}
diff --git a/templates/meeting_detail.html b/templates/meeting_detail.html
index 1a13da6..891a021 100644
--- a/templates/meeting_detail.html
+++ b/templates/meeting_detail.html
@@ -28,9 +28,21 @@
     {% endif %}
 </div>
 
+<!-- Tabs -->
+<div class="tab-strip">
+    <a href="/meetings/{{ item.id }}?tab=overview" class="tab-item {{ 'active' if tab == 'overview' }}">Overview</a>
+    <a href="/meetings/{{ item.id }}?tab=notes" class="tab-item {{ 'active' if tab == 'notes' }}">Notes{% if counts.notes %} ({{ counts.notes }}){% endif %}</a>
+    <a href="/meetings/{{ item.id }}?tab=weblinks" class="tab-item {{ 'active' if tab == 'weblinks' }}">Weblinks{% if counts.weblinks %} ({{ counts.weblinks }}){% endif %}</a>
+    <a href="/meetings/{{ item.id }}?tab=files" class="tab-item {{ 'active' if tab == 'files' }}">Files{% if counts.files %} ({{ counts.files }}){% endif %}</a>
+    <a href="/meetings/{{ item.id }}?tab=lists" class="tab-item {{ 'active' if tab == 'lists' }}">Lists{% if counts.lists %} ({{ counts.lists }}){% endif %}</a>
+    <a href="/meetings/{{ item.id }}?tab=processes" class="tab-item {{ 'active' if tab == 'processes' }}">Processes</a>
+    <a href="/meetings/{{ item.id }}?tab=contacts" class="tab-item {{ 'active' if tab == 'contacts' }}">Contacts{% if counts.contacts %} ({{ counts.contacts }}){% endif %}</a>
+</div>
+
+{% if tab == 'overview' %}
 <!-- Agenda -->
 {% if item.agenda %}
-<div class="card mt-3">
+<div class="card mb-4">
     <div class="card-header"><h3 class="card-title">Agenda</h3></div>
     <div class="detail-body" style="padding: 12px 16px;">{{ item.agenda }}</div>
 </div>
@@ -38,7 +50,7 @@
 
 <!-- Meeting Notes -->
 {% if item.notes_body %}
-<div class="card mt-3">
+<div class="card mb-4">
     <div class="card-header"><h3 class="card-title">Notes</h3></div>
     <div class="detail-body" style="padding: 12px 16px;">{{ item.notes_body }}</div>
 </div>
@@ -46,19 +58,17 @@
 
 <!-- Transcript -->
 {% if item.transcript %}
-<div class="card mt-3">
+<div class="card mb-4">
     <div class="card-header"><h3 class="card-title">Transcript</h3></div>
     <div class="detail-body" style="padding: 12px 16px; font-family: var(--font-mono); font-size: 0.82rem; white-space: pre-wrap;">{{ item.transcript }}</div>
 </div>
 {% endif %}
 
 <!-- Action Items -->
-<div class="card mt-3">
+<div class="card mb-4">
     <div class="card-header">
         <h3 class="card-title">Action Items<span class="page-count">{{ action_items|length }}</span></h3>
     </div>
-
-    <!-- Quick add action item -->
     <form class="quick-add" action="/meetings/{{ item.id }}/action-item" method="post" style="border-bottom: 1px solid var(--border);">
         <input type="text" name="title" placeholder="Add action item..." required>
         <select name="domain_id" class="filter-select" required style="width: auto;">
@@ -68,7 +78,6 @@
         </select>
         <button type="submit" class="btn btn-primary btn-sm">Add</button>
     </form>
-
     {% for task in action_items %}
     <div class="list-row {{ 'completed' if task.status == 'done' }}">
         <div class="row-check">
@@ -83,16 +92,14 @@
         {% if task.project_name %}<span class="row-tag">{{ task.project_name }}</span>{% endif %}
         <span class="status-badge status-{{ task.status }}">{{ task.status|replace('_', ' ') }}</span>
     </div>
-    {% endfor %}
-
-    {% if not action_items %}
+    {% else %}
     <div style="padding: 16px; color: var(--muted); font-size: 0.85rem;">No action items yet</div>
-    {% endif %}
+    {% endfor %}
 </div>
 
 <!-- Decisions -->
 {% if decisions %}
-<div class="card mt-3">
+<div class="card">
     <div class="card-header"><h3 class="card-title">Decisions<span class="page-count">{{ decisions|length }}</span></h3></div>
     {% for dec in decisions %}
     <div class="list-row">
@@ -104,16 +111,89 @@
 </div>
 {% endif %}
 
-<!-- Attendees -->
-{% if attendees %}
-<div class="card mt-3">
-    <div class="card-header"><h3 class="card-title">Attendees<span class="page-count">{{ attendees|length }}</span></h3></div>
-    {% for att in attendees %}
-    <div class="list-row">
-        <span class="row-title"><a href="/contacts/{{ att.id }}">{{ att.first_name }} {{ att.last_name or '' }}</a></span>
-        {% if att.role %}<span class="row-tag">{{ att.role }}</span>{% endif %}
-    </div>
-    {% endfor %}
+{% elif tab == 'notes' %}
+<a href="/notes/create?meeting_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ New Note</a>
+{% for n in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/notes/{{ n.id }}">{{ n.title }}</a></span>
+    <span class="row-meta">{{ n.updated_at.strftime('%Y-%m-%d') if n.updated_at else '' }}</span>
 </div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No notes linked to this meeting</div></div>
+{% endfor %}
+
+{% elif tab == 'weblinks' %}
+<a href="/weblinks/create?meeting_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ New Weblink</a>
+{% for w in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="{{ w.url }}" target="_blank">{{ w.label }}</a></span>
+    <span class="row-meta">{{ w.url[:50] }}{% if w.url|length > 50 %}...{% endif %}</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No weblinks linked to this meeting</div></div>
+{% endfor %}
+
+{% elif tab == 'files' %}
+<a href="/files/upload?context_type=meeting&context_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ Upload File</a>
+{% for f in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/files/{{ f.id }}">{{ f.original_filename }}</a></span>
+    <span class="row-meta">{{ f.created_at.strftime('%Y-%m-%d') if f.created_at else '' }}</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No files attached to this meeting</div></div>
+{% endfor %}
+
+{% elif tab == 'lists' %}
+<a href="/lists/create?meeting_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ New List</a>
+{% for l in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/lists/{{ l.id }}">{{ l.name }}</a></span>
+    <span class="row-meta">{{ l.item_count }} items</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No lists linked to this meeting</div></div>
+{% endfor %}
+
+{% elif tab == 'processes' %}
+<div class="empty-state"><div class="empty-state-text">Process management coming soon</div></div>
+
+{% elif tab == 'contacts' %}
+<div class="card mb-4">
+    <form action="/meetings/{{ item.id }}/contacts/add" method="post" class="flex gap-2 items-end" style="padding: 12px;">
+        <div class="form-group" style="flex:1; margin:0;">
+            <label class="form-label">Contact</label>
+            <select name="contact_id" class="form-select" required>
+                <option value="">Select contact...</option>
+                {% for c in all_contacts %}
+                <option value="{{ c.id }}">{{ c.first_name }} {{ c.last_name or '' }}</option>
+                {% endfor %}
+            </select>
+        </div>
+        <div class="form-group" style="flex:1; margin:0;">
+            <label class="form-label">Role</label>
+            <select name="role" class="form-select">
+                <option value="attendee">Attendee</option>
+                <option value="organizer">Organizer</option>
+                <option value="optional">Optional</option>
+            </select>
+        </div>
+        <button type="submit" class="btn btn-primary btn-sm">Add</button>
+    </form>
+</div>
+{% for c in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/contacts/{{ c.id }}">{{ c.first_name }} {{ c.last_name or '' }}</a></span>
+    {% if c.role %}<span class="row-tag">{{ c.role }}</span>{% endif %}
+    <span class="row-meta">{{ c.linked_at.strftime('%Y-%m-%d') if c.linked_at else '' }}</span>
+    <div class="row-actions">
+        <form action="/meetings/{{ item.id }}/contacts/{{ c.id }}/remove" method="post" style="display:inline">
+            <button class="btn btn-ghost btn-xs" title="Remove">Remove</button>
+        </form>
+    </div>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No contacts linked to this meeting</div></div>
+{% endfor %}
 {% endif %}
 {% endblock %}
diff --git a/templates/note_form.html b/templates/note_form.html
index c9a6a14..750896d 100644
--- a/templates/note_form.html
+++ b/templates/note_form.html
@@ -13,6 +13,8 @@
     <div class="form-group full-width"><label class="form-label">Content</label><textarea name="body" class="form-textarea" rows="15" style="font-family:var(--font-mono);font-size:0.88rem">{{ item.body if item and item.body else '' }}</textarea></div>
     <div class="form-group full-width"><label class="form-label">Tags</label><input type="text" name="tags" class="form-input" value="{{ item.tags|join(', ') if item and item.tags else '' }}"></div>
     <input type="hidden" name="content_format" value="rich">
+    {% if prefill_task_id is defined and prefill_task_id %}<input type="hidden" name="task_id" value="{{ prefill_task_id }}">{% endif %}
+    {% if prefill_meeting_id is defined and prefill_meeting_id %}<input type="hidden" name="meeting_id" value="{{ prefill_meeting_id }}">{% endif %}
     <div class="form-actions"><button type="submit" class="btn btn-primary">{{ 'Save' if item else 'Create' }}</button><a href="{{ '/notes/' ~ item.id if item else '/notes' }}" class="btn btn-secondary">Cancel</a></div>
 </div>
 </form></div>
diff --git a/templates/project_detail.html b/templates/project_detail.html
index aec3766..695c54c 100644
--- a/templates/project_detail.html
+++ b/templates/project_detail.html
@@ -34,8 +34,13 @@
 <!-- Tabs -->
 <div class="tab-strip">
     <a href="/projects/{{ item.id }}?tab=tasks" class="tab-item {{ 'active' if tab == 'tasks' }}">Tasks ({{ tasks|length }})</a>
-    <a href="/projects/{{ item.id }}?tab=notes" class="tab-item {{ 'active' if tab == 'notes' }}">Notes ({{ notes|length }})</a>
-    <a href="/projects/{{ item.id }}?tab=links" class="tab-item {{ 'active' if tab == 'links' }}">Links ({{ links|length }})</a>
+    <a href="/projects/{{ item.id }}?tab=notes" class="tab-item {{ 'active' if tab == 'notes' }}">Notes{% if counts.notes %} ({{ counts.notes }}){% endif %}</a>
+    <a href="/projects/{{ item.id }}?tab=links" class="tab-item {{ 'active' if tab == 'links' }}">Links{% if counts.links %} ({{ counts.links }}){% endif %}</a>
+    <a href="/projects/{{ item.id }}?tab=files" class="tab-item {{ 'active' if tab == 'files' }}">Files{% if counts.files %} ({{ counts.files }}){% endif %}</a>
+    <a href="/projects/{{ item.id }}?tab=lists" class="tab-item {{ 'active' if tab == 'lists' }}">Lists{% if counts.lists %} ({{ counts.lists }}){% endif %}</a>
+    <a href="/projects/{{ item.id }}?tab=decisions" class="tab-item {{ 'active' if tab == 'decisions' }}">Decisions{% if counts.decisions %} ({{ counts.decisions }}){% endif %}</a>
+    <a href="/projects/{{ item.id }}?tab=processes" class="tab-item {{ 'active' if tab == 'processes' }}">Processes</a>
+    <a href="/projects/{{ item.id }}?tab=contacts" class="tab-item {{ 'active' if tab == 'contacts' }}">Contacts{% if counts.contacts %} ({{ counts.contacts }}){% endif %}</a>
 </div>
 
 {% if tab == 'tasks' %}
@@ -91,5 +96,75 @@
 {% else %}
 <div class="empty-state"><div class="empty-state-text">No links yet</div></div>
 {% endfor %}
+
+{% elif tab == 'files' %}
+<a href="/files/upload?context_type=project&context_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ Upload File</a>
+{% for f in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/files/{{ f.id }}">{{ f.original_filename }}</a></span>
+    <span class="row-meta">{{ f.created_at.strftime('%Y-%m-%d') if f.created_at else '' }}</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No files attached to this project</div></div>
+{% endfor %}
+
+{% elif tab == 'lists' %}
+<a href="/lists/create?domain_id={{ item.domain_id }}&project_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ New List</a>
+{% for l in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/lists/{{ l.id }}">{{ l.name }}</a></span>
+    <span class="row-meta">{{ l.item_count }} items</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No lists linked to this project</div></div>
+{% endfor %}
+
+{% elif tab == 'decisions' %}
+<a href="/decisions/create?project_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ New Decision</a>
+{% for d in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/decisions/{{ d.id }}">{{ d.title }}</a></span>
+    <span class="status-badge status-{{ d.status }}">{{ d.status }}</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No decisions linked to this project</div></div>
+{% endfor %}
+
+{% elif tab == 'processes' %}
+<div class="empty-state"><div class="empty-state-text">Process management coming soon</div></div>
+
+{% elif tab == 'contacts' %}
+<div class="card mb-4">
+    <form action="/projects/{{ item.id }}/contacts/add" method="post" class="flex gap-2 items-end" style="padding: 12px;">
+        <div class="form-group" style="flex:1; margin:0;">
+            <label class="form-label">Contact</label>
+            <select name="contact_id" class="form-select" required>
+                <option value="">Select contact...</option>
+                {% for c in all_contacts %}
+                <option value="{{ c.id }}">{{ c.first_name }} {{ c.last_name or '' }}</option>
+                {% endfor %}
+            </select>
+        </div>
+        <div class="form-group" style="flex:1; margin:0;">
+            <label class="form-label">Role</label>
+            <input type="text" name="role" class="form-input" placeholder="e.g. lead, contributor...">
+        </div>
+        <button type="submit" class="btn btn-primary btn-sm">Add</button>
+    </form>
+</div>
+{% for c in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/contacts/{{ c.id }}">{{ c.first_name }} {{ c.last_name or '' }}</a></span>
+    {% if c.role %}<span class="row-tag">{{ c.role }}</span>{% endif %}
+    <span class="row-meta">{{ c.linked_at.strftime('%Y-%m-%d') if c.linked_at else '' }}</span>
+    <div class="row-actions">
+        <form action="/projects/{{ item.id }}/contacts/{{ c.id }}/remove" method="post" style="display:inline">
+            <button class="btn btn-ghost btn-xs" title="Remove">Remove</button>
+        </form>
+    </div>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No contacts linked to this project</div></div>
+{% endfor %}
 {% endif %}
 {% endblock %}
diff --git a/templates/task_detail.html b/templates/task_detail.html
index a1140b3..1803a6a 100644
--- a/templates/task_detail.html
+++ b/templates/task_detail.html
@@ -54,6 +54,19 @@
 </div>
 {% endif %}
 
+<!-- Tabs -->
+<div class="tab-strip">
+    <a href="/tasks/{{ item.id }}?tab=overview" class="tab-item {{ 'active' if tab == 'overview' }}">Overview{% if counts.overview %} ({{ counts.overview }}){% endif %}</a>
+    <a href="/tasks/{{ item.id }}?tab=notes" class="tab-item {{ 'active' if tab == 'notes' }}">Notes{% if counts.notes %} ({{ counts.notes }}){% endif %}</a>
+    <a href="/tasks/{{ item.id }}?tab=weblinks" class="tab-item {{ 'active' if tab == 'weblinks' }}">Weblinks{% if counts.weblinks %} ({{ counts.weblinks }}){% endif %}</a>
+    <a href="/tasks/{{ item.id }}?tab=files" class="tab-item {{ 'active' if tab == 'files' }}">Files{% if counts.files %} ({{ counts.files }}){% endif %}</a>
+    <a href="/tasks/{{ item.id }}?tab=lists" class="tab-item {{ 'active' if tab == 'lists' }}">Lists{% if counts.lists %} ({{ counts.lists }}){% endif %}</a>
+    <a href="/tasks/{{ item.id }}?tab=decisions" class="tab-item {{ 'active' if tab == 'decisions' }}">Decisions{% if counts.decisions %} ({{ counts.decisions }}){% endif %}</a>
+    <a href="/tasks/{{ item.id }}?tab=processes" class="tab-item {{ 'active' if tab == 'processes' }}">Processes</a>
+    <a href="/tasks/{{ item.id }}?tab=contacts" class="tab-item {{ 'active' if tab == 'contacts' }}">Contacts{% if counts.contacts %} ({{ counts.contacts }}){% endif %}</a>
+</div>
+
+{% if tab == 'overview' %}
 {% if parent %}
 <div class="card mb-4">
     <div class="card-title text-sm">Parent Task</div>
@@ -61,7 +74,6 @@
 </div>
 {% endif %}
 
-<!-- Subtasks -->
 <div class="card">
     <div class="card-header">
         <h2 class="card-title">Subtasks<span class="page-count">{{ subtasks|length }}</span></h2>
@@ -84,6 +96,99 @@
     {% endfor %}
 </div>
 
+{% elif tab == 'notes' %}
+<a href="/notes/create?task_id={{ item.id }}&domain_id={{ item.domain_id }}" class="btn btn-ghost btn-sm mb-3">+ New Note</a>
+{% for n in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/notes/{{ n.id }}">{{ n.title }}</a></span>
+    <span class="row-meta">{{ n.updated_at.strftime('%Y-%m-%d') if n.updated_at else '' }}</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No notes linked to this task</div></div>
+{% endfor %}
+
+{% elif tab == 'weblinks' %}
+<a href="/weblinks/create?task_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ New Weblink</a>
+{% for w in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="{{ w.url }}" target="_blank">{{ w.label }}</a></span>
+    <span class="row-meta">{{ w.url[:50] }}{% if w.url|length > 50 %}...{% endif %}</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No weblinks linked to this task</div></div>
+{% endfor %}
+
+{% elif tab == 'files' %}
+<a href="/files/upload?context_type=task&context_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ Upload File</a>
+{% for f in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/files/{{ f.id }}">{{ f.original_filename }}</a></span>
+    <span class="row-meta">{{ f.created_at.strftime('%Y-%m-%d') if f.created_at else '' }}</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No files attached to this task</div></div>
+{% endfor %}
+
+{% elif tab == 'lists' %}
+<a href="/lists/create?task_id={{ item.id }}&domain_id={{ item.domain_id }}" class="btn btn-ghost btn-sm mb-3">+ New List</a>
+{% for l in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/lists/{{ l.id }}">{{ l.name }}</a></span>
+    <span class="row-meta">{{ l.item_count }} items</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No lists linked to this task</div></div>
+{% endfor %}
+
+{% elif tab == 'decisions' %}
+<a href="/decisions/create?task_id={{ item.id }}" class="btn btn-ghost btn-sm mb-3">+ New Decision</a>
+{% for d in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/decisions/{{ d.id }}">{{ d.title }}</a></span>
+    <span class="status-badge status-{{ d.status }}">{{ d.status }}</span>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No decisions linked to this task</div></div>
+{% endfor %}
+
+{% elif tab == 'processes' %}
+<div class="empty-state"><div class="empty-state-text">Process management coming soon</div></div>
+
+{% elif tab == 'contacts' %}
+<div class="card mb-4">
+    <form action="/tasks/{{ item.id }}/contacts/add" method="post" class="flex gap-2 items-end" style="padding: 12px;">
+        <div class="form-group" style="flex:1; margin:0;">
+            <label class="form-label">Contact</label>
+            <select name="contact_id" class="form-select" required>
+                <option value="">Select contact...</option>
+                {% for c in all_contacts %}
+                <option value="{{ c.id }}">{{ c.first_name }} {{ c.last_name or '' }}</option>
+                {% endfor %}
+            </select>
+        </div>
+        <div class="form-group" style="flex:1; margin:0;">
+            <label class="form-label">Role</label>
+            <input type="text" name="role" class="form-input" placeholder="e.g. reviewer, assignee...">
+        </div>
+        <button type="submit" class="btn btn-primary btn-sm">Add</button>
+    </form>
+</div>
+{% for c in tab_data %}
+<div class="list-row">
+    <span class="row-title"><a href="/contacts/{{ c.id }}">{{ c.first_name }} {{ c.last_name or '' }}</a></span>
+    {% if c.role %}<span class="row-tag">{{ c.role }}</span>{% endif %}
+    <span class="row-meta">{{ c.linked_at.strftime('%Y-%m-%d') if c.linked_at else '' }}</span>
+    <div class="row-actions">
+        <form action="/tasks/{{ item.id }}/contacts/{{ c.id }}/remove" method="post" style="display:inline">
+            <button class="btn btn-ghost btn-xs" title="Remove">Remove</button>
+        </form>
+    </div>
+</div>
+{% else %}
+<div class="empty-state"><div class="empty-state-text">No contacts linked to this task</div></div>
+{% endfor %}
+{% endif %}
+
 <div class="text-xs text-muted mt-4">
     Created {{ item.created_at.strftime('%Y-%m-%d %H:%M') if item.created_at else '' }}
     {% if item.completed_at %} | Completed {{ item.completed_at.strftime('%Y-%m-%d %H:%M') }}{% endif %}
diff --git a/templates/weblink_form.html b/templates/weblink_form.html
index 238ee55..278ad70 100644
--- a/templates/weblink_form.html
+++ b/templates/weblink_form.html
@@ -41,9 +41,11 @@
             </div>
         </div>
 
+        {% if prefill_task_id is defined and prefill_task_id %}<input type="hidden" name="task_id" value="{{ prefill_task_id }}">{% endif %}
+        {% if prefill_meeting_id is defined and prefill_meeting_id %}<input type="hidden" name="meeting_id" value="{{ prefill_meeting_id }}">{% endif %}
         <div class="form-actions">
             <button type="submit" class="btn btn-primary">{{ 'Save Changes' if item else 'Add Weblink' }}</button>
-            <a href="/weblinks" class="btn btn-secondary">Cancel</a>
+            <a href="{{ '/tasks/' ~ prefill_task_id ~ '?tab=weblinks' if prefill_task_id is defined and prefill_task_id else '/weblinks' }}" class="btn btn-secondary">Cancel</a>
         </div>
     </form>
 </div>
diff --git a/tests/conftest.py b/tests/conftest.py
index be4bb7a..d1f1a66 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -201,6 +201,24 @@ def all_seeds(sync_conn):
             ON CONFLICT (id) DO NOTHING
         """, (d["focus"], d["task"]))
 
+        # Junction table seeds for contact tabs
+        cur.execute("""
+            INSERT INTO contact_tasks (contact_id, task_id, role)
+            VALUES (%s, %s, 'assignee') ON CONFLICT DO NOTHING
+        """, (d["contact"], d["task"]))
+        cur.execute("""
+            INSERT INTO contact_projects (contact_id, project_id, role)
+            VALUES (%s, %s, 'stakeholder') ON CONFLICT DO NOTHING
+        """, (d["contact"], d["project"]))
+        cur.execute("""
+            INSERT INTO contact_meetings (contact_id, meeting_id, role)
+            VALUES (%s, %s, 'attendee') ON CONFLICT DO NOTHING
+        """, (d["contact"], d["meeting"]))
+        cur.execute("""
+            INSERT INTO contact_lists (contact_id, list_id, role)
+            VALUES (%s, %s, 'contributor') ON CONFLICT DO NOTHING
+        """, (d["contact"], d["list"]))
+
         # Process
         cur.execute("""
             INSERT INTO processes (id, name, process_type, status, category, is_deleted, created_at, updated_at)
@@ -253,6 +271,11 @@ def all_seeds(sync_conn):
 
     # Cleanup: delete all seed data (reverse dependency order)
     try:
+        # Junction tables first
+        cur.execute("DELETE FROM contact_tasks WHERE task_id = %s", (d["task"],))
+        cur.execute("DELETE FROM contact_projects WHERE project_id = %s", (d["project"],))
+        cur.execute("DELETE FROM contact_meetings WHERE meeting_id = %s", (d["meeting"],))
+        cur.execute("DELETE FROM contact_lists WHERE list_id = %s", (d["list"],))
         cur.execute("DELETE FROM files WHERE id = %s", (d["file"],))
         if os.path.exists(dummy_file_path):
             os.remove(dummy_file_path)
diff --git a/tests/registry.py b/tests/registry.py
index 7af503a..8908182 100644
--- a/tests/registry.py
+++ b/tests/registry.py
@@ -46,6 +46,9 @@ PREFIX_TO_SEED = {
     "/time-budgets": "time_budget",
     "/files": "file",
     "/admin/trash": None,
+    "/history": None,
+    "/eisenhower": None,
+    "/calendar": None,
 }
 
 def resolve_path(path_template, seeds):
diff --git a/tests/test_business_logic.py b/tests/test_business_logic.py
index 851a9ce..543228b 100644
--- a/tests/test_business_logic.py
+++ b/tests/test_business_logic.py
@@ -1893,3 +1893,743 @@ async def _create_list_item(db: AsyncSession, list_id: str, content: str) -> str
     )
     await db.commit()
     return _id
+
+
+# ===========================================================================
+# Task Detail Tabs
+# ===========================================================================
+class TestTaskDetailTabs:
+    """Test tabbed task detail page - all tabs load, correct content per tab."""
+
+    @pytest.mark.asyncio
+    async def test_overview_tab_default(self, client: AsyncClient, seed_task: dict):
+        """Default tab is overview."""
+        r = await client.get(f"/tasks/{seed_task['id']}")
+        assert r.status_code == 200
+        # The active tab has class "tab-item active"
+        assert 'tab-item active' in r.text
+
+    @pytest.mark.asyncio
+    async def test_all_tabs_return_200(self, client: AsyncClient, seed_task: dict):
+        """Every tab on task detail returns 200."""
+        for tab in ("overview", "notes", "weblinks", "files", "lists", "decisions", "processes", "contacts"):
+            r = await client.get(f"/tasks/{seed_task['id']}?tab={tab}")
+            assert r.status_code == 200, f"Tab '{tab}' returned {r.status_code}"
+
+    @pytest.mark.asyncio
+    async def test_contacts_tab_shows_seed_contact(
+        self, client: AsyncClient, seed_task: dict, seed_contact: dict,
+    ):
+        """Contacts tab shows the linked contact from seed data."""
+        r = await client.get(f"/tasks/{seed_task['id']}?tab=contacts")
+        assert r.status_code == 200
+        assert seed_contact["first_name"] in r.text
+
+    @pytest.mark.asyncio
+    async def test_notes_tab_shows_linked_note(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_task: dict, seed_domain: dict,
+    ):
+        """A note linked to a task appears on the notes tab."""
+        tag = _uid()
+        note_id = str(uuid.uuid4())
+        await db_session.execute(
+            text("INSERT INTO notes (id, title, domain_id, task_id, body, content_format, is_deleted, created_at, updated_at) "
+                 "VALUES (:id, :title, :did, :tid, 'body', 'markdown', false, now(), now())"),
+            {"id": note_id, "title": f"TaskNote-{tag}", "did": seed_domain["id"], "tid": seed_task["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.get(f"/tasks/{seed_task['id']}?tab=notes")
+        assert f"TaskNote-{tag}" in r.text
+
+        await db_session.execute(text("DELETE FROM notes WHERE id = :id"), {"id": note_id})
+        await db_session.commit()
+
+    @pytest.mark.asyncio
+    async def test_invalid_tab_defaults_to_overview(self, client: AsyncClient, seed_task: dict):
+        """Invalid tab param still loads the page (defaults to overview)."""
+        r = await client.get(f"/tasks/{seed_task['id']}?tab=nonexistent")
+        assert r.status_code == 200
+
+
+# ===========================================================================
+# Task Contact Management
+# ===========================================================================
+class TestTaskContactManagement:
+    """Test adding and removing contacts on task detail."""
+
+    @pytest.mark.asyncio
+    async def test_add_contact_to_task(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_domain: dict, seed_project: dict, seed_contact: dict,
+    ):
+        """Adding a contact to a task creates a junction entry."""
+        tid = await _create_task(db_session, seed_domain["id"], seed_project["id"], f"ContactTask-{_uid()}")
+
+        r = await client.post(f"/tasks/{tid}/contacts/add", data={
+            "contact_id": seed_contact["id"],
+            "role": "reviewer",
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT role FROM contact_tasks WHERE task_id = :tid AND contact_id = :cid"),
+            {"tid": tid, "cid": seed_contact["id"]},
+        )
+        row = result.first()
+        assert row is not None, "Contact-task junction not created"
+        assert row.role == "reviewer"
+
+        # Cleanup
+        await db_session.execute(text("DELETE FROM contact_tasks WHERE task_id = :tid"), {"tid": tid})
+        await db_session.commit()
+        await _delete_tasks(db_session, [tid])
+
+    @pytest.mark.asyncio
+    async def test_remove_contact_from_task(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_domain: dict, seed_project: dict, seed_contact: dict,
+    ):
+        """Removing a contact from a task deletes the junction entry."""
+        tid = await _create_task(db_session, seed_domain["id"], seed_project["id"], f"RmContact-{_uid()}")
+        await db_session.execute(
+            text("INSERT INTO contact_tasks (contact_id, task_id, role) VALUES (:cid, :tid, 'test') ON CONFLICT DO NOTHING"),
+            {"cid": seed_contact["id"], "tid": tid},
+        )
+        await db_session.commit()
+
+        r = await client.post(f"/tasks/{tid}/contacts/{seed_contact['id']}/remove", follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT count(*) FROM contact_tasks WHERE task_id = :tid AND contact_id = :cid"),
+            {"tid": tid, "cid": seed_contact["id"]},
+        )
+        assert result.scalar() == 0
+
+        await _delete_tasks(db_session, [tid])
+
+    @pytest.mark.asyncio
+    async def test_add_duplicate_contact_no_error(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_task: dict, seed_contact: dict,
+    ):
+        """Adding same contact twice doesn't crash (ON CONFLICT DO NOTHING)."""
+        r = await client.post(f"/tasks/{seed_task['id']}/contacts/add", data={
+            "contact_id": seed_contact["id"],
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+        r = await client.post(f"/tasks/{seed_task['id']}/contacts/add", data={
+            "contact_id": seed_contact["id"],
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+
+# ===========================================================================
+# Project Detail Tabs
+# ===========================================================================
+class TestProjectDetailTabs:
+    """Test tabbed project detail page."""
+
+    @pytest.mark.asyncio
+    async def test_all_project_tabs_return_200(self, client: AsyncClient, seed_project: dict):
+        """Every tab on project detail returns 200."""
+        for tab in ("tasks", "notes", "links", "files", "lists", "decisions", "processes", "contacts"):
+            r = await client.get(f"/projects/{seed_project['id']}?tab={tab}")
+            assert r.status_code == 200, f"Project tab '{tab}' returned {r.status_code}"
+
+    @pytest.mark.asyncio
+    async def test_project_contacts_tab_shows_seed_contact(
+        self, client: AsyncClient, seed_project: dict, seed_contact: dict,
+    ):
+        """Contacts tab shows the linked contact."""
+        r = await client.get(f"/projects/{seed_project['id']}?tab=contacts")
+        assert seed_contact["first_name"] in r.text
+
+    @pytest.mark.asyncio
+    async def test_project_tasks_tab_shows_seed_task(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_project: dict, seed_task: dict,
+    ):
+        """Tasks tab shows the seed task linked to this project."""
+        # Ensure seed project and task are not soft-deleted (earlier tests may delete them)
+        await db_session.execute(
+            text("UPDATE projects SET is_deleted = false, deleted_at = NULL WHERE id = :id"),
+            {"id": seed_project["id"]},
+        )
+        await db_session.execute(
+            text("UPDATE tasks SET is_deleted = false, deleted_at = NULL WHERE id = :id"),
+            {"id": seed_task["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.get(f"/projects/{seed_project['id']}?tab=tasks")
+        assert seed_task["title"] in r.text
+
+
+# ===========================================================================
+# Project Contact Management
+# ===========================================================================
+class TestProjectContactManagement:
+    """Test adding and removing contacts on project detail."""
+
+    @pytest.mark.asyncio
+    async def test_add_contact_to_project(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_project: dict, seed_contact: dict,
+    ):
+        """Adding a contact to a project creates a junction entry."""
+        # First remove existing seed junction to test fresh add
+        await db_session.execute(
+            text("DELETE FROM contact_projects WHERE project_id = :pid AND contact_id = :cid"),
+            {"pid": seed_project["id"], "cid": seed_contact["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.post(f"/projects/{seed_project['id']}/contacts/add", data={
+            "contact_id": seed_contact["id"],
+            "role": "lead",
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT role FROM contact_projects WHERE project_id = :pid AND contact_id = :cid"),
+            {"pid": seed_project["id"], "cid": seed_contact["id"]},
+        )
+        row = result.first()
+        assert row is not None
+        assert row.role == "lead"
+
+    @pytest.mark.asyncio
+    async def test_remove_contact_from_project(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_project: dict, seed_contact: dict,
+    ):
+        """Removing a contact from a project deletes the junction entry."""
+        # Ensure junction exists
+        await db_session.execute(
+            text("INSERT INTO contact_projects (contact_id, project_id, role) VALUES (:cid, :pid, 'test') ON CONFLICT DO NOTHING"),
+            {"cid": seed_contact["id"], "pid": seed_project["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.post(f"/projects/{seed_project['id']}/contacts/{seed_contact['id']}/remove", follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT count(*) FROM contact_projects WHERE project_id = :pid AND contact_id = :cid"),
+            {"pid": seed_project["id"], "cid": seed_contact["id"]},
+        )
+        assert result.scalar() == 0
+
+        # Re-insert for other tests
+        await db_session.execute(
+            text("INSERT INTO contact_projects (contact_id, project_id, role) VALUES (:cid, :pid, 'stakeholder') ON CONFLICT DO NOTHING"),
+            {"cid": seed_contact["id"], "pid": seed_project["id"]},
+        )
+        await db_session.commit()
+
+
+# ===========================================================================
+# Meeting Detail Tabs
+# ===========================================================================
+class TestMeetingDetailTabs:
+    """Test tabbed meeting detail page."""
+
+    @pytest.mark.asyncio
+    async def test_all_meeting_tabs_return_200(self, client: AsyncClient, seed_meeting: dict):
+        """Every tab on meeting detail returns 200."""
+        for tab in ("overview", "notes", "weblinks", "files", "lists", "processes", "contacts"):
+            r = await client.get(f"/meetings/{seed_meeting['id']}?tab={tab}")
+            assert r.status_code == 200, f"Meeting tab '{tab}' returned {r.status_code}"
+
+    @pytest.mark.asyncio
+    async def test_meeting_contacts_tab_shows_seed_contact(
+        self, client: AsyncClient, seed_meeting: dict, seed_contact: dict,
+    ):
+        """Contacts tab shows the linked contact."""
+        r = await client.get(f"/meetings/{seed_meeting['id']}?tab=contacts")
+        assert seed_contact["first_name"] in r.text
+
+
+# ===========================================================================
+# Meeting Contact Management
+# ===========================================================================
+class TestMeetingContactManagement:
+    """Test adding and removing contacts on meeting detail."""
+
+    @pytest.mark.asyncio
+    async def test_add_contact_to_meeting(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_meeting: dict, seed_contact: dict,
+    ):
+        """Adding a contact to a meeting creates a junction entry."""
+        await db_session.execute(
+            text("DELETE FROM contact_meetings WHERE meeting_id = :mid AND contact_id = :cid"),
+            {"mid": seed_meeting["id"], "cid": seed_contact["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.post(f"/meetings/{seed_meeting['id']}/contacts/add", data={
+            "contact_id": seed_contact["id"],
+            "role": "organizer",
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT role FROM contact_meetings WHERE meeting_id = :mid AND contact_id = :cid"),
+            {"mid": seed_meeting["id"], "cid": seed_contact["id"]},
+        )
+        row = result.first()
+        assert row is not None
+        assert row.role == "organizer"
+
+    @pytest.mark.asyncio
+    async def test_remove_contact_from_meeting(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_meeting: dict, seed_contact: dict,
+    ):
+        """Removing a contact from a meeting deletes the junction entry."""
+        await db_session.execute(
+            text("INSERT INTO contact_meetings (contact_id, meeting_id, role) VALUES (:cid, :mid, 'attendee') ON CONFLICT DO NOTHING"),
+            {"cid": seed_contact["id"], "mid": seed_meeting["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.post(f"/meetings/{seed_meeting['id']}/contacts/{seed_contact['id']}/remove", follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT count(*) FROM contact_meetings WHERE meeting_id = :mid AND contact_id = :cid"),
+            {"mid": seed_meeting["id"], "cid": seed_contact["id"]},
+        )
+        assert result.scalar() == 0
+
+        # Re-insert for other tests
+        await db_session.execute(
+            text("INSERT INTO contact_meetings (contact_id, meeting_id, role) VALUES (:cid, :mid, 'attendee') ON CONFLICT DO NOTHING"),
+            {"cid": seed_contact["id"], "mid": seed_meeting["id"]},
+        )
+        await db_session.commit()
+
+
+# ===========================================================================
+# List Contact Management
+# ===========================================================================
+class TestListContactManagement:
+    """Test adding and removing contacts on list detail."""
+
+    @pytest.mark.asyncio
+    async def test_add_contact_to_list(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_list: dict, seed_contact: dict,
+    ):
+        """Adding a contact to a list creates a junction entry."""
+        await db_session.execute(
+            text("DELETE FROM contact_lists WHERE list_id = :lid AND contact_id = :cid"),
+            {"lid": seed_list["id"], "cid": seed_contact["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.post(f"/lists/{seed_list['id']}/contacts/add", data={
+            "contact_id": seed_contact["id"],
+            "role": "owner",
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT role FROM contact_lists WHERE list_id = :lid AND contact_id = :cid"),
+            {"lid": seed_list["id"], "cid": seed_contact["id"]},
+        )
+        row = result.first()
+        assert row is not None
+        assert row.role == "owner"
+
+    @pytest.mark.asyncio
+    async def test_remove_contact_from_list(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_list: dict, seed_contact: dict,
+    ):
+        """Removing a contact from a list deletes the junction entry."""
+        await db_session.execute(
+            text("INSERT INTO contact_lists (contact_id, list_id, role) VALUES (:cid, :lid, 'test') ON CONFLICT DO NOTHING"),
+            {"cid": seed_contact["id"], "lid": seed_list["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.post(f"/lists/{seed_list['id']}/contacts/{seed_contact['id']}/remove", follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT count(*) FROM contact_lists WHERE list_id = :lid AND contact_id = :cid"),
+            {"lid": seed_list["id"], "cid": seed_contact["id"]},
+        )
+        assert result.scalar() == 0
+
+        # Re-insert for other tests
+        await db_session.execute(
+            text("INSERT INTO contact_lists (contact_id, list_id, role) VALUES (:cid, :lid, 'contributor') ON CONFLICT DO NOTHING"),
+            {"cid": seed_contact["id"], "lid": seed_list["id"]},
+        )
+        await db_session.commit()
+
+
+# ===========================================================================
+# History Page
+# ===========================================================================
+class TestHistoryPage:
+    """Test the change history page."""
+
+    @pytest.mark.asyncio
+    async def test_history_page_loads(self, client: AsyncClient):
+        """History page returns 200."""
+        r = await client.get("/history/")
+        assert r.status_code == 200
+        assert "Change History" in r.text
+
+    @pytest.mark.asyncio
+    async def test_history_shows_seed_entities(
+        self, client: AsyncClient, db_session: AsyncSession, seed_task: dict,
+    ):
+        """History page shows recently modified seed entities."""
+        # Ensure seed task is not soft-deleted (earlier tests may delete it)
+        await db_session.execute(
+            text("UPDATE tasks SET is_deleted = false, deleted_at = NULL WHERE id = :id"),
+            {"id": seed_task["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.get("/history/")
+        assert r.status_code == 200
+        assert seed_task["title"] in r.text
+
+    @pytest.mark.asyncio
+    async def test_history_entity_type_filter(self, client: AsyncClient):
+        """History page can filter by entity type."""
+        for entity_type in ("tasks", "notes", "projects", "contacts"):
+            r = await client.get(f"/history/?entity_type={entity_type}")
+            assert r.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_history_shows_modified_vs_created(
+        self, client: AsyncClient, db_session: AsyncSession, seed_domain: dict,
+    ):
+        """Items with updated_at different from created_at show as 'modified'."""
+        tag = _uid()
+        note_id = str(uuid.uuid4())
+        await db_session.execute(
+            text("INSERT INTO notes (id, title, domain_id, body, content_format, is_deleted, created_at, updated_at) "
+                 "VALUES (:id, :title, :did, 'body', 'markdown', false, now() - interval '1 hour', now())"),
+            {"id": note_id, "title": f"HistMod-{tag}", "did": seed_domain["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.get("/history/?entity_type=notes")
+        assert f"HistMod-{tag}" in r.text
+        assert "modified" in r.text
+
+        await db_session.execute(text("DELETE FROM notes WHERE id = :id"), {"id": note_id})
+        await db_session.commit()
+
+
+# ===========================================================================
+# Search Prefix Matching
+# ===========================================================================
+class TestSearchPrefixMatching:
+    """Test the improved search with prefix tsquery and ILIKE fallback."""
+
+    @pytest.mark.asyncio
+    async def test_search_api_short_query_rejected(self, client: AsyncClient):
+        """Query shorter than 2 chars returns empty results."""
+        r = await client.get("/search/api?q=a")
+        assert r.status_code == 200
+        data = r.json()
+        assert len(data["results"]) == 0
+
+    @pytest.mark.asyncio
+    async def test_search_api_result_structure(self, client: AsyncClient):
+        """Search results have expected fields."""
+        r = await client.get("/search/api?q=Test")
+        assert r.status_code == 200
+        data = r.json()
+        if data["results"]:
+            result = data["results"][0]
+            assert "type" in result
+            assert "id" in result
+            assert "name" in result
+            assert "url" in result
+            assert "icon" in result
+            assert "rank" in result
+
+    @pytest.mark.asyncio
+    async def test_search_page_returns_200(self, client: AsyncClient):
+        """Full search page works."""
+        r = await client.get("/search/?q=Test")
+        assert r.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_search_ilike_fallback(
+        self, client: AsyncClient, db_session: AsyncSession, seed_domain: dict,
+    ):
+        """ILIKE fallback finds items that tsvector might miss."""
+        tag = _uid()
+        # Create a note with a very specific title
+        note_id = str(uuid.uuid4())
+        await db_session.execute(
+            text("INSERT INTO notes (id, title, domain_id, body, content_format, is_deleted, created_at, updated_at) "
+                 "VALUES (:id, :title, :did, 'body', 'markdown', false, now(), now())"),
+            {"id": note_id, "title": f"XqzNote{tag}", "did": seed_domain["id"]},
+        )
+        await db_session.commit()
+
+        r = await client.get(f"/search/api?q=XqzNote{tag}&entity_type=notes")
+        data = r.json()
+        ids = [res["id"] for res in data["results"]]
+        assert note_id in ids, "ILIKE fallback should find exact substring match"
+
+        await db_session.execute(text("DELETE FROM notes WHERE id = :id"), {"id": note_id})
+        await db_session.commit()
+
+
+# ===========================================================================
+# Projects API (Dynamic Filtering)
+# ===========================================================================
+class TestProjectsAPI:
+    """Test the /projects/api/by-domain JSON endpoint."""
+
+    @pytest.mark.asyncio
+    async def test_projects_by_domain_returns_json(
+        self, client: AsyncClient, db_session: AsyncSession, seed_domain: dict,
+    ):
+        """API returns JSON list of projects for a domain."""
+        # Ensure seed project is not soft-deleted (earlier tests may delete it)
+        await db_session.execute(
+            text("UPDATE projects SET is_deleted = false, deleted_at = NULL WHERE id = :id AND is_deleted = true"),
+            {"id": "a0000000-0000-0000-0000-000000000003"},
+        )
+        await db_session.commit()
+
+        r = await client.get(f"/projects/api/by-domain?domain_id={seed_domain['id']}")
+        assert r.status_code == 200
+        data = r.json()
+        assert isinstance(data, list)
+        assert any(p["name"] == "Test Project" for p in data)
+
+    @pytest.mark.asyncio
+    async def test_projects_by_domain_empty(self, client: AsyncClient):
+        """API returns empty list for nonexistent domain."""
+        fake_id = str(uuid.uuid4())
+        r = await client.get(f"/projects/api/by-domain?domain_id={fake_id}")
+        assert r.status_code == 200
+        data = r.json()
+        assert data == []
+
+    @pytest.mark.asyncio
+    async def test_projects_by_domain_no_param(self, client: AsyncClient):
+        """API without domain_id returns all active projects."""
+        r = await client.get("/projects/api/by-domain")
+        assert r.status_code == 200
+        data = r.json()
+        assert isinstance(data, list)
+
+
+# ===========================================================================
+# Eisenhower Matrix Filters
+# ===========================================================================
+class TestEisenhowerFilters:
+    """Test Eisenhower matrix page with filter parameters."""
+
+    @pytest.mark.asyncio
+    async def test_eisenhower_page_loads(self, client: AsyncClient):
+        """Eisenhower page returns 200."""
+        r = await client.get("/eisenhower/")
+        assert r.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_eisenhower_filter_by_domain(
+        self, client: AsyncClient, seed_domain: dict,
+    ):
+        """Eisenhower page accepts domain_id filter."""
+        r = await client.get(f"/eisenhower/?domain_id={seed_domain['id']}")
+        assert r.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_eisenhower_filter_by_status(self, client: AsyncClient):
+        """Eisenhower page accepts status filter."""
+        r = await client.get("/eisenhower/?status=open")
+        assert r.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_eisenhower_combined_filters(
+        self, client: AsyncClient, seed_domain: dict, seed_project: dict,
+    ):
+        """Eisenhower page accepts multiple filters."""
+        r = await client.get(
+            f"/eisenhower/?domain_id={seed_domain['id']}&project_id={seed_project['id']}&status=open"
+        )
+        assert r.status_code == 200
+
+
+# ===========================================================================
+# Focus Filters
+# ===========================================================================
+class TestFocusFilters:
+    """Test focus page filter parameters."""
+
+    @pytest.mark.asyncio
+    async def test_focus_filter_by_domain(
+        self, client: AsyncClient, seed_domain: dict,
+    ):
+        """Focus page accepts domain_id filter for available tasks."""
+        r = await client.get(f"/focus/?domain_id={seed_domain['id']}")
+        assert r.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_focus_filter_by_project(
+        self, client: AsyncClient, seed_project: dict,
+    ):
+        """Focus page accepts project_id filter."""
+        r = await client.get(f"/focus/?project_id={seed_project['id']}")
+        assert r.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_focus_combined_filters(
+        self, client: AsyncClient, seed_domain: dict, seed_project: dict,
+    ):
+        """Focus page accepts multiple filters."""
+        r = await client.get(
+            f"/focus/?domain_id={seed_domain['id']}&project_id={seed_project['id']}"
+        )
+        assert r.status_code == 200
+
+
+# ===========================================================================
+# Entity Create with task_id/meeting_id
+# ===========================================================================
+class TestEntityCreateWithParentContext:
+    """Test creating entities with task_id or meeting_id context."""
+
+    @pytest.mark.asyncio
+    async def test_create_note_with_task_id(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_task: dict, seed_domain: dict,
+    ):
+        """Creating a note with task_id sets the FK and redirects to task tab."""
+        tag = _uid()
+        r = await client.post("/notes/create", data={
+            "title": f"TaskNote-{tag}",
+            "domain_id": seed_domain["id"],
+            "body": "Test body",
+            "content_format": "markdown",
+            "task_id": seed_task["id"],
+        }, follow_redirects=False)
+        assert r.status_code == 303
+        # Should redirect back to task's notes tab
+        location = r.headers.get("location", "")
+        assert "tab=notes" in location
+
+        result = await db_session.execute(
+            text("SELECT task_id FROM notes WHERE title = :t AND is_deleted = false"),
+            {"t": f"TaskNote-{tag}"},
+        )
+        row = result.first()
+        assert row is not None
+        assert str(row.task_id) == seed_task["id"]
+
+        # Cleanup
+        await db_session.execute(
+            text("DELETE FROM notes WHERE title = :t"), {"t": f"TaskNote-{tag}"}
+        )
+        await db_session.commit()
+
+    @pytest.mark.asyncio
+    async def test_create_note_form_with_task_prefill(
+        self, client: AsyncClient, seed_task: dict,
+    ):
+        """Note create form with task_id query param loads correctly."""
+        r = await client.get(f"/notes/create?task_id={seed_task['id']}")
+        assert r.status_code == 200
+        assert seed_task["id"] in r.text
+
+    @pytest.mark.asyncio
+    async def test_create_weblink_with_task_id(
+        self, client: AsyncClient, db_session: AsyncSession, seed_task: dict,
+    ):
+        """Creating a weblink with task_id sets the FK."""
+        tag = _uid()
+        r = await client.post("/weblinks/create", data={
+            "label": f"TaskWeblink-{tag}",
+            "url": "https://example.com/test",
+            "task_id": seed_task["id"],
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT task_id FROM weblinks WHERE label = :l AND is_deleted = false"),
+            {"l": f"TaskWeblink-{tag}"},
+        )
+        row = result.first()
+        assert row is not None
+        assert str(row.task_id) == seed_task["id"]
+
+        await db_session.execute(
+            text("DELETE FROM weblinks WHERE label = :l"), {"l": f"TaskWeblink-{tag}"}
+        )
+        await db_session.commit()
+
+    @pytest.mark.asyncio
+    async def test_create_list_with_task_id(
+        self, client: AsyncClient, db_session: AsyncSession,
+        seed_task: dict, seed_domain: dict,
+    ):
+        """Creating a list with task_id sets the FK."""
+        tag = _uid()
+        r = await client.post("/lists/create", data={
+            "name": f"TaskList-{tag}",
+            "domain_id": seed_domain["id"],
+            "list_type": "checklist",
+            "task_id": seed_task["id"],
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT task_id FROM lists WHERE name = :n AND is_deleted = false"),
+            {"n": f"TaskList-{tag}"},
+        )
+        row = result.first()
+        assert row is not None
+        assert str(row.task_id) == seed_task["id"]
+
+        await db_session.execute(
+            text("DELETE FROM lists WHERE name = :n"), {"n": f"TaskList-{tag}"}
+        )
+        await db_session.commit()
+
+    @pytest.mark.asyncio
+    async def test_create_decision_with_task_id(
+        self, client: AsyncClient, db_session: AsyncSession, seed_task: dict,
+    ):
+        """Creating a decision with task_id sets the FK."""
+        tag = _uid()
+        r = await client.post("/decisions/create", data={
+            "title": f"TaskDecision-{tag}",
+            "status": "proposed",
+            "impact": "medium",
+            "task_id": seed_task["id"],
+        }, follow_redirects=False)
+        assert r.status_code == 303
+
+        result = await db_session.execute(
+            text("SELECT task_id FROM decisions WHERE title = :t AND is_deleted = false"),
+            {"t": f"TaskDecision-{tag}"},
+        )
+        row = result.first()
+        assert row is not None
+        assert str(row.task_id) == seed_task["id"]
+
+        await db_session.execute(
+            text("DELETE FROM decisions WHERE title = :t"), {"t": f"TaskDecision-{tag}"}
+        )
+        await db_session.commit()