From b66b60da9d80a6617e989e55448ca1615e43e516 Mon Sep 17 00:00:00 2001
From: Adron Hall <adronhall@gmail.com>
Date: Fri, 31 Jul 2026 16:17:30 -0700
Subject: [PATCH] Build out API feature parity with interlinedlist.com
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes the bulk of the gap between the native client and the web app,
verified endpoint-by-endpoint against the live API (OpenAPI + probing with
the test account). App builds clean in Debug and Release; the self-contained
win-x64 publish (what the WiX MSI harvests) succeeds.

New nav views:
- Direct Messages — recipients + thread + send/read
- People — profile lookup, follow/unfollow, request approve/reject, a user's
  messages, block/mute/report
- Settings — profile edit, avatar-from-URL, email change, notification prefs,
  blocked/muted management, API-session list + revoke, CSV data export

Feed depth:
- replies/threads, edit/delete own posts, report, image attachments (upload +
  display), and click-through from an author to their profile (Navigator hub)

Existing views enhanced:
- Lists: row edit + delete (were write-once)
- Documents: folder create/rename/delete + new-doc-in-folder
- Organizations: full member management (add via search, change role, remove),
  edit/delete org
- Notifications: mark-one-read + delete-one

Service layer: 10 new/extended partials + multipart upload helper + shared
JSON helpers; wire models added for all of the above. Write paths follow the
codebase's read-after-write discipline.

Corrected stale CLAUDE.md constraints (re-verified live 2026-07-31): org
members and LinkedIn targets accept the bearer token (were documented as 401
walls), and the sync-token DOES have a server-side revoke
(GET/DELETE /api/user/sessions). See the-gaps.md for the full gap analysis,
per-session progress, and remaining post-v1 items.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CLAUDE.md                                     |  79 ++-
 InterlinedList/MainWindow.xaml                |  18 +
 InterlinedList/MainWindow.xaml.cs             |  16 +
 InterlinedList/Models/ApiSession.cs           |  19 +
 InterlinedList/Models/DirectMessage.cs        |  21 +
 InterlinedList/Models/DmRecipient.cs          |  16 +
 InterlinedList/Models/DmThread.cs             |  14 +
 InterlinedList/Models/FollowStatus.cs         |  13 +
 InterlinedList/Models/FollowUser.cs           |  20 +
 InterlinedList/Models/ModeratedUser.cs        |  17 +
 .../Models/NotificationPreference.cs          |  20 +
 InterlinedList/Models/OrgMember.cs            |  22 +
 InterlinedList/Models/UserProfile.cs          |  26 +
 .../Services/InterlinedApiClient.Account.cs   |  74 +++
 .../InterlinedApiClient.DirectMessages.cs     |  42 ++
 .../Services/InterlinedApiClient.Documents.cs |  18 +
 .../Services/InterlinedApiClient.Exports.cs   |  20 +
 .../Services/InterlinedApiClient.Follow.cs    |  54 ++
 .../Services/InterlinedApiClient.Lists.cs     |  20 +
 .../Services/InterlinedApiClient.Messages.cs  |  60 ++
 .../InterlinedApiClient.Moderation.cs         |  56 ++
 .../InterlinedApiClient.Organizations.cs      |  35 +-
 .../Services/InterlinedApiClient.People.cs    |  20 +
 .../Services/InterlinedApiClient.cs           |  90 ++-
 InterlinedList/Services/Navigator.cs          |  18 +
 .../ViewModels/DirectMessagesViewModel.cs     | 129 ++++
 .../ViewModels/DmMessageViewModel.cs          |  23 +
 .../ViewModels/DocumentsViewModel.cs          | 143 +++++
 InterlinedList/ViewModels/FeedViewModel.cs    |  57 +-
 InterlinedList/ViewModels/ListsViewModel.cs   |  72 +++
 .../ViewModels/MessageItemViewModel.cs        | 173 +++++-
 .../ViewModels/NotificationPrefViewModel.cs   |  58 ++
 .../ViewModels/NotificationsViewModel.cs      |  32 +
 .../ViewModels/OrganizationsViewModel.cs      | 250 ++++++++
 InterlinedList/ViewModels/ProfileViewModel.cs | 225 +++++++
 .../ViewModels/SettingsViewModel.cs           | 251 ++++++++
 InterlinedList/Views/DirectMessagesView.xaml  | 323 ++++++++++
 .../Views/DirectMessagesView.xaml.cs          |  15 +
 InterlinedList/Views/DocumentsView.xaml       |  83 ++-
 InterlinedList/Views/DocumentsView.xaml.cs    |  23 +
 InterlinedList/Views/FeedView.xaml            | 207 ++++++-
 InterlinedList/Views/ListsView.xaml           |  99 ++-
 InterlinedList/Views/OrganizationsView.xaml   | 283 ++++++++-
 InterlinedList/Views/PeopleView.xaml          | 443 ++++++++++++++
 InterlinedList/Views/PeopleView.xaml.cs       |  24 +
 InterlinedList/Views/SettingsView.xaml        | 562 ++++++++++++++++++
 InterlinedList/Views/SettingsView.xaml.cs     |  15 +
 the-gaps.md                                   | 435 ++++++++++++++
 48 files changed, 4640 insertions(+), 93 deletions(-)
 create mode 100644 InterlinedList/Models/ApiSession.cs
 create mode 100644 InterlinedList/Models/DirectMessage.cs
 create mode 100644 InterlinedList/Models/DmRecipient.cs
 create mode 100644 InterlinedList/Models/DmThread.cs
 create mode 100644 InterlinedList/Models/FollowStatus.cs
 create mode 100644 InterlinedList/Models/FollowUser.cs
 create mode 100644 InterlinedList/Models/ModeratedUser.cs
 create mode 100644 InterlinedList/Models/NotificationPreference.cs
 create mode 100644 InterlinedList/Models/OrgMember.cs
 create mode 100644 InterlinedList/Models/UserProfile.cs
 create mode 100644 InterlinedList/Services/InterlinedApiClient.Account.cs
 create mode 100644 InterlinedList/Services/InterlinedApiClient.DirectMessages.cs
 create mode 100644 InterlinedList/Services/InterlinedApiClient.Exports.cs
 create mode 100644 InterlinedList/Services/InterlinedApiClient.Follow.cs
 create mode 100644 InterlinedList/Services/InterlinedApiClient.Messages.cs
 create mode 100644 InterlinedList/Services/InterlinedApiClient.Moderation.cs
 create mode 100644 InterlinedList/Services/InterlinedApiClient.People.cs
 create mode 100644 InterlinedList/Services/Navigator.cs
 create mode 100644 InterlinedList/ViewModels/DirectMessagesViewModel.cs
 create mode 100644 InterlinedList/ViewModels/DmMessageViewModel.cs
 create mode 100644 InterlinedList/ViewModels/NotificationPrefViewModel.cs
 create mode 100644 InterlinedList/ViewModels/ProfileViewModel.cs
 create mode 100644 InterlinedList/ViewModels/SettingsViewModel.cs
 create mode 100644 InterlinedList/Views/DirectMessagesView.xaml
 create mode 100644 InterlinedList/Views/DirectMessagesView.xaml.cs
 create mode 100644 InterlinedList/Views/PeopleView.xaml
 create mode 100644 InterlinedList/Views/PeopleView.xaml.cs
 create mode 100644 InterlinedList/Views/SettingsView.xaml
 create mode 100644 InterlinedList/Views/SettingsView.xaml.cs
 create mode 100644 the-gaps.md

diff --git a/CLAUDE.md b/CLAUDE.md
index 239ddb3..dd11034 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -74,31 +74,52 @@ The app talks to the real InterlinedList backend at `https://interlinedlist.com`
 (154-endpoint REST API, OpenAPI spec at `/api/openapi.json`) — there is no mock
 data layer. Auth is a long-lived bearer token from `POST /api/auth/sync-token`
 (the same mechanism the `il-sync` CLI and other native clients use — no cookie
-jar), persisted DPAPI-encrypted via `CredentialStore`. **There is no
-server-side revoke endpoint for this token** — treat `%LocalAppData%\InterlinedList\session.dat`
-as a standing credential.
-
-Covered now: login/session restore, paginated feed, compose, Dig/Undig,
-notifications tray, profile/follow-counts rail, **Lists** (browse/create/
-delete, freeform JSON data rows — no schema/column editor, see below),
-**Documents** (personal markdown notes: root docs, folders, templates,
-create/edit/delete), **Organizations** (browse orgs you belong to + the
-public directory, create — **no member management**, see below), unified
-**Search** (messages/people/lists/documents from one box), and **Connected
-Accounts** (Bluesky/Mastodon/LinkedIn/Twitter linking + compose-time
-cross-post toggles). Still not built: Stripe billing, replies/threads,
-register/forgot-password, GitHub issue sync, per-list schema/column
-definitions, LinkedIn per-page posting targets.
-
-**Two real, load-bearing constraints discovered by live-probing the API — don't
+jar), persisted DPAPI-encrypted via `CredentialStore`. The token is
+long-lived, so treat `%LocalAppData%\InterlinedList\session.dat` as a standing
+credential — but note the server **does** expose session management:
+`GET /api/user/sessions` lists a user's active sync tokens and
+`DELETE /api/user/sessions/{id}` revokes one (both accept the bearer token —
+verified live 2026-07-31). An earlier revision of this file claimed no revoke
+endpoint existed; that is no longer true.
+
+Covered now (greatly expanded in the 2026-07-31 parity build-out):
+login/session restore, paginated **feed** with compose (text + **image
+attachments**, cross-post toggles), Dig/Undig, **replies/threads**, **edit/
+delete** own posts, **report** posts, and **click-through to author profiles**;
+notifications tray with **mark-one-read / delete-one / mark-all**; **Direct
+Messages** (recipient list + thread + send); **People** (profile lookup,
+follow/unfollow, follow-request approve/reject, a user's messages,
+**block/mute/report**); **Lists** (browse/create/delete, freeform JSON data
+rows with **row edit + delete** — no schema/column editor, see below);
+**Documents** (root docs, templates, create/edit/delete + **folder CRUD /
+new-doc-in-folder**); **Organizations** (browse + create + **full member
+management**: add via search, change role, remove, edit/delete org);
+**Settings** (profile edit, avatar-from-URL, email change, notification
+preferences, blocked/muted management, **API-session list + revoke**, **CSV
+data export**); unified **Search**; and **Connected Accounts** (Bluesky/
+Mastodon/LinkedIn/Twitter linking + cross-post toggles). Still not built:
+Stripe billing UI, register/forgot-password, GitHub issue sync (endpoints work
+but the test account has no GitHub linked), per-list schema/column definitions,
+LinkedIn per-page posting targets, scheduled-post UI (the service supports
+`scheduledAt`), media *video* upload, list watchers/sharing, document sharing/
+collaborators, Materialize ("Create from…"), and account deletion UI (the
+service method exists, intentionally unsurfaced).
+
+**Load-bearing constraints discovered by live-probing the API — don't
 "fix" these without re-verifying, they're not bugs in this app:**
 
-1. **Not every endpoint accepts the bearer sync-token.** `GET/POST
-   /api/organizations/{id}/members` and `GET /api/linkedin/targets` /
-   `posting-targets` return `401` even with a valid token — that subsystem
-   requires cookie-session auth this native client doesn't have. This is why
-   Organizations has no member-management UI and Connected Accounts has no
-   LinkedIn per-page targeting.
+1. **A few endpoints only accept cookie-session auth, not the bearer
+   sync-token.** Re-probed live 2026-07-31 with the test account:
+   `GET /api/user/engagement` and `GET/PUT /api/user/dashboard-layout` return
+   `401` with a valid bearer token (Stripe billing + some `/api/auth/*` session
+   flows are the same shape). A native bearer-token client structurally can't
+   get a cookie session, so those are either browser-handoff (like OAuth) or
+   out of scope. **Correction to an earlier claim:** `GET
+   /api/organizations/{id}/members`, `GET /api/linkedin/targets`, and
+   `GET /api/linkedin/posting-targets` were *previously* documented here as
+   `401`-walled, but as of 2026-07-31 they return `200` with the bearer token —
+   member-management and LinkedIn per-page targeting **are** buildable now.
+   (Member *mutations* — POST/PUT/DELETE — still need live write-verification.)
 2. **The per-provider `GET /api/auth/{provider}/status` endpoints are a red
    herring** — they report whether the *server* has that OAuth integration
    configured, not whether *this user* has linked it. The real per-user link
@@ -117,11 +138,13 @@ engineered and is **not implemented** — data rows work fine schema-less
 verify the actual response shape against a real (test) account before typing
 it strictly, and prefer read-after-write over trusting an unverified envelope.
 
-Left nav maps to real views now: **Feed**, **Lists**, **Documents**,
-**Organizations**, **Search** (`MainWindow.xaml.cs` `NavItem_Click` swaps a
-`ContentControl` via a small per-tag cache in `_views`), **Accounts**
-(Connected Accounts), and **Alerts** (unchanged from Phase 2 — still a
-right-rail toggle, not a center view).
+Left nav maps to real views now: **Feed**, **Messages** (Direct Messages),
+**Lists**, **Documents**, **Organizations**, **People** (profiles + follow),
+**Search** (`MainWindow.xaml.cs` `NavItem_Click` swaps a `ContentControl` via a
+small per-tag cache in `_views`), **Accounts** (Connected Accounts),
+**Settings**, and **Alerts** (right-rail toggle, not a center view). Feed/search
+cards open a profile in the People tab via the `Navigator` hub
+(`Services/Navigator.cs`) → `MainWindow.OpenProfile`.
 
 ## Packaging & distribution
 
diff --git a/InterlinedList/MainWindow.xaml b/InterlinedList/MainWindow.xaml
index 56a3478..81734a4 100644
--- a/InterlinedList/MainWindow.xaml
+++ b/InterlinedList/MainWindow.xaml
@@ -97,16 +97,22 @@
 
                     <Button x:Name="NavFeed"    Tag="Feed"          Click="NavItem_Click"
                             Style="{StaticResource NavItemStyle}" Content="Feed"/>
+                    <Button x:Name="NavMessages" Tag="Messages"     Click="NavItem_Click"
+                            Style="{StaticResource NavItemStyle}" Content="Messages"/>
                     <Button x:Name="NavLists"   Tag="Lists"         Click="NavItem_Click"
                             Style="{StaticResource NavItemStyle}" Content="Lists"/>
                     <Button x:Name="NavDocuments" Tag="Documents"   Click="NavItem_Click"
                             Style="{StaticResource NavItemStyle}" Content="Documents"/>
                     <Button x:Name="NavOrganizations" Tag="Organizations" Click="NavItem_Click"
                             Style="{StaticResource NavItemStyle}" Content="Organizations"/>
+                    <Button x:Name="NavPeople"  Tag="People"        Click="NavItem_Click"
+                            Style="{StaticResource NavItemStyle}" Content="People"/>
                     <Button x:Name="NavSearch"  Tag="Search"        Click="NavItem_Click"
                             Style="{StaticResource NavItemStyle}" Content="Search"/>
                     <Button x:Name="NavAccounts" Tag="Accounts"     Click="NavItem_Click"
                             Style="{StaticResource NavItemStyle}" Content="Accounts"/>
+                    <Button x:Name="NavSettings" Tag="Settings"     Click="NavItem_Click"
+                            Style="{StaticResource NavItemStyle}" Content="Settings"/>
                     <Button x:Name="NavAlerts"  Tag="Alerts"        Click="NavItem_Click"
                             Style="{StaticResource NavItemStyle}" Content="Alerts"/>
 
@@ -232,6 +238,18 @@
                                                            FontSize="11"
                                                            Foreground="{DynamicResource TextMutedBrush}"
                                                            TextWrapping="Wrap"/>
+                                                <StackPanel Orientation="Horizontal" Margin="0,6,0,0">
+                                                    <Button Content="Read"
+                                                            Command="{Binding DataContext.Notifications.MarkOneReadCommand, RelativeSource={RelativeSource AncestorType=Window}}"
+                                                            CommandParameter="{Binding}"
+                                                            Style="{StaticResource DigBtnStyle}"
+                                                            Margin="0,0,6,0"
+                                                            Visibility="{Binding IsUnread, Converter={StaticResource BoolToVisibility}}"/>
+                                                    <Button Content="Delete"
+                                                            Command="{Binding DataContext.Notifications.DeleteOneCommand, RelativeSource={RelativeSource AncestorType=Window}}"
+                                                            CommandParameter="{Binding}"
+                                                            Style="{StaticResource DigBtnStyle}"/>
+                                                </StackPanel>
                                             </StackPanel>
                                         </Border>
                                     </DataTemplate>
diff --git a/InterlinedList/MainWindow.xaml.cs b/InterlinedList/MainWindow.xaml.cs
index 89c5760..ad0a571 100644
--- a/InterlinedList/MainWindow.xaml.cs
+++ b/InterlinedList/MainWindow.xaml.cs
@@ -24,6 +24,9 @@ public MainWindow()
 
         Profile.LoggedOut += (_, _) => LoggedOut?.Invoke(this, EventArgs.Empty);
 
+        // Feed/search cards raise this to open a user's profile in the People tab.
+        Navigator.OnOpenProfile = OpenProfile;
+
         StartClock();
 
         _ = Notifications.LoadCommand.ExecuteAsync(null);
@@ -60,6 +63,16 @@ private void NavItem_Click(object sender, RoutedEventArgs e)
         CenterContent.Content = ViewFor(tag);
     }
 
+    // Navigator.OnOpenProfile → switch to the People tab and load the given user.
+    private void OpenProfile(string username)
+    {
+        NotificationsRail.Visibility = Visibility.Collapsed;
+        ProfileRail.Visibility = Visibility.Visible;
+        var view = (Views.PeopleView)ViewFor("People");
+        CenterContent.Content = view;
+        view.LoadProfile(username);
+    }
+
     private UserControl ViewFor(string tag)
     {
         if (_views.TryGetValue(tag, out var existing)) return existing;
@@ -67,11 +80,14 @@ private UserControl ViewFor(string tag)
         UserControl view = tag switch
         {
             "Feed" => new FeedView(),
+            "Messages" => new DirectMessagesView(),
             "Lists" => new ListsView(),
             "Documents" => new DocumentsView(),
             "Organizations" => new OrganizationsView(),
+            "People" => new PeopleView(),
             "Search" => new SearchView(),
             "Accounts" => new ConnectedAccountsView(),
+            "Settings" => new SettingsView(),
             _ => new FeedView(),
         };
 
diff --git a/InterlinedList/Models/ApiSession.cs b/InterlinedList/Models/ApiSession.cs
new file mode 100644
index 0000000..ae8ef48
--- /dev/null
+++ b/InterlinedList/Models/ApiSession.cs
@@ -0,0 +1,19 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// An active sync-token / API session from GET /api/user/sessions. Revocable via
+/// DELETE /api/user/sessions/{id} (verified live 2026-07-31 — the endpoint the
+/// app itself relies on to let a user cut off a lost device's standing token).
+/// </summary>
+public sealed class ApiSession
+{
+    public required string Id { get; init; }
+    public string? DeviceLabel { get; init; }
+    public DateTimeOffset CreatedAt { get; init; }
+    public DateTimeOffset? LastUsedAt { get; init; }
+    public bool IsCurrent { get; init; }
+
+    public string DeviceLabelOrFallback => string.IsNullOrWhiteSpace(DeviceLabel) ? "Unknown device" : DeviceLabel;
+    public string CreatedFormatted => CreatedAt.ToLocalTime().ToString("yyyy-MM-dd HH:mm");
+    public string LastUsedFormatted => LastUsedAt?.ToLocalTime().ToString("yyyy-MM-dd HH:mm") ?? "—";
+}
diff --git a/InterlinedList/Models/DirectMessage.cs b/InterlinedList/Models/DirectMessage.cs
new file mode 100644
index 0000000..d7f09bf
--- /dev/null
+++ b/InterlinedList/Models/DirectMessage.cs
@@ -0,0 +1,21 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// A single 1:1 direct message (matches the OpenAPI DirectMessage schema).
+/// Soft-delete is per-side: sender/recipientDeletedAt hide it for only one
+/// participant. ReadAt is set once the recipient opens the thread.
+/// </summary>
+public sealed class DirectMessage
+{
+    public required string Id { get; init; }
+    public required string SenderId { get; init; }
+    public required string RecipientId { get; init; }
+    public required string Body { get; init; }
+    public List<string>? ImageUrls { get; init; }
+    public required DateTimeOffset CreatedAt { get; init; }
+    public DateTimeOffset? ReadAt { get; init; }
+    public DateTimeOffset? SenderDeletedAt { get; init; }
+    public DateTimeOffset? RecipientDeletedAt { get; init; }
+
+    public string TimeFormatted => CreatedAt.ToUniversalTime().ToString("HH:mm:ss'Z'");
+}
diff --git a/InterlinedList/Models/DmRecipient.cs b/InterlinedList/Models/DmRecipient.cs
new file mode 100644
index 0000000..3dd6de5
--- /dev/null
+++ b/InterlinedList/Models/DmRecipient.cs
@@ -0,0 +1,16 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// A person the current user can DM (GET /api/dm/recipients) and the
+/// "otherUser" identity embedded in a thread payload.
+/// </summary>
+public sealed class DmRecipient
+{
+    public required string Id { get; init; }
+    public required string Username { get; init; }
+    public string? DisplayName { get; init; }
+    public string? Avatar { get; init; }
+
+    public string DisplayNameOrUsername => DisplayName ?? Username;
+    public string Handle => $"@{Username}";
+}
diff --git a/InterlinedList/Models/DmThread.cs b/InterlinedList/Models/DmThread.cs
new file mode 100644
index 0000000..053a30d
--- /dev/null
+++ b/InterlinedList/Models/DmThread.cs
@@ -0,0 +1,14 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// GET /api/dm/thread/{username} — the conversation with one person, oldest
+/// page first. OlderCursor paginates backward into history.
+/// </summary>
+public sealed class DmThread
+{
+    public required List<DirectMessage> Items { get; init; }
+    public DmRecipient? OtherUser { get; init; }
+    public bool IsBlocked { get; init; }
+    public bool IsMutual { get; init; }
+    public string? OlderCursor { get; init; }
+}
diff --git a/InterlinedList/Models/FollowStatus.cs b/InterlinedList/Models/FollowStatus.cs
new file mode 100644
index 0000000..13968a5
--- /dev/null
+++ b/InterlinedList/Models/FollowStatus.cs
@@ -0,0 +1,13 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// GET /api/follow/{userId}/status — the caller's relationship to a target user.
+/// Status is "approved" / "pending" / null; IsPending flags a follow request the
+/// caller has sent that the (private) target hasn't approved yet.
+/// </summary>
+public sealed class FollowStatus
+{
+    public string? Status { get; init; }
+    public bool IsFollowing { get; init; }
+    public bool IsPending { get; init; }
+}
diff --git a/InterlinedList/Models/FollowUser.cs b/InterlinedList/Models/FollowUser.cs
new file mode 100644
index 0000000..9092a1a
--- /dev/null
+++ b/InterlinedList/Models/FollowUser.cs
@@ -0,0 +1,20 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// A user entry in a followers / following / follow-requests list.
+/// FollowId + Status are present on relationship-scoped lists (a follower row
+/// carries the follow edge's id so it can be approved/rejected/removed).
+/// </summary>
+public sealed class FollowUser
+{
+    public required string Id { get; init; }
+    public required string Username { get; init; }
+    public string? DisplayName { get; init; }
+    public string? Avatar { get; init; }
+    public string? FollowId { get; init; }
+    public string? Status { get; init; }
+    public DateTimeOffset? CreatedAt { get; init; }
+
+    public string DisplayNameOrUsername => DisplayName ?? Username;
+    public string Handle => $"@{Username}";
+}
diff --git a/InterlinedList/Models/ModeratedUser.cs b/InterlinedList/Models/ModeratedUser.cs
new file mode 100644
index 0000000..1747b9f
--- /dev/null
+++ b/InterlinedList/Models/ModeratedUser.cs
@@ -0,0 +1,17 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// A user entry in the current user's block list (GET /api/user/blocks →
+/// blockedUsers[]) or mute list (GET /api/user/mutes → mutedUsers[]).
+/// </summary>
+public sealed class ModeratedUser
+{
+    public required string Id { get; init; }
+    public required string Username { get; init; }
+    public string? DisplayName { get; init; }
+    public string? Avatar { get; init; }
+    public DateTimeOffset? CreatedAt { get; init; }
+
+    public string DisplayNameOrUsername => DisplayName ?? Username;
+    public string Handle => $"@{Username}";
+}
diff --git a/InterlinedList/Models/NotificationPreference.cs b/InterlinedList/Models/NotificationPreference.cs
new file mode 100644
index 0000000..3c8cdaf
--- /dev/null
+++ b/InterlinedList/Models/NotificationPreference.cs
@@ -0,0 +1,20 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// One row of GET /api/user/notification-preferences ("events"): a notifiable
+/// event and which delivery channels are enabled for it. PATCH the same
+/// endpoint to change a channel toggle.
+/// </summary>
+public sealed class NotificationPreference
+{
+    public required string Key { get; init; }
+    public required string Label { get; init; }
+    public string? Description { get; init; }
+    public NotificationChannels Channels { get; init; } = new();
+}
+
+public sealed class NotificationChannels
+{
+    public bool Push { get; init; }
+    public bool InApp { get; init; }
+}
diff --git a/InterlinedList/Models/OrgMember.cs b/InterlinedList/Models/OrgMember.cs
new file mode 100644
index 0000000..9df6b96
--- /dev/null
+++ b/InterlinedList/Models/OrgMember.cs
@@ -0,0 +1,22 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// A member of an organization (GET /api/organizations/{id}/members → members[]).
+/// Role is "owner" / "admin" / "member"; Active flags a soft-removed seat.
+/// This endpoint accepts the bearer token (verified live 2026-07-31 — an earlier
+/// note claimed it was 401-walled; that's no longer true).
+/// </summary>
+public sealed class OrgMember
+{
+    public required string Id { get; init; }
+    public required string Username { get; init; }
+    public string? DisplayName { get; init; }
+    public string? Avatar { get; init; }
+    public string? Role { get; init; }
+    public bool Active { get; init; }
+    public DateTimeOffset? JoinedAt { get; init; }
+
+    public string DisplayNameOrUsername => DisplayName ?? Username;
+    public string Handle => $"@{Username}";
+    public string RoleLabel => string.IsNullOrEmpty(Role) ? "member" : Role;
+}
diff --git a/InterlinedList/Models/UserProfile.cs b/InterlinedList/Models/UserProfile.cs
new file mode 100644
index 0000000..cb52df9
--- /dev/null
+++ b/InterlinedList/Models/UserProfile.cs
@@ -0,0 +1,26 @@
+namespace InterlinedList.Models;
+
+/// <summary>
+/// Public profile from GET /api/users/{username}. Relationship state
+/// (isFollowing / isBlocked / isMuted) is NOT reliably populated on this
+/// payload — fetch it separately via the follow-status and block/mute
+/// endpoints (verified live 2026-07-31: those fields came back null here).
+/// </summary>
+public sealed class UserProfile
+{
+    public required string Id { get; init; }
+    public required string Username { get; init; }
+    public string? DisplayName { get; init; }
+    public string? Bio { get; init; }
+    public string? Avatar { get; init; }
+    public string? HeaderImage { get; init; }
+    public bool IsPrivate { get; init; }
+    public DateTimeOffset? JoinedAt { get; init; }
+    public int FollowerCount { get; init; }
+    public int FollowingCount { get; init; }
+    public int PublicListCount { get; init; }
+    public int PublicMessageCount { get; init; }
+
+    public string DisplayNameOrUsername => DisplayName ?? Username;
+    public string Handle => $"@{Username}";
+}
diff --git a/InterlinedList/Services/InterlinedApiClient.Account.cs b/InterlinedList/Services/InterlinedApiClient.Account.cs
new file mode 100644
index 0000000..9b7a29b
--- /dev/null
+++ b/InterlinedList/Services/InterlinedApiClient.Account.cs
@@ -0,0 +1,74 @@
+using System.IO;
+using System.Net.Http;
+using System.Text.Json;
+using InterlinedList.Models;
+
+namespace InterlinedList.Services;
+
+/// <summary>
+/// Account & settings: profile edit, notification preferences, and API-session
+/// (sync-token) management. GET /api/user/sessions + DELETE
+/// /api/user/sessions/{id} let a user list and revoke standing tokens — the
+/// genuine "sign out this lost device" capability the app previously assumed
+/// didn't exist (verified live 2026-07-31; DELETE is the one destructive call
+/// here and is exercised only against a session the user explicitly picks).
+/// </summary>
+public sealed partial class InterlinedApiClient
+{
+    public Task UpdateProfileAsync(
+        string? displayName,
+        string? bio,
+        bool? isPrivateAccount = null,
+        string? theme = null,
+        CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Patch, "api/user/update",
+            new { displayName, bio, isPrivateAccount, theme }, ct);
+
+    public async Task<List<ApiSession>> GetSessionsAsync(CancellationToken ct = default)
+    {
+        var json = await GetElementAsync("api/user/sessions", ct);
+        return json.TryGetProperty("sessions", out var arr) && arr.ValueKind == JsonValueKind.Array
+            ? arr.Deserialize<List<ApiSession>>(JsonOptions) ?? new()
+            : new();
+    }
+
+    public Task RevokeSessionAsync(string id, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/user/sessions/{id}", null, ct);
+
+    public async Task<List<NotificationPreference>> GetNotificationPreferencesAsync(CancellationToken ct = default)
+    {
+        var json = await GetElementAsync("api/user/notification-preferences", ct);
+        return json.TryGetProperty("events", out var arr) && arr.ValueKind == JsonValueKind.Array
+            ? arr.Deserialize<List<NotificationPreference>>(JsonOptions) ?? new()
+            : new();
+    }
+
+    // channels is sent as an object { push, inApp }; the GET returns it that way,
+    // though the OpenAPI request schema loosely types it as string — verify a
+    // real PATCH round-trips before treating this as fully proven.
+    public Task SetNotificationPreferenceAsync(string key, bool push, bool inApp, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Patch, "api/user/notification-preferences",
+            new { key, channels = new { push, inApp } }, ct);
+
+    // ── Avatar / email / account lifecycle ──────────────────────────────────────
+    // Request shapes verified against the OpenAPI spec 2026-07-31: avatar {url},
+    // change-email {newEmail}, delete {username,email} (a self-confirmation guard).
+
+    public Task UpdateAvatarFromUrlAsync(string url, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, "api/user/avatar/from-url", new { url }, ct);
+
+    public async Task<string> UploadAvatarAsync(Stream content, string fileName, string contentType, CancellationToken ct = default)
+    {
+        var json = await SendMultipartAsync("api/user/avatar/upload", content, fileName, contentType, ct: ct);
+        return json.TryGetProperty("url", out var url) && url.GetString() is { Length: > 0 } u ? u : "";
+    }
+
+    public Task RequestEmailChangeAsync(string newEmail, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, "api/user/change-email/request", new { newEmail }, ct);
+
+    // Destructive. The body echoes the caller's own username + email as a
+    // confirmation guard the server checks — callers should require the user to
+    // type these before invoking.
+    public Task DeleteAccountAsync(string username, string email, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, "api/user/delete", new { username, email }, ct);
+}
diff --git a/InterlinedList/Services/InterlinedApiClient.DirectMessages.cs b/InterlinedList/Services/InterlinedApiClient.DirectMessages.cs
new file mode 100644
index 0000000..623c5a1
--- /dev/null
+++ b/InterlinedList/Services/InterlinedApiClient.DirectMessages.cs
@@ -0,0 +1,42 @@
+using System.Net.Http;
+using System.Text.Json;
+using InterlinedList.Models;
+
+namespace InterlinedList.Services;
+
+/// <summary>
+/// 1:1 direct messages. The MVP conversation list is sourced from
+/// GET /api/dm/recipients (people you can DM); message history comes from the
+/// per-user thread endpoint. NOTE: the POST /api/dm request body is undocumented
+/// in the OpenAPI spec, so <see cref="SendDmAsync"/> uses the inferred
+/// { recipientId, body } shape and is read-after-write — re-fetch the thread and
+/// verify the field names against a real send before depending on it.
+/// </summary>
+public sealed partial class InterlinedApiClient
+{
+    public async Task<List<DmRecipient>> GetDmRecipientsAsync(CancellationToken ct = default)
+    {
+        var json = await GetElementAsync("api/dm/recipients", ct);
+        return json.TryGetProperty("recipients", out var arr) && arr.ValueKind == JsonValueKind.Array
+            ? arr.Deserialize<List<DmRecipient>>(JsonOptions) ?? new()
+            : new();
+    }
+
+    public Task<DmThread> GetDmThreadAsync(string username, CancellationToken ct = default)
+        => GetJsonAsync<DmThread>($"api/dm/thread/{Uri.EscapeDataString(username)}", ct);
+
+    public async Task<int> GetDmUnreadCountAsync(CancellationToken ct = default)
+    {
+        var json = await GetElementAsync("api/dm/unread-count", ct);
+        return json.TryGetProperty("count", out var c) && c.TryGetInt32(out var n) ? n : 0;
+    }
+
+    public Task SendDmAsync(string recipientId, string body, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, "api/dm", new { recipientId, body }, ct);
+
+    public Task MarkDmReadAsync(string id, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/dm/{id}/read", new { }, ct);
+
+    public Task TrashDmAsync(string id, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/dm/{id}/trash", new { }, ct);
+}
diff --git a/InterlinedList/Services/InterlinedApiClient.Documents.cs b/InterlinedList/Services/InterlinedApiClient.Documents.cs
index 8a41816..6b83da8 100644
--- a/InterlinedList/Services/InterlinedApiClient.Documents.cs
+++ b/InterlinedList/Services/InterlinedApiClient.Documents.cs
@@ -75,4 +75,22 @@ public async Task CreateFromTemplateAsync(string templateDocumentId, Cancellatio
             new { templateDocumentId, targetFolderId = (string?)null }, ct);
         await EnsureSuccessAsync(resp, ct);
     }
+
+    // ── Folder management ───────────────────────────────────────────────────────
+    // GetDocumentFoldersAsync (above) already returns each folder with its
+    // embedded documents; these mutate the folder tree. Request shape { name,
+    // parentId } verified against the OpenAPI spec 2026-07-31.
+
+    public Task CreateDocumentFolderAsync(string name, string? parentId = null, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, "api/documents/folders", new { name, parentId }, ct);
+
+    public Task RenameDocumentFolderAsync(string id, string name, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Put, $"api/documents/folders/{id}", new { name }, ct);
+
+    public Task DeleteDocumentFolderAsync(string id, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/documents/folders/{id}", null, ct);
+
+    public Task CreateDocumentInFolderAsync(string folderId, string title, string content, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/documents/folders/{folderId}/documents",
+            new { title, content, isPublic = false }, ct);
 }
diff --git a/InterlinedList/Services/InterlinedApiClient.Exports.cs b/InterlinedList/Services/InterlinedApiClient.Exports.cs
new file mode 100644
index 0000000..e69eb55
--- /dev/null
+++ b/InterlinedList/Services/InterlinedApiClient.Exports.cs
@@ -0,0 +1,20 @@
+namespace InterlinedList.Services;
+
+/// <summary>
+/// CSV data exports. Each endpoint returns a raw text/csv body (verified live
+/// 2026-07-31) — callers write it straight to a user-chosen file.
+/// </summary>
+public sealed partial class InterlinedApiClient
+{
+    public Task<string> ExportMessagesCsvAsync(CancellationToken ct = default)
+        => GetStringAsync("api/exports/messages", ct);
+
+    public Task<string> ExportListsCsvAsync(CancellationToken ct = default)
+        => GetStringAsync("api/exports/lists", ct);
+
+    public Task<string> ExportListDataRowsCsvAsync(CancellationToken ct = default)
+        => GetStringAsync("api/exports/list-data-rows", ct);
+
+    public Task<string> ExportFollowsCsvAsync(CancellationToken ct = default)
+        => GetStringAsync("api/exports/follows", ct);
+}
diff --git a/InterlinedList/Services/InterlinedApiClient.Follow.cs b/InterlinedList/Services/InterlinedApiClient.Follow.cs
new file mode 100644
index 0000000..7b3d83c
--- /dev/null
+++ b/InterlinedList/Services/InterlinedApiClient.Follow.cs
@@ -0,0 +1,54 @@
+using System.Net.Http;
+using System.Text.Json;
+using InterlinedList.Models;
+
+namespace InterlinedList.Services;
+
+/// <summary>
+/// The social graph: follow/unfollow, pending follow requests (for private
+/// accounts), and follower/following/mutual lists. Follow counts live in the
+/// core partial (<see cref="GetFollowCountsAsync"/>). All of these accept the
+/// bearer token (verified live 2026-07-31).
+/// </summary>
+public sealed partial class InterlinedApiClient
+{
+    public Task FollowAsync(string userId, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/follow/{userId}", new { }, ct);
+
+    public Task UnfollowAsync(string userId, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/follow/{userId}", null, ct);
+
+    public Task<FollowStatus> GetFollowStatusAsync(string userId, CancellationToken ct = default)
+        => GetJsonAsync<FollowStatus>($"api/follow/{userId}/status", ct);
+
+    public Task<List<FollowUser>> GetFollowRequestsAsync(CancellationToken ct = default)
+        => GetUserArrayAsync("api/follow/requests", "requests", ct);
+
+    public Task ApproveFollowAsync(string userId, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/follow/{userId}/approve", new { }, ct);
+
+    public Task RejectFollowAsync(string userId, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/follow/{userId}/reject", new { }, ct);
+
+    public Task RemoveFollowerAsync(string userId, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/follow/{userId}/remove", null, ct);
+
+    public Task<List<FollowUser>> GetFollowersAsync(string userId, CancellationToken ct = default)
+        => GetUserArrayAsync($"api/follow/{userId}/followers", "followers", ct);
+
+    public Task<List<FollowUser>> GetFollowingAsync(string userId, CancellationToken ct = default)
+        => GetUserArrayAsync($"api/follow/{userId}/following", "following", ct);
+
+    public Task<List<FollowUser>> GetMutualAsync(string userId, CancellationToken ct = default)
+        => GetUserArrayAsync($"api/follow/{userId}/mutual", "mutual", ct);
+
+    // Follow lists wrap their array under different property names
+    // (requests/followers/following/mutual) — pull the named array, tolerate a miss.
+    private async Task<List<FollowUser>> GetUserArrayAsync(string path, string property, CancellationToken ct)
+    {
+        var json = await GetElementAsync(path, ct);
+        return json.TryGetProperty(property, out var arr) && arr.ValueKind == JsonValueKind.Array
+            ? arr.Deserialize<List<FollowUser>>(JsonOptions) ?? new()
+            : new();
+    }
+}
diff --git a/InterlinedList/Services/InterlinedApiClient.Lists.cs b/InterlinedList/Services/InterlinedApiClient.Lists.cs
index f06069d..89b9522 100644
--- a/InterlinedList/Services/InterlinedApiClient.Lists.cs
+++ b/InterlinedList/Services/InterlinedApiClient.Lists.cs
@@ -50,4 +50,24 @@ public async Task AddListRowAsync(string listId, Dictionary<string, object?> row
         using var resp = await SendAsync(HttpMethod.Post, $"api/lists/{listId}/data", new { data = rowData }, ct);
         await EnsureSuccessAsync(resp, ct);
     }
+
+    // GET /api/lists/{id} returns the list metadata under a "data" envelope
+    // (verified live 2026-07-31).
+    public async Task<ListSummary> GetListAsync(string listId, CancellationToken ct = default)
+    {
+        var json = await GetElementAsync($"api/lists/{listId}", ct);
+        return json.GetProperty("data").Deserialize<ListSummary>(JsonOptions)
+            ?? throw new InterlinedApiException(200, "GET /api/lists/{id} returned no data.");
+    }
+
+    public Task UpdateListAsync(string listId, string title, string? description, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Put, $"api/lists/{listId}", new { title, description }, ct);
+
+    // Edit/delete of an individual row — the pieces that made rows write-once
+    // before. Same read-after-write discipline as AddListRowAsync.
+    public Task UpdateListRowAsync(string listId, string rowId, Dictionary<string, object?> rowData, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Put, $"api/lists/{listId}/data/{rowId}", new { data = rowData }, ct);
+
+    public Task DeleteListRowAsync(string listId, string rowId, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/lists/{listId}/data/{rowId}", null, ct);
 }
diff --git a/InterlinedList/Services/InterlinedApiClient.Messages.cs b/InterlinedList/Services/InterlinedApiClient.Messages.cs
new file mode 100644
index 0000000..c0a3635
--- /dev/null
+++ b/InterlinedList/Services/InterlinedApiClient.Messages.cs
@@ -0,0 +1,60 @@
+using System.IO;
+using System.Net.Http;
+using System.Text.Json;
+using InterlinedList.Models;
+
+namespace InterlinedList.Services;
+
+/// <summary>
+/// Message depth beyond the feed: single-message detail, replies/threads,
+/// and edit/delete/report of a post. Replies are just POST /api/messages with a
+/// parentId (see <see cref="PostMessageAsync"/>). Edit/delete/report response
+/// envelopes aren't parsed — callers re-fetch (the codebase's read-after-write
+/// pattern) rather than trusting an unverified write body.
+/// </summary>
+public sealed partial class InterlinedApiClient
+{
+    public async Task<Message> GetMessageAsync(string id, CancellationToken ct = default)
+    {
+        // Detail is served either bare or wrapped as { "message": {...} } — accept both.
+        var root = await GetElementAsync($"api/messages/{id}", ct);
+        var el = root.TryGetProperty("message", out var wrapped) && wrapped.ValueKind == JsonValueKind.Object
+            ? wrapped
+            : root;
+        return el.Deserialize<Message>(JsonOptions)
+            ?? throw new InterlinedApiException(200, "GET /api/messages/{id} returned no message.");
+    }
+
+    public async Task<List<Message>> GetRepliesAsync(string id, CancellationToken ct = default)
+    {
+        var json = await GetElementAsync($"api/messages/{id}/replies", ct);
+        return json.TryGetProperty("replies", out var arr) && arr.ValueKind == JsonValueKind.Array
+            ? arr.Deserialize<List<Message>>(JsonOptions) ?? new()
+            : new();
+    }
+
+    public Task PostReplyAsync(string parentId, string content, bool publiclyVisible, CancellationToken ct = default)
+        => PostMessageAsync(content, publiclyVisible, parentId: parentId, ct: ct);
+
+    public Task EditMessageAsync(string id, string content, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Patch, $"api/messages/{id}", new { content }, ct);
+
+    public Task DeleteMessageAsync(string id, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/messages/{id}", null, ct);
+
+    public Task ReportMessageAsync(string id, string reason, string? detail, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/messages/{id}/report", new { reason, detail }, ct);
+
+    /// <summary>
+    /// Upload an image for a post; returns the hosted URL to pass back in the
+    /// message's imageUrls. multipart field "file", response { url } — both
+    /// verified live 2026-07-31. Subscriber-gated (402/403 for free accounts).
+    /// </summary>
+    public async Task<string> UploadMessageImageAsync(Stream content, string fileName, string contentType, CancellationToken ct = default)
+    {
+        var json = await SendMultipartAsync("api/messages/images/upload", content, fileName, contentType, ct: ct);
+        return json.TryGetProperty("url", out var url) && url.GetString() is { Length: > 0 } u
+            ? u
+            : throw new InterlinedApiException(200, "Image upload returned no url.");
+    }
+}
diff --git a/InterlinedList/Services/InterlinedApiClient.Moderation.cs b/InterlinedList/Services/InterlinedApiClient.Moderation.cs
new file mode 100644
index 0000000..49df5ad
--- /dev/null
+++ b/InterlinedList/Services/InterlinedApiClient.Moderation.cs
@@ -0,0 +1,56 @@
+using System.Net.Http;
+using System.Text.Json;
+using InterlinedList.Models;
+
+namespace InterlinedList.Services;
+
+/// <summary>
+/// Moderation & safety: block, mute, and report users (report-a-message lives in
+/// the Messages partial). Status probes read the { "blocked": bool } /
+/// { "muted": bool } shapes verified live 2026-07-31. All accept the bearer token.
+/// </summary>
+public sealed partial class InterlinedApiClient
+{
+    public Task BlockUserAsync(string username, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/users/{Uri.EscapeDataString(username)}/block", new { }, ct);
+
+    public Task UnblockUserAsync(string username, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/users/{Uri.EscapeDataString(username)}/block", null, ct);
+
+    public async Task<bool> IsBlockingAsync(string username, CancellationToken ct = default)
+    {
+        var json = await GetElementAsync($"api/users/{Uri.EscapeDataString(username)}/block", ct);
+        return json.TryGetProperty("blocked", out var b) && b.ValueKind == JsonValueKind.True;
+    }
+
+    public Task MuteUserAsync(string username, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/users/{Uri.EscapeDataString(username)}/mute", new { }, ct);
+
+    public Task UnmuteUserAsync(string username, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/users/{Uri.EscapeDataString(username)}/mute", null, ct);
+
+    public async Task<bool> IsMutingAsync(string username, CancellationToken ct = default)
+    {
+        var json = await GetElementAsync($"api/users/{Uri.EscapeDataString(username)}/mute", ct);
+        return json.TryGetProperty("muted", out var m) && m.ValueKind == JsonValueKind.True;
+    }
+
+    public Task ReportUserAsync(string username, string reason, string? detail, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/users/{Uri.EscapeDataString(username)}/report", new { reason, detail }, ct);
+
+    public async Task<List<ModeratedUser>> GetBlockedUsersAsync(CancellationToken ct = default)
+    {
+        var json = await GetElementAsync("api/user/blocks", ct);
+        return json.TryGetProperty("blockedUsers", out var arr) && arr.ValueKind == JsonValueKind.Array
+            ? arr.Deserialize<List<ModeratedUser>>(JsonOptions) ?? new()
+            : new();
+    }
+
+    public async Task<List<ModeratedUser>> GetMutedUsersAsync(CancellationToken ct = default)
+    {
+        var json = await GetElementAsync("api/user/mutes", ct);
+        return json.TryGetProperty("mutedUsers", out var arr) && arr.ValueKind == JsonValueKind.Array
+            ? arr.Deserialize<List<ModeratedUser>>(JsonOptions) ?? new()
+            : new();
+    }
+}
diff --git a/InterlinedList/Services/InterlinedApiClient.Organizations.cs b/InterlinedList/Services/InterlinedApiClient.Organizations.cs
index 8c7a93c..afb6121 100644
--- a/InterlinedList/Services/InterlinedApiClient.Organizations.cs
+++ b/InterlinedList/Services/InterlinedApiClient.Organizations.cs
@@ -6,10 +6,11 @@
 namespace InterlinedList.Services;
 
 /// <summary>
-/// Only the top-level organization endpoints (list/get/create) are wired up
-/// here — GET api/organizations/{id}/members returned 401 with this app's
-/// bearer-token auth during live testing, so member-list/management is
-/// deliberately not implemented anywhere in this client.
+/// Organizations: browse (list/get/create) plus full member management. NOTE:
+/// GET api/organizations/{id}/members was previously documented as 401-walled
+/// for bearer auth, but re-probing live 2026-07-31 it (and add/update/remove)
+/// return 200 with the sync-token — so member management IS implemented now.
+/// Member mutations follow the read-after-write pattern (re-fetch members after).
 /// </summary>
 public sealed partial class InterlinedApiClient
 {
@@ -46,4 +47,30 @@ public async Task CreateOrganizationAsync(string name, string? description, bool
         using var resp = await SendAsync(HttpMethod.Post, "api/organizations", new { name, description, isPublic }, ct);
         await EnsureSuccessAsync(resp, ct);
     }
+
+    public Task UpdateOrganizationAsync(string orgId, string name, string? description, bool isPublic, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Put, $"api/organizations/{orgId}", new { name, description, isPublic }, ct);
+
+    public Task DeleteOrganizationAsync(string orgId, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/organizations/{orgId}", null, ct);
+
+    // ── Member management (bearer-authorized as of 2026-07-31) ──────────────────
+
+    public async Task<List<OrgMember>> GetOrgMembersAsync(string orgId, CancellationToken ct = default)
+    {
+        var json = await GetElementAsync($"api/organizations/{orgId}/members", ct);
+        return json.TryGetProperty("members", out var arr) && arr.ValueKind == JsonValueKind.Array
+            ? arr.Deserialize<List<OrgMember>>(JsonOptions) ?? new()
+            : new();
+    }
+
+    // Add an existing user (found via the global user search) to the org.
+    public Task AddOrgMemberAsync(string orgId, string userId, string role, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Post, $"api/organizations/{orgId}/members", new { userId, role }, ct);
+
+    public Task UpdateOrgMemberRoleAsync(string orgId, string userId, string role, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Put, $"api/organizations/{orgId}/members/{userId}", new { role }, ct);
+
+    public Task RemoveOrgMemberAsync(string orgId, string userId, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/organizations/{orgId}/members/{userId}", null, ct);
 }
diff --git a/InterlinedList/Services/InterlinedApiClient.People.cs b/InterlinedList/Services/InterlinedApiClient.People.cs
new file mode 100644
index 0000000..cebdfaa
--- /dev/null
+++ b/InterlinedList/Services/InterlinedApiClient.People.cs
@@ -0,0 +1,20 @@
+using InterlinedList.Models;
+
+namespace InterlinedList.Services;
+
+/// <summary>
+/// People: a user's public profile and their public content. Relationship state
+/// (follow / block / mute) is NOT on the profile payload — read it from the
+/// follow-status and moderation endpoints (see the Follow/Moderation partials).
+/// </summary>
+public sealed partial class InterlinedApiClient
+{
+    public Task<UserProfile> GetProfileAsync(string username, CancellationToken ct = default)
+        => GetJsonAsync<UserProfile>($"api/users/{Uri.EscapeDataString(username)}", ct);
+
+    public Task<MessagesPage> GetUserMessagesAsync(string username, int limit = 20, int offset = 0, CancellationToken ct = default)
+        => GetJsonAsync<MessagesPage>($"api/user/{Uri.EscapeDataString(username)}/messages?limit={limit}&offset={offset}", ct);
+
+    public Task<ListsPage> GetUserListsAsync(string username, CancellationToken ct = default)
+        => GetJsonAsync<ListsPage>($"api/users/{Uri.EscapeDataString(username)}/lists", ct);
+}
diff --git a/InterlinedList/Services/InterlinedApiClient.cs b/InterlinedList/Services/InterlinedApiClient.cs
index 6614acf..c5ce42f 100644
--- a/InterlinedList/Services/InterlinedApiClient.cs
+++ b/InterlinedList/Services/InterlinedApiClient.cs
@@ -1,3 +1,4 @@
+using System.IO;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.Http.Json;
@@ -61,16 +62,27 @@ public async Task PostMessageAsync(
         bool publiclyVisible,
         bool crossPostToBluesky = false,
         bool crossPostToTwitter = false,
+        bool crossPostToLinkedIn = false,
         string? mastodonProviderIds = null,
+        string? parentId = null,
+        DateTimeOffset? scheduledAt = null,
+        IReadOnlyList<string>? imageUrls = null,
         CancellationToken ct = default)
     {
+        // parentId turns this into a reply; scheduledAt defers publication;
+        // imageUrls attaches already-uploaded images. All are documented request
+        // fields on POST /api/messages (OpenAPI-verified).
         using var resp = await SendAsync(HttpMethod.Post, "api/messages", new
         {
             content,
             publiclyVisible,
             crossPostToBluesky,
             crossPostToTwitter,
-            mastodonProviderIds
+            crossPostToLinkedIn,
+            mastodonProviderIds,
+            parentId,
+            scheduledAt = scheduledAt?.UtcDateTime,
+            imageUrls
         }, ct);
         await EnsureSuccessAsync(resp, ct);
     }
@@ -101,6 +113,12 @@ public async Task MarkAllNotificationsReadAsync(CancellationToken ct = default)
         await EnsureSuccessAsync(resp, ct);
     }
 
+    public Task MarkNotificationReadAsync(string id, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Patch, $"api/notifications/{id}/read", new { }, ct);
+
+    public Task DeleteNotificationAsync(string id, CancellationToken ct = default)
+        => SendVoidAsync(HttpMethod.Delete, $"api/notifications/{id}", null, ct);
+
     public async Task<FollowCounts> GetFollowCountsAsync(string userId, CancellationToken ct = default)
     {
         using var resp = await SendAsync(HttpMethod.Get, $"api/follow/{userId}/counts", body: null, ct);
@@ -109,6 +127,76 @@ public async Task<FollowCounts> GetFollowCountsAsync(string userId, Cancellation
             ?? throw new InterlinedApiException((int)resp.StatusCode, "GET /api/follow/{id}/counts returned no body.");
     }
 
+    // ── Shared JSON plumbing (Phase 0) ──────────────────────────────────────────
+    // New domain partials build on these instead of re-hand-rolling the
+    // SendAsync → EnsureSuccess → ReadFromJson dance. Two write helpers exist by
+    // design: SendJsonAsync<T> for live-verified response envelopes, and
+    // SendVoidAsync for the codebase's read-after-write pattern (mutations whose
+    // body shape isn't trusted — the caller re-fetches from a GET afterward).
+
+    private async Task<T> GetJsonAsync<T>(string path, CancellationToken ct)
+    {
+        using var resp = await SendAsync(HttpMethod.Get, path, body: null, ct);
+        await EnsureSuccessAsync(resp, ct);
+        return await resp.Content.ReadFromJsonAsync<T>(JsonOptions, ct)
+            ?? throw new InterlinedApiException((int)resp.StatusCode, $"GET {path} returned no body.");
+    }
+
+    /// <summary>Read an endpoint that wraps its payload under a property (e.g. { "lists": [...] }).</summary>
+    private async Task<JsonElement> GetElementAsync(string path, CancellationToken ct)
+    {
+        using var resp = await SendAsync(HttpMethod.Get, path, body: null, ct);
+        await EnsureSuccessAsync(resp, ct);
+        return await resp.Content.ReadFromJsonAsync<JsonElement>(JsonOptions, ct);
+    }
+
+    /// <summary>Raw text body — used for CSV export endpoints.</summary>
+    private async Task<string> GetStringAsync(string path, CancellationToken ct)
+    {
+        using var resp = await SendAsync(HttpMethod.Get, path, body: null, ct);
+        await EnsureSuccessAsync(resp, ct);
+        return await resp.Content.ReadAsStringAsync(ct);
+    }
+
+    /// <summary>
+    /// multipart/form-data upload. The field name is "file" and the response is
+    /// { "url": "..." } for the image endpoints (verified live 2026-07-31).
+    /// Returns the root JSON element so callers can pull whatever key they need.
+    /// </summary>
+    private async Task<JsonElement> SendMultipartAsync(
+        string path, Stream content, string fileName, string contentType,
+        string fieldName = "file", CancellationToken ct = default)
+    {
+        using var form = new MultipartFormDataContent();
+        var fileContent = new StreamContent(content);
+        fileContent.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+        form.Add(fileContent, fieldName, fileName);
+
+        using var request = new HttpRequestMessage(HttpMethod.Post, path) { Content = form };
+        if (AccessToken is { Length: > 0 })
+            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
+
+        using var resp = await _http.SendAsync(request, ct);
+        await EnsureSuccessAsync(resp, ct);
+        return await resp.Content.ReadFromJsonAsync<JsonElement>(JsonOptions, ct);
+    }
+
+    /// <summary>Mutating call whose response body we don't parse (read-after-write pattern).</summary>
+    private async Task SendVoidAsync(HttpMethod method, string path, object? body, CancellationToken ct)
+    {
+        using var resp = await SendAsync(method, path, body, ct);
+        await EnsureSuccessAsync(resp, ct);
+    }
+
+    /// <summary>Mutating call whose response envelope IS live-verified and deserialized.</summary>
+    private async Task<T> SendJsonAsync<T>(HttpMethod method, string path, object? body, CancellationToken ct)
+    {
+        using var resp = await SendAsync(method, path, body, ct);
+        await EnsureSuccessAsync(resp, ct);
+        return await resp.Content.ReadFromJsonAsync<T>(JsonOptions, ct)
+            ?? throw new InterlinedApiException((int)resp.StatusCode, $"{method} {path} returned no body.");
+    }
+
     private async Task<HttpResponseMessage> SendAsync(HttpMethod method, string path, object? body, CancellationToken ct)
     {
         using var request = new HttpRequestMessage(method, path);
diff --git a/InterlinedList/Services/Navigator.cs b/InterlinedList/Services/Navigator.cs
new file mode 100644
index 0000000..5e05305
--- /dev/null
+++ b/InterlinedList/Services/Navigator.cs
@@ -0,0 +1,18 @@
+namespace InterlinedList.Services;
+
+/// <summary>
+/// Tiny in-process navigation hub. Lets a feed/search card ask the shell to open
+/// a user's profile without holding a reference to MainWindow. A single settable
+/// callback (not a multicast event) so re-creating the shell on re-login simply
+/// replaces the handler instead of stacking duplicates.
+/// </summary>
+public static class Navigator
+{
+    public static Action<string>? OnOpenProfile { get; set; }
+
+    public static void OpenProfile(string username)
+    {
+        if (!string.IsNullOrWhiteSpace(username))
+            OnOpenProfile?.Invoke(username);
+    }
+}
diff --git a/InterlinedList/ViewModels/DirectMessagesViewModel.cs b/InterlinedList/ViewModels/DirectMessagesViewModel.cs
new file mode 100644
index 0000000..9f07584
--- /dev/null
+++ b/InterlinedList/ViewModels/DirectMessagesViewModel.cs
@@ -0,0 +1,129 @@
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using InterlinedList.Models;
+using InterlinedList.Services;
+
+namespace InterlinedList.ViewModels;
+
+public partial class DirectMessagesViewModel : ObservableObject
+{
+    private readonly SessionService _session;
+
+    public ObservableCollection<DmRecipient> Recipients { get; } = new();
+    public ObservableCollection<DmMessageViewModel> Messages { get; } = new();
+
+    [ObservableProperty]
+    private DmRecipient? selectedRecipient;
+
+    [ObservableProperty]
+    private string composeText = "";
+
+    [ObservableProperty]
+    private bool isLoading;
+
+    [ObservableProperty]
+    private bool isSending;
+
+    [ObservableProperty]
+    private string? errorMessage;
+
+    public bool HasSelection => SelectedRecipient is not null;
+
+    public DirectMessagesViewModel(SessionService session)
+    {
+        _session = session;
+    }
+
+    [RelayCommand]
+    private async Task LoadAsync()
+    {
+        IsLoading = true;
+        try
+        {
+            var recipients = await _session.Api.GetDmRecipientsAsync();
+
+            Recipients.Clear();
+            foreach (var recipient in recipients)
+                Recipients.Add(recipient);
+
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task SelectRecipientAsync(DmRecipient recipient)
+    {
+        SelectedRecipient = recipient;
+        await LoadThreadAsync(recipient);
+    }
+
+    private async Task LoadThreadAsync(DmRecipient recipient)
+    {
+        IsLoading = true;
+        try
+        {
+            var currentUserId = _session.CurrentUser?.Id;
+            var thread = await _session.Api.GetDmThreadAsync(recipient.Username);
+
+            Messages.Clear();
+            foreach (var message in thread.Items)
+                Messages.Add(new DmMessageViewModel(message, currentUserId));
+
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    private bool CanSend() =>
+        HasSelection && !IsSending && !string.IsNullOrWhiteSpace(ComposeText);
+
+    // SendDmAsync doesn't return a parsed message body (see
+    // InterlinedApiClient.DirectMessages.cs), so re-fetch the thread after sending.
+    [RelayCommand(CanExecute = nameof(CanSend))]
+    private async Task SendAsync()
+    {
+        if (SelectedRecipient is not { } recipient)
+            return;
+
+        IsSending = true;
+        try
+        {
+            await _session.Api.SendDmAsync(recipient.Id, ComposeText.Trim());
+            ComposeText = "";
+            await LoadThreadAsync(recipient);
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsSending = false;
+        }
+    }
+
+    partial void OnSelectedRecipientChanged(DmRecipient? value)
+    {
+        OnPropertyChanged(nameof(HasSelection));
+        SendCommand.NotifyCanExecuteChanged();
+    }
+
+    partial void OnComposeTextChanged(string value) => SendCommand.NotifyCanExecuteChanged();
+    partial void OnIsSendingChanged(bool value) => SendCommand.NotifyCanExecuteChanged();
+}
diff --git a/InterlinedList/ViewModels/DmMessageViewModel.cs b/InterlinedList/ViewModels/DmMessageViewModel.cs
new file mode 100644
index 0000000..0356ea6
--- /dev/null
+++ b/InterlinedList/ViewModels/DmMessageViewModel.cs
@@ -0,0 +1,23 @@
+using InterlinedList.Models;
+
+namespace InterlinedList.ViewModels;
+
+/// <summary>
+/// Read-only wrapper around a single <see cref="DirectMessage"/> for the DM
+/// thread list. Plain properties are enough — a message never mutates in place;
+/// the whole collection is rebuilt on each thread (re-)load.
+/// </summary>
+public sealed class DmMessageViewModel
+{
+    private readonly DirectMessage _message;
+
+    public DmMessageViewModel(DirectMessage message, string? currentUserId)
+    {
+        _message = message;
+        IsMine = message.SenderId == currentUserId;
+    }
+
+    public string Body => _message.Body;
+    public string TimeFormatted => _message.TimeFormatted;
+    public bool IsMine { get; }
+}
diff --git a/InterlinedList/ViewModels/DocumentsViewModel.cs b/InterlinedList/ViewModels/DocumentsViewModel.cs
index cbc10e4..4aa2c97 100644
--- a/InterlinedList/ViewModels/DocumentsViewModel.cs
+++ b/InterlinedList/ViewModels/DocumentsViewModel.cs
@@ -35,6 +35,24 @@ public partial class DocumentsViewModel : ObservableObject
     [ObservableProperty]
     private string editContent = "";
 
+    // ── Folder management ─────────────────────────────────────────
+    [ObservableProperty]
+    private string newFolderName = "";
+
+    // The folder currently being renamed inline (null when no inline editor is open).
+    [ObservableProperty]
+    private DocumentFolder? editingFolder;
+
+    [ObservableProperty]
+    private string editingFolderName = "";
+
+    // The folder currently receiving a new document inline (null when closed).
+    [ObservableProperty]
+    private DocumentFolder? addingDocFolder;
+
+    [ObservableProperty]
+    private string newFolderDocTitle = "";
+
     public DocumentsViewModel(SessionService session)
     {
         _session = session;
@@ -156,7 +174,132 @@ private async Task UseTemplateAsync(DocumentTemplate template)
         }
     }
 
+    // ── Folder management commands ────────────────────────────────
+
+    private bool CanCreateFolder() => !string.IsNullOrWhiteSpace(NewFolderName);
+
+    [RelayCommand(CanExecute = nameof(CanCreateFolder))]
+    private async Task CreateFolderAsync()
+    {
+        try
+        {
+            await _session.Api.CreateDocumentFolderAsync(NewFolderName.Trim());
+            NewFolderName = "";
+            ErrorMessage = null;
+            await LoadAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private void StartRenameFolder(DocumentFolder folder)
+    {
+        EditingFolder = folder;
+        EditingFolderName = folder.Name;
+    }
+
+    [RelayCommand]
+    private void CancelRenameFolder()
+    {
+        EditingFolder = null;
+        EditingFolderName = "";
+    }
+
+    private bool CanSaveRenameFolder() => EditingFolder is not null && !string.IsNullOrWhiteSpace(EditingFolderName);
+
+    [RelayCommand(CanExecute = nameof(CanSaveRenameFolder))]
+    private async Task SaveRenameFolderAsync()
+    {
+        if (EditingFolder is not { } folder) return;
+
+        try
+        {
+            await _session.Api.RenameDocumentFolderAsync(folder.Id, EditingFolderName.Trim());
+            EditingFolder = null;
+            EditingFolderName = "";
+            ErrorMessage = null;
+            await LoadAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task DeleteFolderAsync(DocumentFolder folder)
+    {
+        try
+        {
+            await _session.Api.DeleteDocumentFolderAsync(folder.Id);
+            if (EditingFolder == folder)
+            {
+                EditingFolder = null;
+                EditingFolderName = "";
+            }
+            if (AddingDocFolder == folder)
+            {
+                AddingDocFolder = null;
+                NewFolderDocTitle = "";
+            }
+            ErrorMessage = null;
+            await LoadAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private void StartAddDocToFolder(DocumentFolder folder)
+    {
+        AddingDocFolder = folder;
+        NewFolderDocTitle = "";
+    }
+
+    [RelayCommand]
+    private void CancelAddDocToFolder()
+    {
+        AddingDocFolder = null;
+        NewFolderDocTitle = "";
+    }
+
+    private bool CanSaveDocToFolder() => AddingDocFolder is not null && !string.IsNullOrWhiteSpace(NewFolderDocTitle);
+
+    [RelayCommand(CanExecute = nameof(CanSaveDocToFolder))]
+    private async Task SaveDocToFolderAsync()
+    {
+        if (AddingDocFolder is not { } folder) return;
+
+        try
+        {
+            await _session.Api.CreateDocumentInFolderAsync(folder.Id, NewFolderDocTitle.Trim(), "");
+            AddingDocFolder = null;
+            NewFolderDocTitle = "";
+            ErrorMessage = null;
+            await LoadAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
     partial void OnNewDocTitleChanged(string value) => CreateDocumentCommand.NotifyCanExecuteChanged();
 
     partial void OnSelectedDocumentChanged(DocumentSummary? value) => SaveDocumentCommand.NotifyCanExecuteChanged();
+
+    partial void OnNewFolderNameChanged(string value) => CreateFolderCommand.NotifyCanExecuteChanged();
+
+    partial void OnEditingFolderChanged(DocumentFolder? value) => SaveRenameFolderCommand.NotifyCanExecuteChanged();
+
+    partial void OnEditingFolderNameChanged(string value) => SaveRenameFolderCommand.NotifyCanExecuteChanged();
+
+    partial void OnAddingDocFolderChanged(DocumentFolder? value) => SaveDocToFolderCommand.NotifyCanExecuteChanged();
+
+    partial void OnNewFolderDocTitleChanged(string value) => SaveDocToFolderCommand.NotifyCanExecuteChanged();
 }
diff --git a/InterlinedList/ViewModels/FeedViewModel.cs b/InterlinedList/ViewModels/FeedViewModel.cs
index 03900d4..0e163a9 100644
--- a/InterlinedList/ViewModels/FeedViewModel.cs
+++ b/InterlinedList/ViewModels/FeedViewModel.cs
@@ -1,7 +1,9 @@
 using System.Collections.ObjectModel;
+using System.IO;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using InterlinedList.Services;
+using Microsoft.Win32;
 
 namespace InterlinedList.ViewModels;
 
@@ -52,11 +54,60 @@ public partial class FeedViewModel : ObservableObject
     [ObservableProperty]
     private bool crossPostToMastodon;
 
+    // Images uploaded for the next post (URLs returned by the upload endpoint).
+    public ObservableCollection<string> AttachedImageUrls { get; } = new();
+
+    [ObservableProperty]
+    private bool isUploadingImage;
+
     public FeedViewModel(SessionService session)
     {
         _session = session;
+        AttachedImageUrls.CollectionChanged += (_, _) => PostCommand.NotifyCanExecuteChanged();
     }
 
+    [RelayCommand]
+    private async Task AttachImageAsync()
+    {
+        var dlg = new OpenFileDialog
+        {
+            Filter = "Images (*.png;*.jpg;*.jpeg;*.gif;*.webp)|*.png;*.jpg;*.jpeg;*.gif;*.webp",
+            Multiselect = false
+        };
+        if (dlg.ShowDialog() != true) return;
+
+        IsUploadingImage = true;
+        try
+        {
+            var contentType = Path.GetExtension(dlg.FileName).ToLowerInvariant() switch
+            {
+                ".png" => "image/png",
+                ".gif" => "image/gif",
+                ".webp" => "image/webp",
+                _ => "image/jpeg",
+            };
+            await using var stream = File.OpenRead(dlg.FileName);
+            var url = await _session.Api.UploadMessageImageAsync(stream, Path.GetFileName(dlg.FileName), contentType);
+            AttachedImageUrls.Add(url);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        catch (IOException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsUploadingImage = false;
+        }
+    }
+
+    [RelayCommand]
+    private void RemoveAttachment(string url) => AttachedImageUrls.Remove(url);
+
     [RelayCommand]
     private async Task LoadCrossPostOptionsAsync()
     {
@@ -127,7 +178,7 @@ private async Task LoadMoreAsync()
         }
     }
 
-    private bool CanPost() => !IsPosting && !string.IsNullOrWhiteSpace(ComposeText);
+    private bool CanPost() => !IsPosting && (!string.IsNullOrWhiteSpace(ComposeText) || AttachedImageUrls.Count > 0);
 
     [RelayCommand(CanExecute = nameof(CanPost))]
     private async Task PostAsync()
@@ -140,11 +191,13 @@ await _session.Api.PostMessageAsync(
                 _session.CurrentUser?.DefaultPubliclyVisible ?? true,
                 crossPostToBluesky: CrossPostToBluesky,
                 crossPostToTwitter: CrossPostToTwitter,
-                mastodonProviderIds: CrossPostToMastodon ? MastodonProvider : null);
+                mastodonProviderIds: CrossPostToMastodon ? MastodonProvider : null,
+                imageUrls: AttachedImageUrls.Count > 0 ? AttachedImageUrls.ToList() : null);
             ComposeText = "";
             CrossPostToBluesky = false;
             CrossPostToTwitter = false;
             CrossPostToMastodon = false;
+            AttachedImageUrls.Clear();
             await RefreshAsync();
         }
         catch (InterlinedApiException ex)
diff --git a/InterlinedList/ViewModels/ListsViewModel.cs b/InterlinedList/ViewModels/ListsViewModel.cs
index dc90a9c..7477aa2 100644
--- a/InterlinedList/ViewModels/ListsViewModel.cs
+++ b/InterlinedList/ViewModels/ListsViewModel.cs
@@ -40,6 +40,17 @@ public partial class ListsViewModel : ObservableObject
     [ObservableProperty]
     private string? rowErrorMessage;
 
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsEditingRow))]
+    private ListDataRow? editingRow;
+
+    [ObservableProperty]
+    private string editRowJson = "";
+
+    public bool IsEditingRow => EditingRow is not null;
+
+    private static readonly JsonSerializerOptions RowEditJsonOptions = new() { WriteIndented = true };
+
     public ListsViewModel(SessionService session)
     {
         _session = session;
@@ -169,6 +180,67 @@ private async Task AddRowAsync()
         }
     }
 
+    [RelayCommand]
+    private void StartEditRow(ListDataRow row)
+    {
+        EditingRow = row;
+        EditRowJson = JsonSerializer.Serialize(row.RowData, RowEditJsonOptions);
+        RowErrorMessage = null;
+    }
+
+    [RelayCommand]
+    private void CancelEditRow()
+    {
+        EditingRow = null;
+        EditRowJson = "";
+    }
+
+    [RelayCommand]
+    private async Task SaveRowEditAsync()
+    {
+        if (SelectedList is not { } list || EditingRow is not { } row) return;
+
+        Dictionary<string, object?> parsed;
+        try
+        {
+            parsed = JsonSerializer.Deserialize<Dictionary<string, object?>>(EditRowJson)
+                ?? new Dictionary<string, object?>();
+        }
+        catch (JsonException)
+        {
+            RowErrorMessage = "That's not valid JSON.";
+            return;
+        }
+
+        try
+        {
+            await _session.Api.UpdateListRowAsync(list.Id, row.Id, parsed);
+            EditingRow = null;
+            EditRowJson = "";
+            RowErrorMessage = null;
+            await LoadRowsAsync(list);
+        }
+        catch (InterlinedApiException ex)
+        {
+            RowErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task DeleteRowAsync(ListDataRow row)
+    {
+        if (SelectedList is not { } list) return;
+        try
+        {
+            await _session.Api.DeleteListRowAsync(list.Id, row.Id);
+            await LoadRowsAsync(list);
+        }
+        catch (InterlinedApiException ex)
+        {
+            RowErrorMessage = ex.Message;
+        }
+    }
+
     partial void OnNewListTitleChanged(string value) => CreateListCommand.NotifyCanExecuteChanged();
 
     partial void OnSelectedListChanged(ListSummary? value) => AddRowCommand.NotifyCanExecuteChanged();
diff --git a/InterlinedList/ViewModels/MessageItemViewModel.cs b/InterlinedList/ViewModels/MessageItemViewModel.cs
index dd6fa7a..cd1f081 100644
--- a/InterlinedList/ViewModels/MessageItemViewModel.cs
+++ b/InterlinedList/ViewModels/MessageItemViewModel.cs
@@ -1,3 +1,4 @@
+using System.Collections.ObjectModel;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using InterlinedList.Models;
@@ -8,19 +9,33 @@ namespace InterlinedList.ViewModels;
 /// <summary>
 /// Wraps a single Message for display/interaction in the feed. DigCount/DugByMe
 /// are mutable, observable copies (the underlying Message is immutable) so the
-/// Dig command can update them optimistically.
+/// Dig command can update them optimistically. Content is observable too, so an
+/// in-place edit reflects immediately. Edit/Delete/Report/Reply follow the
+/// codebase's read-after-write discipline — the server write is fire-then-trust
+/// for text (edit) or re-fetch (replies).
 /// </summary>
 public partial class MessageItemViewModel : ObservableObject
 {
     private readonly InterlinedApiClient _api;
+    private readonly string? _currentUserId;
+    private readonly bool _publiclyVisible;
 
     public string Id { get; }
-    public string Content { get; }
     public string TimeFormatted { get; }
     public string AuthorDisplayName { get; }
     public string AuthorHandle { get; }
+    public string? AuthorUsername { get; }
     public string? AvatarUrl { get; }
     public bool IsMine { get; }
+    public bool CanReport => !IsMine;
+
+    public IReadOnlyList<string> ImageUrls { get; }
+    public bool HasImages => ImageUrls.Count > 0;
+
+    public ObservableCollection<MessageItemViewModel> Replies { get; } = new();
+
+    [ObservableProperty]
+    private string content;
 
     [ObservableProperty]
     private int digCount;
@@ -31,20 +46,42 @@ public partial class MessageItemViewModel : ObservableObject
     [ObservableProperty]
     private bool isBusy;
 
+    [ObservableProperty]
+    private bool isDeleted;
+
+    [ObservableProperty]
+    private bool isEditing;
+
+    [ObservableProperty]
+    private string editText = "";
+
+    [ObservableProperty]
+    private bool areRepliesVisible;
+
+    [ObservableProperty]
+    private bool isComposingReply;
+
+    [ObservableProperty]
+    private string replyText = "";
+
     [ObservableProperty]
     private string? errorMessage;
 
     public MessageItemViewModel(Message message, InterlinedApiClient api, string? currentUserId)
     {
         _api = api;
+        _currentUserId = currentUserId;
+        _publiclyVisible = message.PubliclyVisible;
 
         Id = message.Id;
-        Content = message.Content;
+        content = message.Content;
         TimeFormatted = message.TimeFormatted;
         AuthorDisplayName = message.AuthorDisplayName;
         AuthorHandle = message.AuthorHandle;
+        AuthorUsername = message.User?.Username;
         AvatarUrl = message.User?.Avatar;
         IsMine = message.UserId == currentUserId;
+        ImageUrls = message.ImageUrls ?? new List<string>();
 
         digCount = message.DigCount;
         dugByMe = message.DugByMe;
@@ -91,4 +128,134 @@ private async Task DigAsync()
             IsBusy = false;
         }
     }
+
+    // ── Edit (own message) ──────────────────────────────────────────────────────
+
+    [RelayCommand]
+    private void StartEdit()
+    {
+        EditText = Content;
+        IsEditing = true;
+    }
+
+    [RelayCommand]
+    private void CancelEdit() => IsEditing = false;
+
+    private bool CanSaveEdit() => !string.IsNullOrWhiteSpace(EditText);
+
+    [RelayCommand(CanExecute = nameof(CanSaveEdit))]
+    private async Task SaveEditAsync()
+    {
+        try
+        {
+            var text = EditText.Trim();
+            await _api.EditMessageAsync(Id, text);
+            Content = text;
+            IsEditing = false;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    // ── Delete (own message) ────────────────────────────────────────────────────
+
+    [RelayCommand]
+    private async Task DeleteAsync()
+    {
+        try
+        {
+            await _api.DeleteMessageAsync(Id);
+            IsDeleted = true; // the card collapses via a DataTrigger
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    // ── Report (someone else's message) ─────────────────────────────────────────
+
+    [RelayCommand]
+    private async Task ReportAsync()
+    {
+        try
+        {
+            await _api.ReportMessageAsync(Id, "other", null);
+            ErrorMessage = "Reported. Thanks — our team will take a look.";
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    // ── Replies / thread ────────────────────────────────────────────────────────
+
+    [RelayCommand]
+    private async Task ToggleRepliesAsync()
+    {
+        if (AreRepliesVisible)
+        {
+            AreRepliesVisible = false;
+            return;
+        }
+
+        try
+        {
+            var replies = await _api.GetRepliesAsync(Id);
+            Replies.Clear();
+            foreach (var reply in replies)
+                Replies.Add(new MessageItemViewModel(reply, _api, _currentUserId));
+            AreRepliesVisible = true;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private void StartReply() => IsComposingReply = true;
+
+    [RelayCommand]
+    private void CancelReply()
+    {
+        IsComposingReply = false;
+        ReplyText = "";
+    }
+
+    private bool CanPostReply() => !string.IsNullOrWhiteSpace(ReplyText);
+
+    [RelayCommand(CanExecute = nameof(CanPostReply))]
+    private async Task PostReplyAsync()
+    {
+        try
+        {
+            await _api.PostReplyAsync(Id, ReplyText.Trim(), _publiclyVisible);
+            ReplyText = "";
+            IsComposingReply = false;
+
+            var replies = await _api.GetRepliesAsync(Id);
+            Replies.Clear();
+            foreach (var reply in replies)
+                Replies.Add(new MessageItemViewModel(reply, _api, _currentUserId));
+            AreRepliesVisible = true;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private void OpenAuthor()
+    {
+        if (!string.IsNullOrEmpty(AuthorUsername))
+            Navigator.OpenProfile(AuthorUsername);
+    }
+
+    partial void OnEditTextChanged(string value) => SaveEditCommand.NotifyCanExecuteChanged();
+    partial void OnReplyTextChanged(string value) => PostReplyCommand.NotifyCanExecuteChanged();
 }
diff --git a/InterlinedList/ViewModels/NotificationPrefViewModel.cs b/InterlinedList/ViewModels/NotificationPrefViewModel.cs
new file mode 100644
index 0000000..6054b75
--- /dev/null
+++ b/InterlinedList/ViewModels/NotificationPrefViewModel.cs
@@ -0,0 +1,58 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using InterlinedList.Models;
+using InterlinedList.Services;
+
+namespace InterlinedList.ViewModels;
+
+/// <summary>
+/// Item view model for a single notification preference row. Two-way binding on
+/// <see cref="Push"/> / <see cref="InApp"/> drives a fire-and-forget PATCH to the
+/// API. Reentrancy during the initial ctor assignment is guarded by
+/// <c>_loaded</c> so setting the initial channel state doesn't immediately POST.
+/// </summary>
+public partial class NotificationPrefViewModel : ObservableObject
+{
+    private readonly SessionService _session;
+    private readonly bool _loaded;
+
+    public string Key { get; }
+    public string Label { get; }
+    public string? Description { get; }
+
+    [ObservableProperty]
+    private bool push;
+
+    [ObservableProperty]
+    private bool inApp;
+
+    public NotificationPrefViewModel(NotificationPreference pref, SessionService session)
+    {
+        _session = session;
+        Key = pref.Key;
+        Label = pref.Label;
+        Description = pref.Description;
+        push = pref.Channels.Push;
+        inApp = pref.Channels.InApp;
+        _loaded = true;
+    }
+
+    partial void OnPushChanged(bool value) => Persist();
+
+    partial void OnInAppChanged(bool value) => Persist();
+
+    private async void Persist()
+    {
+        if (!_loaded)
+            return;
+
+        try
+        {
+            await _session.Api.SetNotificationPreferenceAsync(Key, Push, InApp);
+        }
+        catch (InterlinedApiException)
+        {
+            // Non-critical — a failed toggle just isn't persisted; swallow so a
+            // transient API error doesn't crash on a fire-and-forget path.
+        }
+    }
+}
diff --git a/InterlinedList/ViewModels/NotificationsViewModel.cs b/InterlinedList/ViewModels/NotificationsViewModel.cs
index 2433077..97bd31d 100644
--- a/InterlinedList/ViewModels/NotificationsViewModel.cs
+++ b/InterlinedList/ViewModels/NotificationsViewModel.cs
@@ -68,4 +68,36 @@ private async Task MarkAllReadAsync()
             ErrorMessage = ex.Message;
         }
     }
+
+    [RelayCommand]
+    private async Task MarkOneReadAsync(NotificationItemViewModel item)
+    {
+        try
+        {
+            await _session.Api.MarkNotificationReadAsync(item.Id);
+            item.MarkRead();
+            UnreadCount = Items.Count(i => i.IsUnread);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task DeleteOneAsync(NotificationItemViewModel item)
+    {
+        try
+        {
+            await _session.Api.DeleteNotificationAsync(item.Id);
+            Items.Remove(item);
+            UnreadCount = Items.Count(i => i.IsUnread);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
 }
diff --git a/InterlinedList/ViewModels/OrganizationsViewModel.cs b/InterlinedList/ViewModels/OrganizationsViewModel.cs
index ceae97f..370f666 100644
--- a/InterlinedList/ViewModels/OrganizationsViewModel.cs
+++ b/InterlinedList/ViewModels/OrganizationsViewModel.cs
@@ -15,6 +15,12 @@ public partial class OrganizationsViewModel : ObservableObject
     public ObservableCollection<OrganizationSummary> MyOrganizations { get; } = new();
     public ObservableCollection<OrganizationSummary> AllOrganizations { get; } = new();
 
+    // Members of the currently selected organization.
+    public ObservableCollection<OrgMember> Members { get; } = new();
+
+    // Results of the "add member" user search.
+    public ObservableCollection<UserSearchResult> UserSearchResults { get; } = new();
+
     [ObservableProperty]
     private bool isLoading;
 
@@ -33,6 +39,34 @@ public partial class OrganizationsViewModel : ObservableObject
     [ObservableProperty]
     private OrganizationSummary? selectedOrganization;
 
+    // True when the signed-in user's role in the selected org is owner or admin.
+    [ObservableProperty]
+    private bool canManageMembers;
+
+    // True only for the owner (delete-org affordance).
+    [ObservableProperty]
+    private bool canDeleteOrganization;
+
+    // ── Add-member search ───────────────────────────────────────────────────
+    [ObservableProperty]
+    private string memberSearchQuery = "";
+
+    [ObservableProperty]
+    private bool isSearchingUsers;
+
+    // ── Edit-org form (mirrors SelectedOrganization when the panel opens) ────
+    [ObservableProperty]
+    private bool isEditingOrganization;
+
+    [ObservableProperty]
+    private string editOrgName = "";
+
+    [ObservableProperty]
+    private string editOrgDescription = "";
+
+    [ObservableProperty]
+    private bool editOrgIsPublic;
+
     public OrganizationsViewModel(SessionService session)
     {
         _session = session;
@@ -93,13 +127,229 @@ private async Task SelectOrganizationAsync(OrganizationSummary org)
         try
         {
             SelectedOrganization = await _session.Api.GetOrganizationAsync(org.Id);
+            IsEditingOrganization = false;
+            MemberSearchQuery = "";
+            UserSearchResults.Clear();
+            ErrorMessage = null;
+            await LoadMembersAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    // ── Members ─────────────────────────────────────────────────────────────
+
+    // Re-fetch the member list for the selected org and recompute the current
+    // user's management rights. Called after selecting an org and after every
+    // member mutation (read-after-write).
+    private async Task LoadMembersAsync()
+    {
+        Members.Clear();
+        CanManageMembers = false;
+        CanDeleteOrganization = false;
+
+        var org = SelectedOrganization;
+        if (org is null)
+            return;
+
+        try
+        {
+            var members = await _session.Api.GetOrgMembersAsync(org.Id);
+            foreach (var member in members)
+                Members.Add(member);
+
+            var myId = _session.CurrentUser?.Id;
+            var mine = myId is null
+                ? null
+                : Members.FirstOrDefault(m => m.Id == myId);
+            var myRole = mine?.Role;
+            CanManageMembers = myRole is "owner" or "admin";
+            CanDeleteOrganization = myRole is "owner";
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task RemoveOrgMemberAsync(OrgMember member)
+    {
+        var org = SelectedOrganization;
+        if (org is null || member is null)
+            return;
+
+        try
+        {
+            await _session.Api.RemoveOrgMemberAsync(org.Id, member.Id);
+            await LoadMembersAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task PromoteMemberAsync(OrgMember member)
+    {
+        // member → admin → owner
+        var next = member?.Role switch
+        {
+            "member" => "admin",
+            "admin" => "owner",
+            _ => null,
+        };
+        await SetMemberRoleAsync(member, next);
+    }
+
+    [RelayCommand]
+    private async Task DemoteMemberAsync(OrgMember member)
+    {
+        // owner → admin → member
+        var next = member?.Role switch
+        {
+            "owner" => "admin",
+            "admin" => "member",
+            _ => null,
+        };
+        await SetMemberRoleAsync(member, next);
+    }
+
+    private async Task SetMemberRoleAsync(OrgMember? member, string? role)
+    {
+        var org = SelectedOrganization;
+        if (org is null || member is null || role is null)
+            return;
+
+        try
+        {
+            await _session.Api.UpdateOrgMemberRoleAsync(org.Id, member.Id, role);
+            await LoadMembersAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    // ── Add member (user search → add) ──────────────────────────────────────
+
+    private bool CanSearchUsers() => !string.IsNullOrWhiteSpace(MemberSearchQuery);
+
+    [RelayCommand(CanExecute = nameof(CanSearchUsers))]
+    private async Task SearchUsersAsync()
+    {
+        UserSearchResults.Clear();
+        IsSearchingUsers = true;
+        try
+        {
+            var page = await _session.Api.SearchUsersAsync(MemberSearchQuery.Trim());
+            foreach (var user in page.Users)
+                UserSearchResults.Add(user);
             ErrorMessage = null;
         }
         catch (InterlinedApiException ex)
         {
             ErrorMessage = ex.Message;
         }
+        finally
+        {
+            IsSearchingUsers = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task AddMemberAsync(UserSearchResult user)
+    {
+        var org = SelectedOrganization;
+        if (org is null || user is null)
+            return;
+
+        try
+        {
+            await _session.Api.AddOrgMemberAsync(org.Id, user.Id, "member");
+            MemberSearchQuery = "";
+            UserSearchResults.Clear();
+            await LoadMembersAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    // ── Edit / delete organization ──────────────────────────────────────────
+
+    [RelayCommand]
+    private void BeginEditOrganization()
+    {
+        var org = SelectedOrganization;
+        if (org is null)
+            return;
+
+        EditOrgName = org.Name;
+        EditOrgDescription = org.Description ?? "";
+        EditOrgIsPublic = org.IsPublic;
+        IsEditingOrganization = true;
+    }
+
+    [RelayCommand]
+    private void CancelEditOrganization() => IsEditingOrganization = false;
+
+    private bool CanSaveOrganization() => !string.IsNullOrWhiteSpace(EditOrgName);
+
+    [RelayCommand(CanExecute = nameof(CanSaveOrganization))]
+    private async Task SaveOrganizationAsync()
+    {
+        var org = SelectedOrganization;
+        if (org is null)
+            return;
+
+        try
+        {
+            var description = string.IsNullOrWhiteSpace(EditOrgDescription) ? null : EditOrgDescription.Trim();
+            await _session.Api.UpdateOrganizationAsync(org.Id, EditOrgName.Trim(), description, EditOrgIsPublic);
+            IsEditingOrganization = false;
+            // Read-after-write: re-fetch the org detail and its members.
+            SelectedOrganization = await _session.Api.GetOrganizationAsync(org.Id);
+            await LoadMembersAsync();
+            // Keep the left-pane lists in sync with the edited name/visibility.
+            await LoadAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task DeleteOrganizationAsync()
+    {
+        var org = SelectedOrganization;
+        if (org is null)
+            return;
+
+        try
+        {
+            await _session.Api.DeleteOrganizationAsync(org.Id);
+            SelectedOrganization = null;
+            IsEditingOrganization = false;
+            Members.Clear();
+            UserSearchResults.Clear();
+            CanManageMembers = false;
+            CanDeleteOrganization = false;
+            await LoadAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
     }
 
     partial void OnNewOrgNameChanged(string value) => CreateOrganizationCommand.NotifyCanExecuteChanged();
+    partial void OnMemberSearchQueryChanged(string value) => SearchUsersCommand.NotifyCanExecuteChanged();
+    partial void OnEditOrgNameChanged(string value) => SaveOrganizationCommand.NotifyCanExecuteChanged();
 }
diff --git a/InterlinedList/ViewModels/ProfileViewModel.cs b/InterlinedList/ViewModels/ProfileViewModel.cs
new file mode 100644
index 0000000..0a5308a
--- /dev/null
+++ b/InterlinedList/ViewModels/ProfileViewModel.cs
@@ -0,0 +1,225 @@
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using InterlinedList.Models;
+using InterlinedList.Services;
+
+namespace InterlinedList.ViewModels;
+
+/// <summary>
+/// Backs the People view: look up any user's public profile, follow/unfollow
+/// them, browse their recent messages, and approve/reject the follow requests
+/// pending on the current (private) account.
+/// </summary>
+public partial class ProfileViewModel : ObservableObject
+{
+    private readonly SessionService _session;
+
+    public ObservableCollection<FollowUser> FollowRequests { get; } = new();
+    public ObservableCollection<MessageItemViewModel> Messages { get; } = new();
+
+    [ObservableProperty]
+    private string lookupUsername = "";
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasProfile))]
+    private UserProfile? profile;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(FollowButtonText))]
+    private FollowStatus? relationship;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(BlockButtonText))]
+    private bool isBlocking;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(MuteButtonText))]
+    private bool isMuting;
+
+    [ObservableProperty]
+    private bool isLoading;
+
+    [ObservableProperty]
+    private string? errorMessage;
+
+    public bool HasRequests => FollowRequests.Count > 0;
+
+    public bool HasProfile => Profile is not null;
+
+    public string FollowButtonText =>
+        Relationship?.IsFollowing == true ? "Following"
+        : Relationship?.IsPending == true ? "Requested"
+        : "Follow";
+
+    public string BlockButtonText => IsBlocking ? "Unblock" : "Block";
+
+    public string MuteButtonText => IsMuting ? "Unmute" : "Mute";
+
+    public ProfileViewModel(SessionService session)
+    {
+        _session = session;
+        FollowRequests.CollectionChanged += (_, _) => OnPropertyChanged(nameof(HasRequests));
+    }
+
+    [RelayCommand]
+    private async Task LoadAsync()
+    {
+        IsLoading = true;
+        try
+        {
+            var requests = await _session.Api.GetFollowRequestsAsync();
+
+            FollowRequests.Clear();
+            foreach (var request in requests)
+                FollowRequests.Add(request);
+
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task LoadProfileAsync()
+    {
+        var username = LookupUsername.Trim().TrimStart('@');
+        if (string.IsNullOrWhiteSpace(username))
+            return;
+
+        IsLoading = true;
+        try
+        {
+            var profile = await _session.Api.GetProfileAsync(username);
+            Profile = profile;
+
+            Relationship = await _session.Api.GetFollowStatusAsync(profile.Id);
+            IsBlocking = await _session.Api.IsBlockingAsync(profile.Username);
+            IsMuting = await _session.Api.IsMutingAsync(profile.Username);
+
+            var page = await _session.Api.GetUserMessagesAsync(profile.Username);
+            Messages.Clear();
+            foreach (var message in page.Messages)
+                Messages.Add(new MessageItemViewModel(message, _session.Api, _session.CurrentUser?.Id));
+
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task ToggleFollowAsync()
+    {
+        if (Profile is null)
+            return;
+
+        try
+        {
+            if (Relationship?.IsFollowing == true)
+                await _session.Api.UnfollowAsync(Profile.Id);
+            else
+                await _session.Api.FollowAsync(Profile.Id);
+
+            // Write path isn't trusted for its response shape — read back the
+            // relationship and refresh the profile so the counts stay honest.
+            Relationship = await _session.Api.GetFollowStatusAsync(Profile.Id);
+            Profile = await _session.Api.GetProfileAsync(Profile.Username);
+
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task ToggleBlockAsync()
+    {
+        if (Profile is null) return;
+        try
+        {
+            if (IsBlocking) await _session.Api.UnblockUserAsync(Profile.Username);
+            else await _session.Api.BlockUserAsync(Profile.Username);
+            IsBlocking = await _session.Api.IsBlockingAsync(Profile.Username);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task ToggleMuteAsync()
+    {
+        if (Profile is null) return;
+        try
+        {
+            if (IsMuting) await _session.Api.UnmuteUserAsync(Profile.Username);
+            else await _session.Api.MuteUserAsync(Profile.Username);
+            IsMuting = await _session.Api.IsMutingAsync(Profile.Username);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task ReportAsync()
+    {
+        if (Profile is null) return;
+        try
+        {
+            await _session.Api.ReportUserAsync(Profile.Username, "other", null);
+            ErrorMessage = "Reported. Thanks — our team will take a look.";
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task ApproveAsync(FollowUser user)
+    {
+        try
+        {
+            await _session.Api.ApproveFollowAsync(user.Id);
+            await LoadAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task RejectAsync(FollowUser user)
+    {
+        try
+        {
+            await _session.Api.RejectFollowAsync(user.Id);
+            await LoadAsync();
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+}
diff --git a/InterlinedList/ViewModels/SettingsViewModel.cs b/InterlinedList/ViewModels/SettingsViewModel.cs
new file mode 100644
index 0000000..2656c5e
--- /dev/null
+++ b/InterlinedList/ViewModels/SettingsViewModel.cs
@@ -0,0 +1,251 @@
+using System.Collections.ObjectModel;
+using System.IO;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using InterlinedList.Models;
+using InterlinedList.Services;
+using Microsoft.Win32;
+
+namespace InterlinedList.ViewModels;
+
+/// <summary>
+/// Settings view model: edit profile, manage standing API sessions (sync-tokens),
+/// notification preferences, and the blocked/muted user lists. Sessions are NOT
+/// auto-loaded (the list can be hundreds of rows) — they load on the Refresh
+/// button via <see cref="LoadSessionsCommand"/>.
+/// </summary>
+public partial class SettingsViewModel : ObservableObject
+{
+    private readonly SessionService _session;
+
+    public ObservableCollection<ApiSession> Sessions { get; } = new();
+    public ObservableCollection<NotificationPrefViewModel> Preferences { get; } = new();
+    public ObservableCollection<ModeratedUser> BlockedUsers { get; } = new();
+    public ObservableCollection<ModeratedUser> MutedUsers { get; } = new();
+
+    [ObservableProperty]
+    private string displayName = "";
+
+    [ObservableProperty]
+    private string bio = "";
+
+    [ObservableProperty]
+    private bool isPrivateAccount;
+
+    [ObservableProperty]
+    private bool isBusy;
+
+    [ObservableProperty]
+    private string? errorMessage;
+
+    [ObservableProperty]
+    private string avatarUrl = "";
+
+    [ObservableProperty]
+    private string newEmail = "";
+
+    public SettingsViewModel(SessionService session)
+    {
+        _session = session;
+    }
+
+    [RelayCommand]
+    private async Task SetAvatarAsync()
+    {
+        if (string.IsNullOrWhiteSpace(AvatarUrl)) return;
+        try
+        {
+            await _session.Api.UpdateAvatarFromUrlAsync(AvatarUrl.Trim());
+            AvatarUrl = "";
+            ErrorMessage = "Avatar updated.";
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task ChangeEmailAsync()
+    {
+        if (string.IsNullOrWhiteSpace(NewEmail)) return;
+        try
+        {
+            await _session.Api.RequestEmailChangeAsync(NewEmail.Trim());
+            NewEmail = "";
+            ErrorMessage = "Requested — check your inbox to confirm the new address.";
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task LoadAsync()
+    {
+        IsBusy = true;
+        try
+        {
+            // Prefill profile fields from the current user.
+            var user = _session.CurrentUser;
+            if (user is not null)
+            {
+                DisplayName = user.DisplayName ?? "";
+                Bio = user.Bio ?? "";
+                IsPrivateAccount = user.IsPrivateAccount;
+            }
+
+            var prefs = await _session.Api.GetNotificationPreferencesAsync();
+            Preferences.Clear();
+            foreach (var pref in prefs)
+                Preferences.Add(new NotificationPrefViewModel(pref, _session));
+
+            var blocked = await _session.Api.GetBlockedUsersAsync();
+            BlockedUsers.Clear();
+            foreach (var blockedUser in blocked)
+                BlockedUsers.Add(blockedUser);
+
+            var muted = await _session.Api.GetMutedUsersAsync();
+            MutedUsers.Clear();
+            foreach (var mutedUser in muted)
+                MutedUsers.Add(mutedUser);
+
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task LoadSessionsAsync()
+    {
+        IsBusy = true;
+        try
+        {
+            var sessions = await _session.Api.GetSessionsAsync();
+            Sessions.Clear();
+            foreach (var s in sessions)
+                Sessions.Add(s);
+
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task SaveProfileAsync()
+    {
+        IsBusy = true;
+        try
+        {
+            await _session.Api.UpdateProfileAsync(DisplayName, Bio, IsPrivateAccount);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task RevokeAsync(ApiSession s)
+    {
+        try
+        {
+            await _session.Api.RevokeSessionAsync(s.Id);
+            Sessions.Remove(s);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task UnblockAsync(ModeratedUser u)
+    {
+        try
+        {
+            await _session.Api.UnblockUserAsync(u.Username);
+            BlockedUsers.Remove(u);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    [RelayCommand]
+    private async Task UnmuteAsync(ModeratedUser u)
+    {
+        try
+        {
+            await _session.Api.UnmuteUserAsync(u.Username);
+            MutedUsers.Remove(u);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+
+    // ── CSV data export ─────────────────────────────────────────────────────────
+
+    [RelayCommand]
+    private Task ExportMessagesAsync() => ExportCsvAsync(_session.Api.ExportMessagesCsvAsync, "messages.csv");
+
+    [RelayCommand]
+    private Task ExportListsAsync() => ExportCsvAsync(_session.Api.ExportListsCsvAsync, "lists.csv");
+
+    [RelayCommand]
+    private Task ExportListRowsAsync() => ExportCsvAsync(_session.Api.ExportListDataRowsCsvAsync, "list-rows.csv");
+
+    [RelayCommand]
+    private Task ExportFollowsAsync() => ExportCsvAsync(_session.Api.ExportFollowsCsvAsync, "follows.csv");
+
+    private async Task ExportCsvAsync(Func<CancellationToken, Task<string>> fetch, string defaultFileName)
+    {
+        try
+        {
+            var csv = await fetch(default);
+            var dlg = new SaveFileDialog
+            {
+                FileName = defaultFileName,
+                DefaultExt = ".csv",
+                Filter = "CSV file (*.csv)|*.csv|All files (*.*)|*.*"
+            };
+            if (dlg.ShowDialog() == true)
+                await File.WriteAllTextAsync(dlg.FileName, csv);
+            ErrorMessage = null;
+        }
+        catch (InterlinedApiException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+        catch (IOException ex)
+        {
+            ErrorMessage = ex.Message;
+        }
+    }
+}
diff --git a/InterlinedList/Views/DirectMessagesView.xaml b/InterlinedList/Views/DirectMessagesView.xaml
new file mode 100644
index 0000000..8d5a87f
--- /dev/null
+++ b/InterlinedList/Views/DirectMessagesView.xaml
@@ -0,0 +1,323 @@
+<UserControl x:Class="InterlinedList.Views.DirectMessagesView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="clr-namespace:InterlinedList.ViewModels"
+             xmlns:local="clr-namespace:InterlinedList.Views"
+             Background="{DynamicResource AppBgBrush}">
+
+    <UserControl.Resources>
+        <BooleanToVisibilityConverter x:Key="BoolToVisibility"/>
+        <local:InverseNullToVisibilityConverter x:Key="InverseNullToVisibility"/>
+        <local:NullOrEmptyToVisibilityConverter x:Key="NullOrEmptyToVisibility"/>
+
+        <!-- Primary green button (matches FeedView) -->
+        <Style x:Key="PrimaryBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="{DynamicResource PrimaryBrush}"/>
+            <Setter Property="Foreground" Value="White"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="Padding" Value="16,6"/>
+            <Setter Property="FontSize" Value="13"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Bg"
+                                Background="{TemplateBinding Background}"
+                                CornerRadius="4"
+                                Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Bg" Property="Background"
+                                        Value="{DynamicResource PrimaryHoverBrush}"/>
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter TargetName="Bg" Property="Opacity" Value="0.5"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+    </UserControl.Resources>
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>  <!-- Header -->
+            <RowDefinition Height="Auto"/>  <!-- Error banner -->
+            <RowDefinition Height="*"/>     <!-- Two-column body -->
+        </Grid.RowDefinitions>
+
+        <!-- Header -->
+        <Border Grid.Row="0"
+                Background="{DynamicResource SurfaceBrush}"
+                BorderBrush="{DynamicResource BorderBrush}"
+                BorderThickness="0,0,0,1"
+                Padding="20,12">
+            <Grid>
+                <TextBlock Text="Direct Messages"
+                           FontSize="17" FontWeight="SemiBold"
+                           Foreground="{DynamicResource TextBrush}"
+                           VerticalAlignment="Center"/>
+                <TextBlock Text="Loading…"
+                           HorizontalAlignment="Right"
+                           FontSize="12"
+                           Foreground="{DynamicResource TextMutedBrush}"
+                           Visibility="{Binding IsLoading, Converter={StaticResource BoolToVisibility}}"/>
+            </Grid>
+        </Border>
+
+        <!-- Error banner -->
+        <Border Grid.Row="1"
+                Background="#1AE81123"
+                Padding="20,8">
+            <Border.Style>
+                <Style TargetType="Border">
+                    <Setter Property="Visibility" Value="Visible"/>
+                    <Style.Triggers>
+                        <DataTrigger Binding="{Binding ErrorMessage}" Value="{x:Null}">
+                            <Setter Property="Visibility" Value="Collapsed"/>
+                        </DataTrigger>
+                    </Style.Triggers>
+                </Style>
+            </Border.Style>
+            <TextBlock Text="{Binding ErrorMessage}"
+                       FontSize="12"
+                       Foreground="#FFE81123"
+                       TextWrapping="Wrap"/>
+        </Border>
+
+        <!-- Two-column body -->
+        <Grid Grid.Row="2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="240"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+
+            <!-- LEFT: recipient list -->
+            <Border Grid.Column="0"
+                    Background="{DynamicResource Surface2Brush}"
+                    BorderBrush="{DynamicResource BorderBrush}"
+                    BorderThickness="0,0,1,0">
+                <ScrollViewer VerticalScrollBarVisibility="Auto"
+                              HorizontalScrollBarVisibility="Disabled"
+                              Padding="8,8">
+                    <ItemsControl ItemsSource="{Binding Recipients}">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <Button Margin="0,0,0,2"
+                                        HorizontalContentAlignment="Stretch"
+                                        Cursor="Hand"
+                                        Command="{Binding DataContext.SelectRecipientCommand,
+                                                  RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                        CommandParameter="{Binding}">
+                                    <Button.Template>
+                                        <ControlTemplate TargetType="Button">
+                                            <Border x:Name="Row"
+                                                    Background="Transparent"
+                                                    CornerRadius="4"
+                                                    Padding="8,6">
+                                                <ContentPresenter/>
+                                            </Border>
+                                            <ControlTemplate.Triggers>
+                                                <Trigger Property="IsMouseOver" Value="True">
+                                                    <Setter TargetName="Row" Property="Background"
+                                                            Value="{DynamicResource Surface3Brush}"/>
+                                                </Trigger>
+                                            </ControlTemplate.Triggers>
+                                        </ControlTemplate>
+                                    </Button.Template>
+                                    <DockPanel>
+                                        <Border DockPanel.Dock="Left"
+                                                Width="24" Height="24"
+                                                CornerRadius="999"
+                                                ClipToBounds="True"
+                                                Background="{DynamicResource Surface3Brush}"
+                                                Margin="0,0,8,0"
+                                                VerticalAlignment="Center">
+                                            <Image Source="{Binding Avatar}" Stretch="UniformToFill"/>
+                                        </Border>
+                                        <StackPanel VerticalAlignment="Center">
+                                            <TextBlock Text="{Binding DisplayNameOrUsername}"
+                                                       FontSize="12" FontWeight="SemiBold"
+                                                       Foreground="{DynamicResource TextBrush}"
+                                                       TextTrimming="CharacterEllipsis"/>
+                                            <TextBlock Text="{Binding Handle}"
+                                                       FontSize="11"
+                                                       Foreground="{DynamicResource TextMutedBrush}"
+                                                       TextTrimming="CharacterEllipsis"/>
+                                        </StackPanel>
+                                    </DockPanel>
+                                </Button>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                </ScrollViewer>
+            </Border>
+
+            <!-- RIGHT: selected conversation -->
+            <Grid Grid.Column="1">
+
+                <!-- Empty state (no recipient selected) -->
+                <TextBlock Text="Select a conversation"
+                           HorizontalAlignment="Center"
+                           VerticalAlignment="Center"
+                           FontSize="14"
+                           Foreground="{DynamicResource TextMutedBrush}"
+                           Visibility="{Binding SelectedRecipient, Converter={StaticResource InverseNullToVisibility}}"/>
+
+                <!-- Conversation -->
+                <Grid Visibility="{Binding HasSelection, Converter={StaticResource BoolToVisibility}}">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>  <!-- Conversation header -->
+                        <RowDefinition Height="*"/>     <!-- Messages -->
+                        <RowDefinition Height="Auto"/>  <!-- Compose -->
+                    </Grid.RowDefinitions>
+
+                    <!-- Conversation header -->
+                    <Border Grid.Row="0"
+                            Background="{DynamicResource SurfaceBrush}"
+                            BorderBrush="{DynamicResource BorderBrush}"
+                            BorderThickness="0,0,0,1"
+                            Padding="16,10">
+                        <DockPanel DataContext="{Binding SelectedRecipient}">
+                            <Border DockPanel.Dock="Left"
+                                    Width="28" Height="28"
+                                    CornerRadius="999"
+                                    ClipToBounds="True"
+                                    Background="{DynamicResource Surface3Brush}"
+                                    Margin="0,0,10,0"
+                                    VerticalAlignment="Center">
+                                <Image Source="{Binding Avatar}" Stretch="UniformToFill"/>
+                            </Border>
+                            <StackPanel VerticalAlignment="Center">
+                                <TextBlock Text="{Binding DisplayNameOrUsername}"
+                                           FontSize="14" FontWeight="SemiBold"
+                                           Foreground="{DynamicResource TextBrush}"/>
+                                <TextBlock Text="{Binding Handle}"
+                                           FontSize="11"
+                                           Foreground="{DynamicResource TextMutedBrush}"/>
+                            </StackPanel>
+                        </DockPanel>
+                    </Border>
+
+                    <!-- Message list -->
+                    <ScrollViewer Grid.Row="1"
+                                  VerticalScrollBarVisibility="Auto"
+                                  HorizontalScrollBarVisibility="Disabled"
+                                  Padding="16,12">
+                        <ItemsControl ItemsSource="{Binding Messages}">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate DataType="{x:Type vm:DmMessageViewModel}">
+                                    <Grid Margin="0,0,0,8">
+                                        <!-- Others: left-aligned, SurfaceBrush -->
+                                        <Border HorizontalAlignment="Left"
+                                                MaxWidth="420"
+                                                Background="{DynamicResource SurfaceBrush}"
+                                                BorderBrush="{DynamicResource BorderBrush}"
+                                                BorderThickness="1"
+                                                CornerRadius="4"
+                                                Padding="10,8">
+                                            <Border.Style>
+                                                <Style TargetType="Border">
+                                                    <Setter Property="Visibility" Value="Visible"/>
+                                                    <Style.Triggers>
+                                                        <DataTrigger Binding="{Binding IsMine}" Value="True">
+                                                            <Setter Property="Visibility" Value="Collapsed"/>
+                                                        </DataTrigger>
+                                                    </Style.Triggers>
+                                                </Style>
+                                            </Border.Style>
+                                            <StackPanel>
+                                                <TextBlock Text="{Binding Body}"
+                                                           FontSize="13"
+                                                           Foreground="{DynamicResource TextBodyBrush}"
+                                                           TextWrapping="Wrap"
+                                                           LineHeight="20"/>
+                                                <TextBlock Text="{Binding TimeFormatted}"
+                                                           FontFamily="JetBrains Mono, Consolas"
+                                                           FontSize="10"
+                                                           Foreground="{DynamicResource TextMutedBrush}"
+                                                           Margin="0,4,0,0"
+                                                           HorizontalAlignment="Left"/>
+                                            </StackPanel>
+                                        </Border>
+
+                                        <!-- Mine: right-aligned, teal-ish (Surface3Brush + teal accent) -->
+                                        <Border HorizontalAlignment="Right"
+                                                MaxWidth="420"
+                                                Background="{DynamicResource Surface3Brush}"
+                                                BorderBrush="{StaticResource TealBrush}"
+                                                BorderThickness="0,0,3,0"
+                                                CornerRadius="4"
+                                                Padding="10,8"
+                                                Visibility="Collapsed">
+                                            <Border.Style>
+                                                <Style TargetType="Border">
+                                                    <Setter Property="Visibility" Value="Collapsed"/>
+                                                    <Style.Triggers>
+                                                        <DataTrigger Binding="{Binding IsMine}" Value="True">
+                                                            <Setter Property="Visibility" Value="Visible"/>
+                                                        </DataTrigger>
+                                                    </Style.Triggers>
+                                                </Style>
+                                            </Border.Style>
+                                            <StackPanel>
+                                                <TextBlock Text="{Binding Body}"
+                                                           FontSize="13"
+                                                           Foreground="{DynamicResource TextBodyBrush}"
+                                                           TextWrapping="Wrap"
+                                                           LineHeight="20"/>
+                                                <TextBlock Text="{Binding TimeFormatted}"
+                                                           FontFamily="JetBrains Mono, Consolas"
+                                                           FontSize="10"
+                                                           Foreground="{DynamicResource TextMutedBrush}"
+                                                           Margin="0,4,0,0"
+                                                           HorizontalAlignment="Right"/>
+                                            </StackPanel>
+                                        </Border>
+                                    </Grid>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+                    </ScrollViewer>
+
+                    <!-- Compose -->
+                    <Border Grid.Row="2"
+                            Background="{DynamicResource Surface2Brush}"
+                            BorderBrush="{DynamicResource BorderBrush}"
+                            BorderThickness="0,1,0,0"
+                            Padding="16,12">
+                        <Grid>
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="*"/>
+                                <ColumnDefinition Width="Auto"/>
+                            </Grid.ColumnDefinitions>
+                            <TextBox Grid.Column="0"
+                                     Text="{Binding ComposeText, UpdateSourceTrigger=PropertyChanged}"
+                                     AcceptsReturn="True"
+                                     TextWrapping="Wrap"
+                                     MinHeight="40"
+                                     MaxHeight="120"
+                                     Padding="10,8"
+                                     FontSize="13"
+                                     VerticalContentAlignment="Center"
+                                     Background="{DynamicResource SurfaceBrush}"
+                                     Foreground="{DynamicResource TextBodyBrush}"
+                                     BorderBrush="{DynamicResource BorderBrush}"
+                                     BorderThickness="1"/>
+                            <Button Grid.Column="1"
+                                    Content="Send"
+                                    Command="{Binding SendCommand}"
+                                    Margin="8,0,0,0"
+                                    VerticalAlignment="Bottom"
+                                    Style="{StaticResource PrimaryBtnStyle}"/>
+                        </Grid>
+                    </Border>
+                </Grid>
+            </Grid>
+        </Grid>
+    </Grid>
+</UserControl>
diff --git a/InterlinedList/Views/DirectMessagesView.xaml.cs b/InterlinedList/Views/DirectMessagesView.xaml.cs
new file mode 100644
index 0000000..94411ae
--- /dev/null
+++ b/InterlinedList/Views/DirectMessagesView.xaml.cs
@@ -0,0 +1,15 @@
+using System.Windows.Controls;
+using InterlinedList.ViewModels;
+
+namespace InterlinedList.Views;
+
+public partial class DirectMessagesView : UserControl
+{
+    public DirectMessagesView()
+    {
+        InitializeComponent();
+        var vm = new DirectMessagesViewModel(Services.AppServices.Session);
+        DataContext = vm;
+        _ = vm.LoadCommand.ExecuteAsync(null);
+    }
+}
diff --git a/InterlinedList/Views/DocumentsView.xaml b/InterlinedList/Views/DocumentsView.xaml
index f7fbde4..89c55a0 100644
--- a/InterlinedList/Views/DocumentsView.xaml
+++ b/InterlinedList/Views/DocumentsView.xaml
@@ -2,6 +2,7 @@
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:vm="clr-namespace:InterlinedList.ViewModels"
+             xmlns:local="clr-namespace:InterlinedList.Views"
              xmlns:models="clr-namespace:InterlinedList.Models"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
@@ -11,6 +12,7 @@
 
     <UserControl.Resources>
         <BooleanToVisibilityConverter x:Key="BoolToVisibility"/>
+        <local:ReferenceEqualToVisibilityConverter x:Key="RefEqualToVisibility"/>
 
         <Style x:Key="FieldStyle" TargetType="TextBox">
             <Setter Property="Background" Value="{DynamicResource SurfaceBrush}"/>
@@ -141,6 +143,16 @@
                             HorizontalAlignment="Left"
                             Style="{StaticResource PrimaryBtnStyle}"/>
 
+                    <TextBlock Text="New folder" FontSize="10" FontWeight="SemiBold"
+                               Foreground="{DynamicResource TextMutedBrush}" Margin="0,14,0,4"/>
+                    <TextBox Text="{Binding NewFolderName, UpdateSourceTrigger=PropertyChanged}"
+                             Style="{StaticResource FieldStyle}"
+                             Tag="Folder name"/>
+                    <Button Content="New folder"
+                            Command="{Binding CreateFolderCommand}"
+                            HorizontalAlignment="Left"
+                            Style="{StaticResource SmallBtnStyle}"/>
+
                     <TextBlock Text="{Binding ErrorMessage}"
                                Style="{StaticResource ErrorBannerStyle}"
                                Foreground="#FFE81123"
@@ -174,10 +186,73 @@
                                             CornerRadius="4"
                                             Padding="10,8">
                                         <StackPanel>
-                                            <TextBlock Text="{Binding Name}"
-                                                       FontSize="13" FontWeight="SemiBold"
-                                                       Foreground="{DynamicResource TextBrush}"
-                                                       Margin="0,0,0,4"/>
+                                            <!-- Folder header: name + subtle actions -->
+                                            <DockPanel Margin="0,0,0,4">
+                                                <TextBlock DockPanel.Dock="Left"
+                                                           Text="{Binding Name}"
+                                                           FontSize="13" FontWeight="SemiBold"
+                                                           Foreground="{DynamicResource TextBrush}"
+                                                           VerticalAlignment="Center"/>
+                                                <StackPanel Orientation="Horizontal"
+                                                            HorizontalAlignment="Right">
+                                                    <Button Content="New doc"
+                                                            Command="{Binding DataContext.StartAddDocToFolderCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                            CommandParameter="{Binding}"
+                                                            Style="{StaticResource SmallBtnStyle}"/>
+                                                    <Button Content="Rename"
+                                                            Command="{Binding DataContext.StartRenameFolderCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                            CommandParameter="{Binding}"
+                                                            Style="{StaticResource SmallBtnStyle}"/>
+                                                    <Button Content="Delete"
+                                                            Command="{Binding DataContext.DeleteFolderCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                            CommandParameter="{Binding}"
+                                                            Style="{StaticResource SmallBtnStyle}"/>
+                                                </StackPanel>
+                                            </DockPanel>
+
+                                            <!-- Inline rename editor (this row only) -->
+                                            <StackPanel Margin="0,4,0,6">
+                                                <StackPanel.Visibility>
+                                                    <MultiBinding Converter="{StaticResource RefEqualToVisibility}">
+                                                        <Binding Path="."/>
+                                                        <Binding Path="DataContext.EditingFolder" RelativeSource="{RelativeSource AncestorType=UserControl}"/>
+                                                    </MultiBinding>
+                                                </StackPanel.Visibility>
+                                                <TextBox Text="{Binding DataContext.EditingFolderName, RelativeSource={RelativeSource AncestorType=UserControl}, UpdateSourceTrigger=PropertyChanged}"
+                                                         Style="{StaticResource FieldStyle}"
+                                                         Margin="0,0,0,4"/>
+                                                <StackPanel Orientation="Horizontal">
+                                                    <Button Content="Save"
+                                                            Command="{Binding DataContext.SaveRenameFolderCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                            Style="{StaticResource SmallBtnStyle}"/>
+                                                    <Button Content="Cancel"
+                                                            Command="{Binding DataContext.CancelRenameFolderCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                            Style="{StaticResource SmallBtnStyle}"/>
+                                                </StackPanel>
+                                            </StackPanel>
+
+                                            <!-- Inline new-doc editor (this row only) -->
+                                            <StackPanel Margin="0,4,0,6">
+                                                <StackPanel.Visibility>
+                                                    <MultiBinding Converter="{StaticResource RefEqualToVisibility}">
+                                                        <Binding Path="."/>
+                                                        <Binding Path="DataContext.AddingDocFolder" RelativeSource="{RelativeSource AncestorType=UserControl}"/>
+                                                    </MultiBinding>
+                                                </StackPanel.Visibility>
+                                                <TextBox Text="{Binding DataContext.NewFolderDocTitle, RelativeSource={RelativeSource AncestorType=UserControl}, UpdateSourceTrigger=PropertyChanged}"
+                                                         Style="{StaticResource FieldStyle}"
+                                                         Margin="0,0,0,4"
+                                                         Tag="Document title"/>
+                                                <StackPanel Orientation="Horizontal">
+                                                    <Button Content="Add doc"
+                                                            Command="{Binding DataContext.SaveDocToFolderCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                            Style="{StaticResource SmallBtnStyle}"/>
+                                                    <Button Content="Cancel"
+                                                            Command="{Binding DataContext.CancelAddDocToFolderCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                            Style="{StaticResource SmallBtnStyle}"/>
+                                                </StackPanel>
+                                            </StackPanel>
+
                                             <ItemsControl ItemsSource="{Binding Documents}">
                                                 <ItemsControl.ItemTemplate>
                                                     <DataTemplate DataType="{x:Type models:DocumentFolderEntry}">
diff --git a/InterlinedList/Views/DocumentsView.xaml.cs b/InterlinedList/Views/DocumentsView.xaml.cs
index f86fe1f..4398dbb 100644
--- a/InterlinedList/Views/DocumentsView.xaml.cs
+++ b/InterlinedList/Views/DocumentsView.xaml.cs
@@ -1,4 +1,7 @@
+using System.Globalization;
+using System.Windows;
 using System.Windows.Controls;
+using System.Windows.Data;
 using InterlinedList.ViewModels;
 
 namespace InterlinedList.Views;
@@ -13,3 +16,23 @@ public DocumentsView()
         _ = vm.LoadCommand.ExecuteAsync(null);
     }
 }
+
+/// <summary>
+/// MultiBinding converter: returns Visible when the two bound values are
+/// reference-equal (i.e. the row's folder is the folder currently being
+/// edited / added-to), otherwise Collapsed. Used to show a folder's inline
+/// rename / new-doc editors only on the row they belong to.
+/// </summary>
+public sealed class ReferenceEqualToVisibilityConverter : IMultiValueConverter
+{
+    public object Convert(object[] values, System.Type targetType, object parameter, CultureInfo culture)
+    {
+        if (values.Length < 2) return Visibility.Collapsed;
+        return ReferenceEquals(values[0], values[1]) && values[0] is not null
+            ? Visibility.Visible
+            : Visibility.Collapsed;
+    }
+
+    public object[] ConvertBack(object value, System.Type[] targetTypes, object parameter, CultureInfo culture)
+        => throw new System.NotSupportedException();
+}
diff --git a/InterlinedList/Views/FeedView.xaml b/InterlinedList/Views/FeedView.xaml
index 1027e64..39ecf07 100644
--- a/InterlinedList/Views/FeedView.xaml
+++ b/InterlinedList/Views/FeedView.xaml
@@ -74,6 +74,57 @@
                 </Setter.Value>
             </Setter>
         </Style>
+
+        <!-- Subtle card action (Reply / Edit / Delete / Report) -->
+        <Style x:Key="CardActionBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextMutedBrush}"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="Padding" Value="6,2"/>
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Bg"
+                                Background="{TemplateBinding Background}"
+                                CornerRadius="3"
+                                Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Bg" Property="Background" Value="{DynamicResource Surface3Brush}"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- Clickable author name → opens their profile -->
+        <Style x:Key="AuthorLinkBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextBrush}"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="Padding" Value="0"/>
+            <Setter Property="FontSize" Value="12"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="HorizontalContentAlignment" Value="Left"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <ContentPresenter/>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter Property="TextBlock.TextDecorations" Value="Underline"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
     </UserControl.Resources>
 
     <Grid>
@@ -144,11 +195,42 @@
                               VerticalAlignment="Center"/>
                 </StackPanel>
 
-                <Button Content="Post"
-                        Command="{Binding PostCommand}"
-                        HorizontalAlignment="Right"
-                        Margin="0,8,0,0"
-                        Style="{StaticResource PrimaryBtnStyle}"/>
+                <!-- Attached images (uploaded, pending post) -->
+                <ItemsControl ItemsSource="{Binding AttachedImageUrls}" Margin="0,8,0,0">
+                    <ItemsControl.ItemsPanel>
+                        <ItemsPanelTemplate><WrapPanel/></ItemsPanelTemplate>
+                    </ItemsControl.ItemsPanel>
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate>
+                            <Border Margin="0,0,6,6" Width="52" Height="52" CornerRadius="4"
+                                    ClipToBounds="True" Background="{DynamicResource Surface3Brush}">
+                                <Grid>
+                                    <Image Source="{Binding}" Stretch="UniformToFill"/>
+                                    <Button Content="✕"
+                                            Command="{Binding DataContext.RemoveAttachmentCommand,
+                                                      RelativeSource={RelativeSource AncestorType=ItemsControl}}"
+                                            CommandParameter="{Binding}"
+                                            HorizontalAlignment="Right" VerticalAlignment="Top"
+                                            Width="16" Height="16" Padding="0" FontSize="9"
+                                            Background="#99000000" Foreground="White"
+                                            BorderThickness="0" Cursor="Hand"/>
+                                </Grid>
+                            </Border>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+
+                <DockPanel Margin="0,8,0,0">
+                    <Button DockPanel.Dock="Left"
+                            Content="Add image"
+                            Command="{Binding AttachImageCommand}"
+                            Style="{StaticResource DigBtnStyle}"/>
+                    <Button DockPanel.Dock="Right"
+                            Content="Post"
+                            Command="{Binding PostCommand}"
+                            HorizontalAlignment="Right"
+                            Style="{StaticResource PrimaryBtnStyle}"/>
+                </DockPanel>
             </StackPanel>
         </Border>
 
@@ -187,6 +269,15 @@
                                     BorderBrush="{DynamicResource BorderBrush}"
                                     BorderThickness="1"
                                     CornerRadius="4">
+                                <Border.Style>
+                                    <Style TargetType="Border">
+                                        <Style.Triggers>
+                                            <DataTrigger Binding="{Binding IsDeleted}" Value="True">
+                                                <Setter Property="Visibility" Value="Collapsed"/>
+                                            </DataTrigger>
+                                        </Style.Triggers>
+                                    </Style>
+                                </Border.Style>
                                 <Grid>
                                     <Grid.ColumnDefinitions>
                                         <ColumnDefinition Width="4"/>
@@ -220,12 +311,12 @@
                                                     Margin="0,0,8,0">
                                                 <Image Source="{Binding AvatarUrl}" Stretch="UniformToFill"/>
                                             </Border>
-                                            <TextBlock DockPanel.Dock="Left"
-                                                       Text="{Binding AuthorDisplayName}"
-                                                       FontSize="12" FontWeight="SemiBold"
-                                                       Foreground="{DynamicResource TextBrush}"
-                                                       VerticalAlignment="Center"
-                                                       Margin="0,0,6,0"/>
+                                            <Button DockPanel.Dock="Left"
+                                                    Content="{Binding AuthorDisplayName}"
+                                                    Command="{Binding OpenAuthorCommand}"
+                                                    Style="{StaticResource AuthorLinkBtnStyle}"
+                                                    VerticalAlignment="Center"
+                                                    Margin="0,0,6,0"/>
                                             <TextBlock DockPanel.Dock="Left"
                                                        Text="{Binding AuthorHandle}"
                                                        FontSize="11"
@@ -248,7 +339,20 @@
                                                    LineHeight="20"
                                                    Margin="0,0,0,8"/>
 
-                                        <!-- Footer: Dig -->
+                                        <!-- Attached images -->
+                                        <ItemsControl ItemsSource="{Binding ImageUrls}" Margin="0,0,0,8"
+                                                      Visibility="{Binding HasImages, Converter={StaticResource BoolToVisibility}}">
+                                            <ItemsControl.ItemTemplate>
+                                                <DataTemplate>
+                                                    <Border Margin="0,0,0,6" CornerRadius="4"
+                                                            ClipToBounds="True" HorizontalAlignment="Left">
+                                                        <Image Source="{Binding}" Stretch="Uniform" MaxHeight="320"/>
+                                                    </Border>
+                                                </DataTemplate>
+                                            </ItemsControl.ItemTemplate>
+                                        </ItemsControl>
+
+                                        <!-- Footer: Dig + actions -->
                                         <StackPanel Orientation="Horizontal">
                                             <Button Content="Dig"
                                                     Command="{Binding DigCommand}">
@@ -268,8 +372,85 @@
                                                        FontSize="10"
                                                        Foreground="{DynamicResource TextMutedBrush}"
                                                        VerticalAlignment="Center"
-                                                       Margin="8,0,0,0"/>
+                                                       Margin="8,0,12,0"/>
+                                            <Button Content="Reply" Command="{Binding StartReplyCommand}"
+                                                    Style="{StaticResource CardActionBtnStyle}"/>
+                                            <Button Content="Replies" Command="{Binding ToggleRepliesCommand}"
+                                                    Style="{StaticResource CardActionBtnStyle}"/>
+                                            <Button Content="Edit" Command="{Binding StartEditCommand}"
+                                                    Style="{StaticResource CardActionBtnStyle}"
+                                                    Visibility="{Binding IsMine, Converter={StaticResource BoolToVisibility}}"/>
+                                            <Button Content="Delete" Command="{Binding DeleteCommand}"
+                                                    Style="{StaticResource CardActionBtnStyle}"
+                                                    Visibility="{Binding IsMine, Converter={StaticResource BoolToVisibility}}"/>
+                                            <Button Content="Report" Command="{Binding ReportCommand}"
+                                                    Style="{StaticResource CardActionBtnStyle}"
+                                                    Visibility="{Binding CanReport, Converter={StaticResource BoolToVisibility}}"/>
+                                        </StackPanel>
+
+                                        <!-- Inline edit -->
+                                        <StackPanel Margin="0,8,0,0"
+                                                    Visibility="{Binding IsEditing, Converter={StaticResource BoolToVisibility}}">
+                                            <TextBox Text="{Binding EditText, UpdateSourceTrigger=PropertyChanged}"
+                                                     AcceptsReturn="True" TextWrapping="Wrap"
+                                                     MinHeight="44" Padding="8,6" FontSize="13"
+                                                     Background="{DynamicResource Surface2Brush}"
+                                                     Foreground="{DynamicResource TextBodyBrush}"
+                                                     BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1"/>
+                                            <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,6,0,0">
+                                                <Button Content="Cancel" Command="{Binding CancelEditCommand}"
+                                                        Style="{StaticResource CardActionBtnStyle}" Margin="0,0,6,0"/>
+                                                <Button Content="Save" Command="{Binding SaveEditCommand}"
+                                                        Style="{StaticResource PrimaryBtnStyle}"/>
+                                            </StackPanel>
                                         </StackPanel>
+
+                                        <!-- Reply composer -->
+                                        <StackPanel Margin="0,8,0,0"
+                                                    Visibility="{Binding IsComposingReply, Converter={StaticResource BoolToVisibility}}">
+                                            <TextBox Text="{Binding ReplyText, UpdateSourceTrigger=PropertyChanged}"
+                                                     AcceptsReturn="True" TextWrapping="Wrap"
+                                                     MinHeight="44" Padding="8,6" FontSize="13"
+                                                     Background="{DynamicResource Surface2Brush}"
+                                                     Foreground="{DynamicResource TextBodyBrush}"
+                                                     BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1"/>
+                                            <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,6,0,0">
+                                                <Button Content="Cancel" Command="{Binding CancelReplyCommand}"
+                                                        Style="{StaticResource CardActionBtnStyle}" Margin="0,0,6,0"/>
+                                                <Button Content="Reply" Command="{Binding PostReplyCommand}"
+                                                        Style="{StaticResource PrimaryBtnStyle}"/>
+                                            </StackPanel>
+                                        </StackPanel>
+
+                                        <!-- Replies -->
+                                        <ItemsControl ItemsSource="{Binding Replies}" Margin="12,8,0,0"
+                                                      Visibility="{Binding AreRepliesVisible, Converter={StaticResource BoolToVisibility}}">
+                                            <ItemsControl.ItemTemplate>
+                                                <DataTemplate DataType="{x:Type vm:MessageItemViewModel}">
+                                                    <Border Margin="0,0,0,6"
+                                                            Background="{DynamicResource Surface2Brush}"
+                                                            BorderBrush="{DynamicResource BorderBrush}"
+                                                            BorderThickness="1" CornerRadius="3" Padding="10,8">
+                                                        <StackPanel>
+                                                            <DockPanel Margin="0,0,0,4">
+                                                                <TextBlock DockPanel.Dock="Left" Text="{Binding AuthorDisplayName}"
+                                                                           FontSize="11" FontWeight="SemiBold"
+                                                                           Foreground="{DynamicResource TextBrush}" Margin="0,0,6,0"/>
+                                                                <TextBlock DockPanel.Dock="Left" Text="{Binding AuthorHandle}"
+                                                                           FontSize="10" Foreground="{DynamicResource TextMutedBrush}"/>
+                                                                <TextBlock DockPanel.Dock="Right" Text="{Binding TimeFormatted}"
+                                                                           FontFamily="JetBrains Mono, Consolas" FontSize="10"
+                                                                           Foreground="{DynamicResource TextMutedBrush}"
+                                                                           HorizontalAlignment="Right"/>
+                                                            </DockPanel>
+                                                            <TextBlock Text="{Binding Content}" FontSize="12"
+                                                                       Foreground="{DynamicResource TextBodyBrush}"
+                                                                       TextWrapping="Wrap" LineHeight="18"/>
+                                                        </StackPanel>
+                                                    </Border>
+                                                </DataTemplate>
+                                            </ItemsControl.ItemTemplate>
+                                        </ItemsControl>
                                     </StackPanel>
 
                                 </Grid>
diff --git a/InterlinedList/Views/ListsView.xaml b/InterlinedList/Views/ListsView.xaml
index 587fdf7..a210194 100644
--- a/InterlinedList/Views/ListsView.xaml
+++ b/InterlinedList/Views/ListsView.xaml
@@ -82,6 +82,31 @@
                 </Setter.Value>
             </Setter>
         </Style>
+
+        <!-- Subtle row action (Edit / Delete) -->
+        <Style x:Key="RowActionBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextMutedBrush}"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="Padding" Value="6,2"/>
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Bg" Background="{TemplateBinding Background}"
+                                CornerRadius="3" Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Bg" Property="Background" Value="{DynamicResource Surface3Brush}"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
     </UserControl.Resources>
 
     <Grid>
@@ -214,23 +239,63 @@
                           VerticalScrollBarVisibility="Auto"
                           HorizontalScrollBarVisibility="Disabled"
                           Padding="20,12">
-                <ItemsControl ItemsSource="{Binding Rows}">
-                    <ItemsControl.ItemTemplate>
-                        <DataTemplate DataType="{x:Type models:ListDataRow}">
-                            <Border Margin="0,0,0,6"
-                                    Background="{DynamicResource Surface2Brush}"
-                                    BorderBrush="{DynamicResource BorderBrush}"
-                                    BorderThickness="1"
-                                    CornerRadius="4"
-                                    Padding="10,8">
-                                <TextBlock Text="{Binding DisplaySummary}"
-                                           FontSize="12"
-                                           Foreground="{DynamicResource TextBodyBrush}"
-                                           TextWrapping="Wrap"/>
-                            </Border>
-                        </DataTemplate>
-                    </ItemsControl.ItemTemplate>
-                </ItemsControl>
+                <StackPanel>
+                    <ItemsControl ItemsSource="{Binding Rows}">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate DataType="{x:Type models:ListDataRow}">
+                                <Border Margin="0,0,0,6"
+                                        Background="{DynamicResource Surface2Brush}"
+                                        BorderBrush="{DynamicResource BorderBrush}"
+                                        BorderThickness="1"
+                                        CornerRadius="4"
+                                        Padding="10,8">
+                                    <DockPanel>
+                                        <StackPanel DockPanel.Dock="Right" Orientation="Horizontal"
+                                                    VerticalAlignment="Top" Margin="8,0,0,0">
+                                            <Button Content="Edit"
+                                                    Command="{Binding DataContext.StartEditRowCommand,
+                                                              RelativeSource={RelativeSource AncestorType=ItemsControl}}"
+                                                    CommandParameter="{Binding}"
+                                                    Style="{StaticResource RowActionBtnStyle}"/>
+                                            <Button Content="Delete"
+                                                    Command="{Binding DataContext.DeleteRowCommand,
+                                                              RelativeSource={RelativeSource AncestorType=ItemsControl}}"
+                                                    CommandParameter="{Binding}"
+                                                    Style="{StaticResource RowActionBtnStyle}"/>
+                                        </StackPanel>
+                                        <TextBlock Text="{Binding DisplaySummary}"
+                                                   FontSize="12"
+                                                   Foreground="{DynamicResource TextBodyBrush}"
+                                                   TextWrapping="Wrap"/>
+                                    </DockPanel>
+                                </Border>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+
+                    <!-- Inline row editor -->
+                    <Border Margin="0,4,0,0"
+                            Background="{DynamicResource Surface3Brush}"
+                            BorderBrush="{DynamicResource BorderStrongBrush}"
+                            BorderThickness="1" CornerRadius="4" Padding="10,8"
+                            Visibility="{Binding IsEditingRow, Converter={StaticResource BoolToVisibility}}">
+                        <StackPanel>
+                            <TextBlock Text="Edit row (JSON)" FontSize="11" FontWeight="SemiBold"
+                                       Foreground="{DynamicResource TextBrush}" Margin="0,0,0,4"/>
+                            <TextBox Text="{Binding EditRowJson, UpdateSourceTrigger=PropertyChanged}"
+                                     Style="{StaticResource FieldStyle}"
+                                     AcceptsReturn="True" TextWrapping="Wrap"
+                                     FontFamily="JetBrains Mono, Consolas"
+                                     MinHeight="60" MaxHeight="160"/>
+                            <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,6,0,0">
+                                <Button Content="Cancel" Command="{Binding CancelEditRowCommand}"
+                                        Style="{StaticResource RowActionBtnStyle}" Margin="0,0,6,0"/>
+                                <Button Content="Save" Command="{Binding SaveRowEditCommand}"
+                                        Style="{StaticResource PrimaryBtnStyle}"/>
+                            </StackPanel>
+                        </StackPanel>
+                    </Border>
+                </StackPanel>
             </ScrollViewer>
 
             <!-- Add row -->
diff --git a/InterlinedList/Views/OrganizationsView.xaml b/InterlinedList/Views/OrganizationsView.xaml
index b766761..76ae811 100644
--- a/InterlinedList/Views/OrganizationsView.xaml
+++ b/InterlinedList/Views/OrganizationsView.xaml
@@ -112,6 +112,56 @@
             </Style.Triggers>
         </Style>
 
+        <!-- Whole management area: shown only when an org is selected -->
+        <Style x:Key="OrgDetailStyle" TargetType="FrameworkElement">
+            <Setter Property="Visibility" Value="Visible"/>
+            <Style.Triggers>
+                <DataTrigger Binding="{Binding SelectedOrganization}" Value="{x:Null}">
+                    <Setter Property="Visibility" Value="Collapsed"/>
+                </DataTrigger>
+            </Style.Triggers>
+        </Style>
+
+        <!-- Owner/admin-only affordances -->
+        <Style x:Key="ManageOnlyStyle" TargetType="FrameworkElement">
+            <Setter Property="Visibility" Value="Collapsed"/>
+            <Style.Triggers>
+                <DataTrigger Binding="{Binding CanManageMembers}" Value="True">
+                    <Setter Property="Visibility" Value="Visible"/>
+                </DataTrigger>
+            </Style.Triggers>
+        </Style>
+
+        <!-- Owner-only affordances (delete org) -->
+        <Style x:Key="OwnerOnlyStyle" TargetType="FrameworkElement">
+            <Setter Property="Visibility" Value="Collapsed"/>
+            <Style.Triggers>
+                <DataTrigger Binding="{Binding CanDeleteOrganization}" Value="True">
+                    <Setter Property="Visibility" Value="Visible"/>
+                </DataTrigger>
+            </Style.Triggers>
+        </Style>
+
+        <!-- Edit-org form: visible only while editing -->
+        <Style x:Key="EditFormStyle" TargetType="FrameworkElement">
+            <Setter Property="Visibility" Value="Collapsed"/>
+            <Style.Triggers>
+                <DataTrigger Binding="{Binding IsEditingOrganization}" Value="True">
+                    <Setter Property="Visibility" Value="Visible"/>
+                </DataTrigger>
+            </Style.Triggers>
+        </Style>
+
+        <!-- No members hint -->
+        <Style x:Key="NoMembersHintStyle" TargetType="TextBlock">
+            <Setter Property="Visibility" Value="Collapsed"/>
+            <Style.Triggers>
+                <DataTrigger Binding="{Binding Members.Count}" Value="0">
+                    <Setter Property="Visibility" Value="Visible"/>
+                </DataTrigger>
+            </Style.Triggers>
+        </Style>
+
         <!-- Visible only when SelectedOrganization.Role is non-null -->
         <Style x:Key="RoleLineStyle" TargetType="TextBlock">
             <Setter Property="Visibility" Value="Visible"/>
@@ -136,6 +186,113 @@
             </Style.Triggers>
         </Style>
 
+        <!-- Member row: avatar + name/handle + role badge, and (owner/admin only)
+             Promote / Demote / Remove actions. Item-row commands reach the VM via
+             the UserControl's DataContext. -->
+        <DataTemplate x:Key="MemberItemTemplate" DataType="{x:Type models:OrgMember}">
+            <Border Margin="0,0,0,6"
+                    Background="{DynamicResource Surface2Brush}"
+                    BorderBrush="{DynamicResource BorderBrush}"
+                    BorderThickness="1"
+                    CornerRadius="4"
+                    Padding="10,8">
+                <DockPanel>
+                    <!-- Avatar -->
+                    <Border DockPanel.Dock="Left"
+                            Width="28" Height="28"
+                            CornerRadius="999"
+                            ClipToBounds="True"
+                            Background="{DynamicResource Surface3Brush}"
+                            Margin="0,0,10,0"
+                            VerticalAlignment="Center">
+                        <Image Source="{Binding Avatar}" Stretch="UniformToFill"/>
+                    </Border>
+
+                    <!-- Management actions (owner/admin only), right-aligned -->
+                    <StackPanel DockPanel.Dock="Right"
+                                Orientation="Horizontal"
+                                VerticalAlignment="Center"
+                                Visibility="{Binding DataContext.CanManageMembers, RelativeSource={RelativeSource AncestorType=UserControl}, Converter={StaticResource BoolToVisibility}}">
+                        <Button Content="Promote"
+                                Command="{Binding DataContext.PromoteMemberCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                CommandParameter="{Binding}"
+                                Style="{StaticResource SmallBtnStyle}"
+                                Margin="0,0,6,0"/>
+                        <Button Content="Demote"
+                                Command="{Binding DataContext.DemoteMemberCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                CommandParameter="{Binding}"
+                                Style="{StaticResource SmallBtnStyle}"
+                                Margin="0,0,6,0"/>
+                        <Button Content="Remove"
+                                Command="{Binding DataContext.RemoveOrgMemberCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                CommandParameter="{Binding}"
+                                Style="{StaticResource SmallBtnStyle}"/>
+                    </StackPanel>
+
+                    <!-- Role badge (always shown) -->
+                    <Border DockPanel.Dock="Right"
+                            Background="{StaticResource TealBrush}"
+                            CornerRadius="3"
+                            Padding="6,2"
+                            Margin="8,0,10,0"
+                            VerticalAlignment="Center">
+                        <TextBlock Text="{Binding RoleLabel}"
+                                   FontSize="9" FontWeight="SemiBold"
+                                   Foreground="White"/>
+                    </Border>
+
+                    <!-- Name + handle -->
+                    <StackPanel VerticalAlignment="Center">
+                        <TextBlock Text="{Binding DisplayNameOrUsername}"
+                                   FontSize="13" FontWeight="SemiBold"
+                                   Foreground="{DynamicResource TextBrush}"/>
+                        <TextBlock Text="{Binding Handle}"
+                                   FontSize="11"
+                                   FontFamily="JetBrains Mono, Consolas"
+                                   Foreground="{DynamicResource TextMutedBrush}"/>
+                    </StackPanel>
+                </DockPanel>
+            </Border>
+        </DataTemplate>
+
+        <!-- User search result row (add-member picker): clicking adds as "member". -->
+        <DataTemplate x:Key="UserResultTemplate" DataType="{x:Type models:UserSearchResult}">
+            <Border Margin="0,0,0,6"
+                    Background="{DynamicResource Surface2Brush}"
+                    BorderBrush="{DynamicResource BorderBrush}"
+                    BorderThickness="1"
+                    CornerRadius="4"
+                    Padding="10,8">
+                <DockPanel>
+                    <Border DockPanel.Dock="Left"
+                            Width="28" Height="28"
+                            CornerRadius="999"
+                            ClipToBounds="True"
+                            Background="{DynamicResource Surface3Brush}"
+                            Margin="0,0,10,0"
+                            VerticalAlignment="Center">
+                        <Image Source="{Binding Avatar}" Stretch="UniformToFill"/>
+                    </Border>
+                    <Button DockPanel.Dock="Right"
+                            Content="Add"
+                            Command="{Binding DataContext.AddMemberCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                            CommandParameter="{Binding}"
+                            Style="{StaticResource PrimaryBtnStyle}"
+                            VerticalAlignment="Center"/>
+                    <StackPanel VerticalAlignment="Center">
+                        <TextBlock Text="{Binding DisplayName}"
+                                   FontSize="13" FontWeight="SemiBold"
+                                   Foreground="{DynamicResource TextBrush}"/>
+                        <TextBlock FontSize="11"
+                                   FontFamily="JetBrains Mono, Consolas"
+                                   Foreground="{DynamicResource TextMutedBrush}">
+                            <Run Text="@"/><Run Text="{Binding Username, Mode=OneWay}"/>
+                        </TextBlock>
+                    </StackPanel>
+                </DockPanel>
+            </Border>
+        </DataTemplate>
+
         <DataTemplate x:Key="OrgItemTemplate" DataType="{x:Type models:OrganizationSummary}">
             <Border Margin="0,0,0,8"
                     Background="{DynamicResource Surface2Brush}"
@@ -212,7 +369,7 @@
                                Style="{StaticResource ErrorTextStyle}"/>
 
                     <!-- Member management note -->
-                    <TextBlock Text="Member lists and invitations aren't available in this app — that part of the API requires a browser session, not a device sign-in, so it can't work from this client. Manage members at interlinedlist.com."
+                    <TextBlock Text="Select an organization to view its members. Owners and admins can add, remove, and change the roles of members here."
                                FontSize="11"
                                FontStyle="Italic"
                                Foreground="{DynamicResource TextMutedBrush}"
@@ -287,26 +444,110 @@
             </Border>
 
             <Grid Grid.Row="1">
-                <StackPanel Margin="20,16" MaxWidth="560" HorizontalAlignment="Left">
-                    <TextBlock Text="{Binding SelectedOrganization.Description}"
-                               FontSize="13"
-                               Foreground="{DynamicResource TextBodyBrush}"
-                               TextWrapping="Wrap"
-                               Margin="0,0,0,12"/>
-                    <TextBlock FontSize="12" Foreground="{DynamicResource TextMutedBrush}" Margin="0,0,0,4">
-                        <Run Text="Slug: "/><Run Text="{Binding SelectedOrganization.Slug, Mode=OneWay}"/>
-                    </TextBlock>
-                    <TextBlock FontSize="12" Foreground="{DynamicResource TextMutedBrush}" Margin="0,0,0,4">
-                        <Run Text="Members: "/><Run Text="{Binding SelectedOrganization.MemberCount, Mode=OneWay}"/>
-                    </TextBlock>
-                    <TextBlock FontSize="12" Foreground="{DynamicResource TextMutedBrush}" Margin="0,0,0,4">
-                        <Run Text="Visibility: "/><Run Text="{Binding SelectedOrganization.IsPublic, Mode=OneWay}"/>
-                    </TextBlock>
-                    <TextBlock FontSize="12" Foreground="{DynamicResource TextMutedBrush}"
-                               Style="{StaticResource RoleLineStyle}">
-                        <Run Text="Your role: "/><Run Text="{Binding SelectedOrganization.Role, Mode=OneWay}"/>
-                    </TextBlock>
-                </StackPanel>
+                <ScrollViewer VerticalScrollBarVisibility="Auto"
+                              HorizontalScrollBarVisibility="Disabled"
+                              Style="{StaticResource OrgDetailStyle}">
+                    <StackPanel Margin="20,16" MaxWidth="620" HorizontalAlignment="Left">
+                        <TextBlock Text="{Binding SelectedOrganization.Description}"
+                                   FontSize="13"
+                                   Foreground="{DynamicResource TextBodyBrush}"
+                                   TextWrapping="Wrap"
+                                   Margin="0,0,0,12"/>
+                        <TextBlock FontSize="12" Foreground="{DynamicResource TextMutedBrush}" Margin="0,0,0,4">
+                            <Run Text="Slug: "/><Run Text="{Binding SelectedOrganization.Slug, Mode=OneWay}"/>
+                        </TextBlock>
+                        <TextBlock FontSize="12" Foreground="{DynamicResource TextMutedBrush}" Margin="0,0,0,4">
+                            <Run Text="Members: "/><Run Text="{Binding SelectedOrganization.MemberCount, Mode=OneWay}"/>
+                        </TextBlock>
+                        <TextBlock FontSize="12" Foreground="{DynamicResource TextMutedBrush}" Margin="0,0,0,4">
+                            <Run Text="Visibility: "/><Run Text="{Binding SelectedOrganization.IsPublic, Mode=OneWay}"/>
+                        </TextBlock>
+                        <TextBlock FontSize="12" Foreground="{DynamicResource TextMutedBrush}"
+                                   Style="{StaticResource RoleLineStyle}">
+                            <Run Text="Your role: "/><Run Text="{Binding SelectedOrganization.Role, Mode=OneWay}"/>
+                        </TextBlock>
+
+                        <!-- Owner/admin: edit / delete org affordances -->
+                        <StackPanel Orientation="Horizontal"
+                                    Margin="0,12,0,0"
+                                    Style="{StaticResource ManageOnlyStyle}">
+                            <Button Content="Edit organization"
+                                    Command="{Binding BeginEditOrganizationCommand}"
+                                    Style="{StaticResource SmallBtnStyle}"
+                                    Margin="0,0,8,0"/>
+                            <Button Content="Delete organization"
+                                    Command="{Binding DeleteOrganizationCommand}"
+                                    Style="{StaticResource SmallBtnStyle}"
+                                    Foreground="#FFE81123"
+                                    BorderBrush="#FFE81123"
+                                    Visibility="{Binding CanDeleteOrganization, Converter={StaticResource BoolToVisibility}}"/>
+                        </StackPanel>
+
+                        <!-- Edit-org form (visible while editing) -->
+                        <StackPanel Margin="0,12,0,0"
+                                    Style="{StaticResource EditFormStyle}">
+                            <TextBlock Text="EDIT ORGANIZATION"
+                                       FontSize="10" FontWeight="SemiBold"
+                                       Foreground="{DynamicResource TextMutedBrush}"
+                                       Margin="0,0,0,8"/>
+                            <TextBox Text="{Binding EditOrgName, UpdateSourceTrigger=PropertyChanged}"
+                                     Style="{StaticResource FieldStyle}"/>
+                            <TextBox Text="{Binding EditOrgDescription, UpdateSourceTrigger=PropertyChanged}"
+                                     Style="{StaticResource FieldStyle}"
+                                     AcceptsReturn="True"
+                                     TextWrapping="Wrap"
+                                     MinHeight="52"/>
+                            <CheckBox Content="Public organization"
+                                      IsChecked="{Binding EditOrgIsPublic}"
+                                      Foreground="{DynamicResource TextBodyBrush}"
+                                      FontSize="12"
+                                      Margin="0,0,0,8"/>
+                            <StackPanel Orientation="Horizontal">
+                                <Button Content="Save changes"
+                                        Command="{Binding SaveOrganizationCommand}"
+                                        Style="{StaticResource PrimaryBtnStyle}"
+                                        Margin="0,0,8,0"/>
+                                <Button Content="Cancel"
+                                        Command="{Binding CancelEditOrganizationCommand}"
+                                        Style="{StaticResource SmallBtnStyle}"/>
+                            </StackPanel>
+                        </StackPanel>
+
+                        <!-- Members -->
+                        <TextBlock Text="MEMBERS"
+                                   FontSize="10" FontWeight="SemiBold"
+                                   Foreground="{DynamicResource TextMutedBrush}"
+                                   Margin="0,20,0,8"/>
+                        <ItemsControl ItemsSource="{Binding Members}"
+                                      ItemTemplate="{StaticResource MemberItemTemplate}"/>
+                        <TextBlock Text="No members to show."
+                                   FontSize="11"
+                                   Foreground="{DynamicResource TextMutedBrush}"
+                                   Style="{StaticResource NoMembersHintStyle}"/>
+
+                        <!-- Add member (owner/admin only) -->
+                        <StackPanel Margin="0,16,0,0"
+                                    Style="{StaticResource ManageOnlyStyle}">
+                            <TextBlock Text="ADD MEMBER"
+                                       FontSize="10" FontWeight="SemiBold"
+                                       Foreground="{DynamicResource TextMutedBrush}"
+                                       Margin="0,0,0,8"/>
+                            <DockPanel Margin="0,0,0,8">
+                                <Button DockPanel.Dock="Right"
+                                        Content="Search"
+                                        Command="{Binding SearchUsersCommand}"
+                                        Style="{StaticResource PrimaryBtnStyle}"
+                                        Margin="8,0,0,0"/>
+                                <TextBox Text="{Binding MemberSearchQuery, UpdateSourceTrigger=PropertyChanged}"
+                                         Style="{StaticResource FieldStyle}"
+                                         Margin="0"
+                                         VerticalContentAlignment="Center"/>
+                            </DockPanel>
+                            <ItemsControl ItemsSource="{Binding UserSearchResults}"
+                                          ItemTemplate="{StaticResource UserResultTemplate}"/>
+                        </StackPanel>
+                    </StackPanel>
+                </ScrollViewer>
 
                 <TextBlock Text="Select an organization to see its details."
                            FontSize="13"
diff --git a/InterlinedList/Views/PeopleView.xaml b/InterlinedList/Views/PeopleView.xaml
new file mode 100644
index 0000000..13b9826
--- /dev/null
+++ b/InterlinedList/Views/PeopleView.xaml
@@ -0,0 +1,443 @@
+<UserControl x:Class="InterlinedList.Views.PeopleView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="clr-namespace:InterlinedList.ViewModels"
+             xmlns:local="clr-namespace:InterlinedList.Views"
+             Background="{DynamicResource AppBgBrush}">
+
+    <UserControl.Resources>
+        <BooleanToVisibilityConverter x:Key="BoolToVis"/>
+
+        <!-- Primary green button -->
+        <Style x:Key="PrimaryBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="{DynamicResource PrimaryBrush}"/>
+            <Setter Property="Foreground" Value="White"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="Padding" Value="16,6"/>
+            <Setter Property="FontSize" Value="13"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Bg"
+                                Background="{TemplateBinding Background}"
+                                CornerRadius="4"
+                                Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Bg" Property="Background"
+                                        Value="{DynamicResource PrimaryHoverBrush}"/>
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter TargetName="Bg" Property="Opacity" Value="0.5"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- Amber Dig / reject button -->
+        <Style x:Key="DigBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="{StaticResource AmberBrush}"/>
+            <Setter Property="BorderBrush" Value="{StaticResource AmberBrush}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="Padding" Value="10,2"/>
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Bg"
+                                Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}"
+                                CornerRadius="3"
+                                Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Bg" Property="Background" Value="#1AF0A830"/>
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter TargetName="Bg" Property="Opacity" Value="0.5"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+    </UserControl.Resources>
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>  <!-- Header -->
+            <RowDefinition Height="Auto"/>  <!-- Error banner -->
+            <RowDefinition Height="*"/>     <!-- Body -->
+        </Grid.RowDefinitions>
+
+        <!-- Header -->
+        <Border Grid.Row="0"
+                Background="{DynamicResource SurfaceBrush}"
+                BorderBrush="{DynamicResource BorderBrush}"
+                BorderThickness="0,0,0,1"
+                Padding="20,12">
+            <Grid>
+                <TextBlock Text="People"
+                           FontSize="17" FontWeight="SemiBold"
+                           Foreground="{DynamicResource TextBrush}"
+                           VerticalAlignment="Center"/>
+                <TextBlock Text="Loading…"
+                           HorizontalAlignment="Right"
+                           FontSize="12"
+                           Foreground="{DynamicResource TextMutedBrush}"
+                           Visibility="{Binding IsLoading, Converter={StaticResource BoolToVis}}"/>
+            </Grid>
+        </Border>
+
+        <!-- Error banner -->
+        <Border Grid.Row="1"
+                Background="#1AE81123"
+                Padding="20,8">
+            <Border.Style>
+                <Style TargetType="Border">
+                    <Setter Property="Visibility" Value="Visible"/>
+                    <Style.Triggers>
+                        <DataTrigger Binding="{Binding ErrorMessage}" Value="{x:Null}">
+                            <Setter Property="Visibility" Value="Collapsed"/>
+                        </DataTrigger>
+                    </Style.Triggers>
+                </Style>
+            </Border.Style>
+            <TextBlock Text="{Binding ErrorMessage}"
+                       FontSize="12"
+                       Foreground="#FFE81123"
+                       TextWrapping="Wrap"/>
+        </Border>
+
+        <!-- Body -->
+        <ScrollViewer Grid.Row="2"
+                      VerticalScrollBarVisibility="Auto"
+                      HorizontalScrollBarVisibility="Disabled"
+                      Padding="16,12">
+            <StackPanel>
+
+                <!-- 1. Follow requests -->
+                <Border Margin="0,0,0,12"
+                        Background="{DynamicResource SurfaceBrush}"
+                        BorderBrush="{DynamicResource BorderBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="16,12"
+                        Visibility="{Binding HasRequests, Converter={StaticResource BoolToVis}}">
+                    <StackPanel>
+                        <TextBlock Text="Follow requests"
+                                   FontSize="14" FontWeight="SemiBold"
+                                   Foreground="{DynamicResource TextBrush}"
+                                   Margin="0,0,0,8"/>
+                        <ItemsControl ItemsSource="{Binding FollowRequests}">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate>
+                                    <Grid Margin="0,4">
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="Auto"/>
+                                            <ColumnDefinition Width="*"/>
+                                            <ColumnDefinition Width="Auto"/>
+                                        </Grid.ColumnDefinitions>
+
+                                        <!-- Avatar -->
+                                        <Border Grid.Column="0"
+                                                Width="24" Height="24"
+                                                CornerRadius="999"
+                                                ClipToBounds="True"
+                                                Background="{DynamicResource Surface3Brush}"
+                                                VerticalAlignment="Center"
+                                                Margin="0,0,8,0">
+                                            <Image Source="{Binding Avatar}" Stretch="UniformToFill"/>
+                                        </Border>
+
+                                        <!-- Name + handle -->
+                                        <StackPanel Grid.Column="1" VerticalAlignment="Center">
+                                            <TextBlock Text="{Binding DisplayNameOrUsername}"
+                                                       FontSize="12" FontWeight="SemiBold"
+                                                       Foreground="{DynamicResource TextBrush}"/>
+                                            <TextBlock Text="{Binding Handle}"
+                                                       FontSize="11"
+                                                       Foreground="{DynamicResource TextMutedBrush}"/>
+                                        </StackPanel>
+
+                                        <!-- Actions -->
+                                        <StackPanel Grid.Column="2" Orientation="Horizontal"
+                                                    VerticalAlignment="Center">
+                                            <Button Content="Approve"
+                                                    Command="{Binding DataContext.ApproveCommand,
+                                                              RelativeSource={RelativeSource AncestorType=ItemsControl}}"
+                                                    CommandParameter="{Binding}"
+                                                    Style="{StaticResource PrimaryBtnStyle}"
+                                                    Margin="0,0,6,0"/>
+                                            <Button Content="Reject"
+                                                    Command="{Binding DataContext.RejectCommand,
+                                                              RelativeSource={RelativeSource AncestorType=ItemsControl}}"
+                                                    CommandParameter="{Binding}"
+                                                    Style="{StaticResource DigBtnStyle}"/>
+                                        </StackPanel>
+                                    </Grid>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+                    </StackPanel>
+                </Border>
+
+                <!-- 2. Lookup -->
+                <Border Margin="0,0,0,12"
+                        Background="{DynamicResource Surface2Brush}"
+                        BorderBrush="{DynamicResource BorderBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="16,12">
+                    <StackPanel>
+                        <TextBlock Text="Find someone"
+                                   FontSize="14" FontWeight="SemiBold"
+                                   Foreground="{DynamicResource TextBrush}"
+                                   Margin="0,0,0,8"/>
+                        <Grid>
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="*"/>
+                                <ColumnDefinition Width="Auto"/>
+                            </Grid.ColumnDefinitions>
+                            <TextBox Grid.Column="0"
+                                     Text="{Binding LookupUsername, UpdateSourceTrigger=PropertyChanged}"
+                                     Padding="10,6"
+                                     FontSize="13"
+                                     VerticalContentAlignment="Center"
+                                     Background="{DynamicResource SurfaceBrush}"
+                                     Foreground="{DynamicResource TextBodyBrush}"
+                                     BorderBrush="{DynamicResource BorderBrush}"
+                                     BorderThickness="1"/>
+                            <Button Grid.Column="1"
+                                    Content="View profile"
+                                    Command="{Binding LoadProfileCommand}"
+                                    Style="{StaticResource PrimaryBtnStyle}"
+                                    Margin="8,0,0,0"/>
+                        </Grid>
+                    </StackPanel>
+                </Border>
+
+                <!-- 3. Profile card -->
+                <StackPanel Visibility="{Binding HasProfile, Converter={StaticResource BoolToVis}}">
+                    <Border Margin="0,0,0,12"
+                            Background="{DynamicResource SurfaceBrush}"
+                            BorderBrush="{DynamicResource BorderBrush}"
+                            BorderThickness="1"
+                            CornerRadius="4"
+                            Padding="16,14">
+                        <StackPanel>
+                            <!-- Identity row -->
+                            <Grid>
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="Auto"/>
+                                    <ColumnDefinition Width="*"/>
+                                    <ColumnDefinition Width="Auto"/>
+                                </Grid.ColumnDefinitions>
+
+                                <!-- Avatar -->
+                                <Border Grid.Column="0"
+                                        Width="56" Height="56"
+                                        CornerRadius="999"
+                                        ClipToBounds="True"
+                                        Background="{DynamicResource Surface3Brush}"
+                                        VerticalAlignment="Top"
+                                        Margin="0,0,12,0">
+                                    <Image Source="{Binding Profile.Avatar}" Stretch="UniformToFill"/>
+                                </Border>
+
+                                <!-- Name / handle / bio -->
+                                <StackPanel Grid.Column="1" VerticalAlignment="Center">
+                                    <TextBlock Text="{Binding Profile.DisplayNameOrUsername}"
+                                               FontSize="16" FontWeight="SemiBold"
+                                               Foreground="{DynamicResource TextBrush}"/>
+                                    <TextBlock Text="{Binding Profile.Handle}"
+                                               FontSize="12"
+                                               Foreground="{DynamicResource TextMutedBrush}"
+                                               Margin="0,1,0,0"/>
+                                    <TextBlock Text="{Binding Profile.Bio}"
+                                               FontSize="13"
+                                               Foreground="{DynamicResource TextBodyBrush}"
+                                               TextWrapping="Wrap"
+                                               LineHeight="19"
+                                               Margin="0,6,0,0"/>
+                                </StackPanel>
+
+                                <!-- Follow / Unfollow + moderation -->
+                                <StackPanel Grid.Column="2" VerticalAlignment="Top">
+                                    <Button Content="{Binding FollowButtonText}"
+                                            Command="{Binding ToggleFollowCommand}"
+                                            Style="{StaticResource PrimaryBtnStyle}"
+                                            HorizontalAlignment="Right"/>
+                                    <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,6,0,0">
+                                        <Button Content="{Binding BlockButtonText}"
+                                                Command="{Binding ToggleBlockCommand}"
+                                                Style="{StaticResource DigBtnStyle}" Margin="0,0,6,0"/>
+                                        <Button Content="{Binding MuteButtonText}"
+                                                Command="{Binding ToggleMuteCommand}"
+                                                Style="{StaticResource DigBtnStyle}" Margin="0,0,6,0"/>
+                                        <Button Content="Report"
+                                                Command="{Binding ReportCommand}"
+                                                Style="{StaticResource DigBtnStyle}"/>
+                                    </StackPanel>
+                                </StackPanel>
+                            </Grid>
+
+                            <!-- Stats row -->
+                            <StackPanel Orientation="Horizontal" Margin="0,14,0,0">
+                                <StackPanel Margin="0,0,24,0">
+                                    <TextBlock Text="{Binding Profile.FollowerCount}"
+                                               FontFamily="JetBrains Mono, Consolas"
+                                               FontSize="15" FontWeight="SemiBold"
+                                               Foreground="{DynamicResource TextBrush}"/>
+                                    <TextBlock Text="Followers"
+                                               FontSize="11"
+                                               Foreground="{DynamicResource TextMutedBrush}"/>
+                                </StackPanel>
+                                <StackPanel Margin="0,0,24,0">
+                                    <TextBlock Text="{Binding Profile.FollowingCount}"
+                                               FontFamily="JetBrains Mono, Consolas"
+                                               FontSize="15" FontWeight="SemiBold"
+                                               Foreground="{DynamicResource TextBrush}"/>
+                                    <TextBlock Text="Following"
+                                               FontSize="11"
+                                               Foreground="{DynamicResource TextMutedBrush}"/>
+                                </StackPanel>
+                                <StackPanel Margin="0,0,24,0">
+                                    <TextBlock Text="{Binding Profile.PublicListCount}"
+                                               FontFamily="JetBrains Mono, Consolas"
+                                               FontSize="15" FontWeight="SemiBold"
+                                               Foreground="{DynamicResource TextBrush}"/>
+                                    <TextBlock Text="Lists"
+                                               FontSize="11"
+                                               Foreground="{DynamicResource TextMutedBrush}"/>
+                                </StackPanel>
+                                <StackPanel>
+                                    <TextBlock Text="{Binding Profile.PublicMessageCount}"
+                                               FontFamily="JetBrains Mono, Consolas"
+                                               FontSize="15" FontWeight="SemiBold"
+                                               Foreground="{DynamicResource TextBrush}"/>
+                                    <TextBlock Text="Posts"
+                                               FontSize="11"
+                                               Foreground="{DynamicResource TextMutedBrush}"/>
+                                </StackPanel>
+                            </StackPanel>
+                        </StackPanel>
+                    </Border>
+
+                    <!-- Recent messages -->
+                    <ItemsControl ItemsSource="{Binding Messages}">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate DataType="{x:Type vm:MessageItemViewModel}">
+                                <Border Margin="0,0,0,8"
+                                        Background="{DynamicResource SurfaceBrush}"
+                                        BorderBrush="{DynamicResource BorderBrush}"
+                                        BorderThickness="1"
+                                        CornerRadius="4">
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="4"/>
+                                            <ColumnDefinition Width="*"/>
+                                        </Grid.ColumnDefinitions>
+
+                                        <!-- Left edge: amber once Dug, teal otherwise -->
+                                        <Border Grid.Column="0" CornerRadius="4,0,0,4">
+                                            <Border.Style>
+                                                <Style TargetType="Border">
+                                                    <Setter Property="Background" Value="{StaticResource TealBrush}"/>
+                                                    <Style.Triggers>
+                                                        <DataTrigger Binding="{Binding DugByMe}" Value="True">
+                                                            <Setter Property="Background" Value="{StaticResource AmberBrush}"/>
+                                                        </DataTrigger>
+                                                    </Style.Triggers>
+                                                </Style>
+                                            </Border.Style>
+                                        </Border>
+
+                                        <!-- Card content -->
+                                        <StackPanel Grid.Column="1" Margin="12,10">
+
+                                            <!-- Header row -->
+                                            <DockPanel Margin="0,0,0,6">
+                                                <Border DockPanel.Dock="Left"
+                                                        Width="24" Height="24"
+                                                        CornerRadius="999"
+                                                        ClipToBounds="True"
+                                                        Background="{DynamicResource Surface3Brush}"
+                                                        Margin="0,0,8,0">
+                                                    <Image Source="{Binding AvatarUrl}" Stretch="UniformToFill"/>
+                                                </Border>
+                                                <TextBlock DockPanel.Dock="Left"
+                                                           Text="{Binding AuthorDisplayName}"
+                                                           FontSize="12" FontWeight="SemiBold"
+                                                           Foreground="{DynamicResource TextBrush}"
+                                                           VerticalAlignment="Center"
+                                                           Margin="0,0,6,0"/>
+                                                <TextBlock DockPanel.Dock="Left"
+                                                           Text="{Binding AuthorHandle}"
+                                                           FontSize="11"
+                                                           Foreground="{DynamicResource TextMutedBrush}"
+                                                           VerticalAlignment="Center"
+                                                           Margin="0,0,8,0"/>
+                                                <TextBlock DockPanel.Dock="Right"
+                                                           Text="{Binding TimeFormatted}"
+                                                           FontFamily="JetBrains Mono, Consolas"
+                                                           FontSize="10"
+                                                           Foreground="{DynamicResource TextMutedBrush}"
+                                                           HorizontalAlignment="Right"/>
+                                            </DockPanel>
+
+                                            <!-- Body -->
+                                            <TextBlock Text="{Binding Content}"
+                                                       FontSize="13"
+                                                       Foreground="{DynamicResource TextBodyBrush}"
+                                                       TextWrapping="Wrap"
+                                                       LineHeight="20"
+                                                       Margin="0,0,0,8"/>
+
+                                            <!-- Footer: Dig -->
+                                            <StackPanel Orientation="Horizontal">
+                                                <Button Content="Dig"
+                                                        Command="{Binding DigCommand}">
+                                                    <Button.Style>
+                                                        <Style TargetType="Button" BasedOn="{StaticResource DigBtnStyle}">
+                                                            <Style.Triggers>
+                                                                <DataTrigger Binding="{Binding DugByMe}" Value="True">
+                                                                    <Setter Property="Background" Value="{StaticResource AmberBrush}"/>
+                                                                    <Setter Property="Foreground" Value="White"/>
+                                                                </DataTrigger>
+                                                            </Style.Triggers>
+                                                        </Style>
+                                                    </Button.Style>
+                                                </Button>
+                                                <TextBlock Text="{Binding DigCount}"
+                                                           FontFamily="JetBrains Mono, Consolas"
+                                                           FontSize="10"
+                                                           Foreground="{DynamicResource TextMutedBrush}"
+                                                           VerticalAlignment="Center"
+                                                           Margin="8,0,0,0"/>
+                                            </StackPanel>
+                                        </StackPanel>
+
+                                    </Grid>
+                                </Border>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                </StackPanel>
+
+            </StackPanel>
+        </ScrollViewer>
+    </Grid>
+</UserControl>
diff --git a/InterlinedList/Views/PeopleView.xaml.cs b/InterlinedList/Views/PeopleView.xaml.cs
new file mode 100644
index 0000000..b0449e6
--- /dev/null
+++ b/InterlinedList/Views/PeopleView.xaml.cs
@@ -0,0 +1,24 @@
+using System.Windows.Controls;
+using InterlinedList.ViewModels;
+
+namespace InterlinedList.Views;
+
+public partial class PeopleView : UserControl
+{
+    private readonly ProfileViewModel _vm;
+
+    public PeopleView()
+    {
+        InitializeComponent();
+        _vm = new ProfileViewModel(Services.AppServices.Session);
+        DataContext = _vm;
+        _ = _vm.LoadCommand.ExecuteAsync(null);
+    }
+
+    /// <summary>Open a specific user's profile (used by shell navigation from a feed/search card).</summary>
+    public void LoadProfile(string username)
+    {
+        _vm.LookupUsername = username;
+        _ = _vm.LoadProfileCommand.ExecuteAsync(null);
+    }
+}
diff --git a/InterlinedList/Views/SettingsView.xaml b/InterlinedList/Views/SettingsView.xaml
new file mode 100644
index 0000000..27f0dbd
--- /dev/null
+++ b/InterlinedList/Views/SettingsView.xaml
@@ -0,0 +1,562 @@
+<UserControl x:Class="InterlinedList.Views.SettingsView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="clr-namespace:InterlinedList.ViewModels"
+             xmlns:models="clr-namespace:InterlinedList.Models"
+             xmlns:local="clr-namespace:InterlinedList.Views"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             mc:Ignorable="d"
+             d:DesignHeight="900" d:DesignWidth="720"
+             Background="{DynamicResource AppBgBrush}">
+
+    <UserControl.Resources>
+        <BooleanToVisibilityConverter x:Key="BoolToVisibility"/>
+        <local:NullOrEmptyToVisibilityConverter x:Key="NullOrEmptyToVisibility"/>
+
+        <!-- Text field -->
+        <Style x:Key="FieldStyle" TargetType="TextBox">
+            <Setter Property="Background" Value="{DynamicResource SurfaceBrush}"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextBodyBrush}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource BorderBrush}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="Padding" Value="8,6"/>
+            <Setter Property="FontSize" Value="13"/>
+        </Style>
+
+        <!-- Primary green button -->
+        <Style x:Key="PrimaryBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="{DynamicResource PrimaryBrush}"/>
+            <Setter Property="Foreground" Value="White"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="Padding" Value="16,6"/>
+            <Setter Property="FontSize" Value="13"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Bg"
+                                Background="{TemplateBinding Background}"
+                                CornerRadius="4"
+                                Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Bg" Property="Background"
+                                        Value="{DynamicResource PrimaryHoverBrush}"/>
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter TargetName="Bg" Property="Opacity" Value="0.5"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- Amber Dig-style button (used for Revoke / Unblock / Unmute) -->
+        <Style x:Key="DigBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="{StaticResource AmberBrush}"/>
+            <Setter Property="BorderBrush" Value="{StaticResource AmberBrush}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="Padding" Value="10,2"/>
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border x:Name="Bg"
+                                Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}"
+                                CornerRadius="3"
+                                Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Bg" Property="Background" Value="#1AF0A830"/>
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter TargetName="Bg" Property="Opacity" Value="0.5"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- Small ghost button (Refresh) -->
+        <Style x:Key="SmallBtnStyle" TargetType="Button">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextMutedBrush}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource BorderBrush}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="Padding" Value="10,3"/>
+            <Setter Property="FontSize" Value="11"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}"
+                                CornerRadius="3"
+                                Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter Property="Opacity" Value="0.5"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- Section card header text -->
+        <Style x:Key="SectionTitleStyle" TargetType="TextBlock">
+            <Setter Property="FontSize" Value="14"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextBrush}"/>
+        </Style>
+
+        <Style x:Key="SubtleTextStyle" TargetType="TextBlock">
+            <Setter Property="FontSize" Value="12"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextMutedBrush}"/>
+            <Setter Property="TextWrapping" Value="Wrap"/>
+        </Style>
+
+        <Style x:Key="FieldLabelStyle" TargetType="TextBlock">
+            <Setter Property="FontSize" Value="12"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextBrush}"/>
+        </Style>
+
+        <Style x:Key="MonoMetaStyle" TargetType="TextBlock">
+            <Setter Property="FontFamily" Value="JetBrains Mono, Consolas"/>
+            <Setter Property="FontSize" Value="10"/>
+            <Setter Property="Foreground" Value="{DynamicResource TextMutedBrush}"/>
+        </Style>
+    </UserControl.Resources>
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>  <!-- Header -->
+            <RowDefinition Height="Auto"/>  <!-- Error banner -->
+            <RowDefinition Height="*"/>     <!-- Sections -->
+        </Grid.RowDefinitions>
+
+        <!-- Header -->
+        <Border Grid.Row="0"
+                Background="{DynamicResource SurfaceBrush}"
+                BorderBrush="{DynamicResource BorderBrush}"
+                BorderThickness="0,0,0,1"
+                Padding="20,12">
+            <Grid>
+                <TextBlock Text="Settings"
+                           FontSize="17" FontWeight="SemiBold"
+                           Foreground="{DynamicResource TextBrush}"
+                           VerticalAlignment="Center"/>
+                <TextBlock Text="Working…"
+                           HorizontalAlignment="Right"
+                           FontSize="12"
+                           Foreground="{DynamicResource TextMutedBrush}"
+                           VerticalAlignment="Center"
+                           Visibility="{Binding IsBusy, Converter={StaticResource BoolToVisibility}}"/>
+            </Grid>
+        </Border>
+
+        <!-- Error banner -->
+        <Border Grid.Row="1"
+                Background="#1AE81123"
+                Padding="20,8">
+            <Border.Style>
+                <Style TargetType="Border">
+                    <Setter Property="Visibility" Value="Visible"/>
+                    <Style.Triggers>
+                        <DataTrigger Binding="{Binding ErrorMessage}" Value="{x:Null}">
+                            <Setter Property="Visibility" Value="Collapsed"/>
+                        </DataTrigger>
+                    </Style.Triggers>
+                </Style>
+            </Border.Style>
+            <TextBlock Text="{Binding ErrorMessage}"
+                       FontSize="12"
+                       Foreground="#FFE81123"
+                       TextWrapping="Wrap"/>
+        </Border>
+
+        <!-- Sections -->
+        <ScrollViewer Grid.Row="2"
+                      VerticalScrollBarVisibility="Auto"
+                      HorizontalScrollBarVisibility="Disabled"
+                      Padding="20,16">
+            <StackPanel>
+
+                <!-- ============ Profile ============ -->
+                <Border Background="{DynamicResource SurfaceBrush}"
+                        BorderBrush="{DynamicResource BorderBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="16"
+                        Margin="0,0,0,16">
+                    <StackPanel>
+                        <TextBlock Text="Profile" Style="{StaticResource SectionTitleStyle}"/>
+                        <TextBlock Text="Change how you appear to others."
+                                   Style="{StaticResource SubtleTextStyle}"
+                                   Margin="0,4,0,12"/>
+
+                        <TextBlock Text="Display name"
+                                   Style="{StaticResource FieldLabelStyle}"
+                                   Margin="0,0,0,4"/>
+                        <TextBox Text="{Binding DisplayName, UpdateSourceTrigger=PropertyChanged}"
+                                 Style="{StaticResource FieldStyle}"
+                                 Margin="0,0,0,12"/>
+
+                        <TextBlock Text="Bio"
+                                   Style="{StaticResource FieldLabelStyle}"
+                                   Margin="0,0,0,4"/>
+                        <TextBox Text="{Binding Bio, UpdateSourceTrigger=PropertyChanged}"
+                                 Style="{StaticResource FieldStyle}"
+                                 AcceptsReturn="True"
+                                 TextWrapping="Wrap"
+                                 MinHeight="72"
+                                 MaxHeight="160"
+                                 VerticalScrollBarVisibility="Auto"
+                                 Margin="0,0,0,12"/>
+
+                        <CheckBox Content="Private account"
+                                  IsChecked="{Binding IsPrivateAccount}"
+                                  Foreground="{DynamicResource TextBodyBrush}"
+                                  FontSize="13"
+                                  Margin="0,0,0,12"/>
+
+                        <Button Content="Save"
+                                Command="{Binding SaveProfileCommand}"
+                                HorizontalAlignment="Left"
+                                Style="{StaticResource PrimaryBtnStyle}"/>
+                    </StackPanel>
+                </Border>
+
+                <!-- ============ Account ============ -->
+                <Border Background="{DynamicResource SurfaceBrush}"
+                        BorderBrush="{DynamicResource BorderBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="16"
+                        Margin="0,0,0,16">
+                    <StackPanel>
+                        <TextBlock Text="Account" Style="{StaticResource SectionTitleStyle}"/>
+                        <TextBlock Text="Update your avatar or email address."
+                                   Style="{StaticResource SubtleTextStyle}"
+                                   Margin="0,4,0,12"/>
+
+                        <TextBlock Text="Avatar image URL"
+                                   Style="{StaticResource FieldLabelStyle}"
+                                   Margin="0,0,0,4"/>
+                        <DockPanel Margin="0,0,0,12">
+                            <Button DockPanel.Dock="Right" Content="Set avatar"
+                                    Command="{Binding SetAvatarCommand}"
+                                    Style="{StaticResource PrimaryBtnStyle}" Margin="8,0,0,0"/>
+                            <TextBox Text="{Binding AvatarUrl, UpdateSourceTrigger=PropertyChanged}"
+                                     Style="{StaticResource FieldStyle}"/>
+                        </DockPanel>
+
+                        <TextBlock Text="New email address"
+                                   Style="{StaticResource FieldLabelStyle}"
+                                   Margin="0,0,0,4"/>
+                        <DockPanel>
+                            <Button DockPanel.Dock="Right" Content="Request change"
+                                    Command="{Binding ChangeEmailCommand}"
+                                    Style="{StaticResource PrimaryBtnStyle}" Margin="8,0,0,0"/>
+                            <TextBox Text="{Binding NewEmail, UpdateSourceTrigger=PropertyChanged}"
+                                     Style="{StaticResource FieldStyle}"/>
+                        </DockPanel>
+                    </StackPanel>
+                </Border>
+
+                <!-- ============ API sessions ============ -->
+                <Border Background="{DynamicResource SurfaceBrush}"
+                        BorderBrush="{DynamicResource BorderBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="16"
+                        Margin="0,0,0,16">
+                    <StackPanel>
+                        <Grid>
+                            <StackPanel>
+                                <TextBlock Text="API sessions" Style="{StaticResource SectionTitleStyle}"/>
+                                <TextBlock Text="Each of these is a standing sync-token. Revoke one to cut off a lost or unrecognized device."
+                                           Style="{StaticResource SubtleTextStyle}"
+                                           Margin="0,4,0,0"/>
+                            </StackPanel>
+                            <Button Content="Refresh"
+                                    Command="{Binding LoadSessionsCommand}"
+                                    HorizontalAlignment="Right" VerticalAlignment="Top"
+                                    Style="{StaticResource SmallBtnStyle}"/>
+                        </Grid>
+
+                        <!-- The list can be hundreds of rows — bound inner scroller. -->
+                        <ScrollViewer MaxHeight="260"
+                                      VerticalScrollBarVisibility="Auto"
+                                      HorizontalScrollBarVisibility="Disabled"
+                                      Margin="0,12,0,0">
+                            <ItemsControl ItemsSource="{Binding Sessions}">
+                                <ItemsControl.ItemTemplate>
+                                    <DataTemplate DataType="{x:Type models:ApiSession}">
+                                        <Border Margin="0,0,0,8"
+                                                Background="{DynamicResource Surface2Brush}"
+                                                BorderBrush="{DynamicResource BorderBrush}"
+                                                BorderThickness="1"
+                                                CornerRadius="4"
+                                                Padding="12,10">
+                                            <Grid>
+                                                <Grid.ColumnDefinitions>
+                                                    <ColumnDefinition Width="*"/>
+                                                    <ColumnDefinition Width="Auto"/>
+                                                </Grid.ColumnDefinitions>
+                                                <StackPanel Grid.Column="0">
+                                                    <StackPanel Orientation="Horizontal">
+                                                        <TextBlock Text="{Binding DeviceLabelOrFallback}"
+                                                                   FontSize="13" FontWeight="SemiBold"
+                                                                   Foreground="{DynamicResource TextBrush}"/>
+                                                        <Border Background="{DynamicResource Surface3Brush}"
+                                                                CornerRadius="3"
+                                                                Padding="6,1"
+                                                                Margin="8,0,0,0"
+                                                                VerticalAlignment="Center"
+                                                                Visibility="{Binding IsCurrent, Converter={StaticResource BoolToVisibility}}">
+                                                            <TextBlock Text="(this device)"
+                                                                       FontSize="10"
+                                                                       Foreground="{DynamicResource TextMutedBrush}"/>
+                                                        </Border>
+                                                    </StackPanel>
+                                                    <TextBlock Text="{Binding CreatedFormatted, StringFormat='Created {0}'}"
+                                                               Style="{StaticResource MonoMetaStyle}"
+                                                               Margin="0,4,0,0"/>
+                                                    <TextBlock Text="{Binding LastUsedFormatted, StringFormat='Last used {0}'}"
+                                                               Style="{StaticResource MonoMetaStyle}"
+                                                               Margin="0,2,0,0"/>
+                                                </StackPanel>
+                                                <Button Grid.Column="1"
+                                                        Content="Revoke"
+                                                        Command="{Binding DataContext.RevokeCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                        CommandParameter="{Binding}"
+                                                        VerticalAlignment="Center"
+                                                        Style="{StaticResource DigBtnStyle}"/>
+                                            </Grid>
+                                        </Border>
+                                    </DataTemplate>
+                                </ItemsControl.ItemTemplate>
+                            </ItemsControl>
+                        </ScrollViewer>
+                    </StackPanel>
+                </Border>
+
+                <!-- ============ Notifications ============ -->
+                <Border Background="{DynamicResource SurfaceBrush}"
+                        BorderBrush="{DynamicResource BorderBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="16"
+                        Margin="0,0,0,16">
+                    <StackPanel>
+                        <TextBlock Text="Notifications" Style="{StaticResource SectionTitleStyle}"/>
+                        <TextBlock Text="Choose which events reach you, and how."
+                                   Style="{StaticResource SubtleTextStyle}"
+                                   Margin="0,4,0,12"/>
+
+                        <ItemsControl ItemsSource="{Binding Preferences}">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate DataType="{x:Type vm:NotificationPrefViewModel}">
+                                    <Border Margin="0,0,0,8"
+                                            Background="{DynamicResource Surface2Brush}"
+                                            BorderBrush="{DynamicResource BorderBrush}"
+                                            BorderThickness="1"
+                                            CornerRadius="4"
+                                            Padding="12,10">
+                                        <Grid>
+                                            <Grid.ColumnDefinitions>
+                                                <ColumnDefinition Width="*"/>
+                                                <ColumnDefinition Width="Auto"/>
+                                            </Grid.ColumnDefinitions>
+                                            <StackPanel Grid.Column="0" Margin="0,0,12,0">
+                                                <TextBlock Text="{Binding Label}"
+                                                           FontSize="13" FontWeight="SemiBold"
+                                                           Foreground="{DynamicResource TextBrush}"/>
+                                                <TextBlock Text="{Binding Description}"
+                                                           Style="{StaticResource SubtleTextStyle}"
+                                                           Margin="0,2,0,0"
+                                                           Visibility="{Binding Description, Converter={StaticResource NullOrEmptyToVisibility}}"/>
+                                            </StackPanel>
+                                            <StackPanel Grid.Column="1"
+                                                        Orientation="Horizontal"
+                                                        VerticalAlignment="Center">
+                                                <CheckBox Content="Push"
+                                                          IsChecked="{Binding Push, Mode=TwoWay}"
+                                                          Foreground="{DynamicResource TextBodyBrush}"
+                                                          FontSize="12"
+                                                          Margin="0,0,14,0"
+                                                          VerticalAlignment="Center"/>
+                                                <CheckBox Content="In-app"
+                                                          IsChecked="{Binding InApp, Mode=TwoWay}"
+                                                          Foreground="{DynamicResource TextBodyBrush}"
+                                                          FontSize="12"
+                                                          VerticalAlignment="Center"/>
+                                            </StackPanel>
+                                        </Grid>
+                                    </Border>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+                    </StackPanel>
+                </Border>
+
+                <!-- ============ Blocked & muted ============ -->
+                <Border Background="{DynamicResource SurfaceBrush}"
+                        BorderBrush="{DynamicResource BorderBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="16"
+                        Margin="0,0,0,16">
+                    <StackPanel>
+                        <TextBlock Text="Blocked &amp; muted" Style="{StaticResource SectionTitleStyle}"/>
+                        <TextBlock Text="People you've blocked or muted. Remove them here to restore visibility."
+                                   Style="{StaticResource SubtleTextStyle}"
+                                   Margin="0,4,0,12"/>
+
+                        <!-- Blocked -->
+                        <TextBlock Text="Blocked"
+                                   Style="{StaticResource FieldLabelStyle}"
+                                   Margin="0,0,0,6"/>
+                        <ItemsControl ItemsSource="{Binding BlockedUsers}" Margin="0,0,0,4">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate DataType="{x:Type models:ModeratedUser}">
+                                    <Border Margin="0,0,0,8"
+                                            Background="{DynamicResource Surface2Brush}"
+                                            BorderBrush="{DynamicResource BorderBrush}"
+                                            BorderThickness="1"
+                                            CornerRadius="4"
+                                            Padding="12,8">
+                                        <Grid>
+                                            <Grid.ColumnDefinitions>
+                                                <ColumnDefinition Width="Auto"/>
+                                                <ColumnDefinition Width="*"/>
+                                                <ColumnDefinition Width="Auto"/>
+                                            </Grid.ColumnDefinitions>
+                                            <Border Grid.Column="0"
+                                                    Width="28" Height="28"
+                                                    CornerRadius="999"
+                                                    ClipToBounds="True"
+                                                    Background="{DynamicResource Surface3Brush}"
+                                                    Margin="0,0,10,0">
+                                                <Image Source="{Binding Avatar}" Stretch="UniformToFill"/>
+                                            </Border>
+                                            <StackPanel Grid.Column="1" VerticalAlignment="Center">
+                                                <TextBlock Text="{Binding DisplayNameOrUsername}"
+                                                           FontSize="13" FontWeight="SemiBold"
+                                                           Foreground="{DynamicResource TextBrush}"/>
+                                                <TextBlock Text="{Binding Handle}"
+                                                           FontSize="11"
+                                                           Foreground="{DynamicResource TextMutedBrush}"/>
+                                            </StackPanel>
+                                            <Button Grid.Column="2"
+                                                    Content="Unblock"
+                                                    Command="{Binding DataContext.UnblockCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                    CommandParameter="{Binding}"
+                                                    VerticalAlignment="Center"
+                                                    Style="{StaticResource DigBtnStyle}"/>
+                                        </Grid>
+                                    </Border>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+
+                        <!-- Muted -->
+                        <TextBlock Text="Muted"
+                                   Style="{StaticResource FieldLabelStyle}"
+                                   Margin="0,12,0,6"/>
+                        <ItemsControl ItemsSource="{Binding MutedUsers}">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate DataType="{x:Type models:ModeratedUser}">
+                                    <Border Margin="0,0,0,8"
+                                            Background="{DynamicResource Surface2Brush}"
+                                            BorderBrush="{DynamicResource BorderBrush}"
+                                            BorderThickness="1"
+                                            CornerRadius="4"
+                                            Padding="12,8">
+                                        <Grid>
+                                            <Grid.ColumnDefinitions>
+                                                <ColumnDefinition Width="Auto"/>
+                                                <ColumnDefinition Width="*"/>
+                                                <ColumnDefinition Width="Auto"/>
+                                            </Grid.ColumnDefinitions>
+                                            <Border Grid.Column="0"
+                                                    Width="28" Height="28"
+                                                    CornerRadius="999"
+                                                    ClipToBounds="True"
+                                                    Background="{DynamicResource Surface3Brush}"
+                                                    Margin="0,0,10,0">
+                                                <Image Source="{Binding Avatar}" Stretch="UniformToFill"/>
+                                            </Border>
+                                            <StackPanel Grid.Column="1" VerticalAlignment="Center">
+                                                <TextBlock Text="{Binding DisplayNameOrUsername}"
+                                                           FontSize="13" FontWeight="SemiBold"
+                                                           Foreground="{DynamicResource TextBrush}"/>
+                                                <TextBlock Text="{Binding Handle}"
+                                                           FontSize="11"
+                                                           Foreground="{DynamicResource TextMutedBrush}"/>
+                                            </StackPanel>
+                                            <Button Grid.Column="2"
+                                                    Content="Unmute"
+                                                    Command="{Binding DataContext.UnmuteCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                    CommandParameter="{Binding}"
+                                                    VerticalAlignment="Center"
+                                                    Style="{StaticResource DigBtnStyle}"/>
+                                        </Grid>
+                                    </Border>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+                    </StackPanel>
+                </Border>
+
+                <!-- ============ Data export ============ -->
+                <Border Background="{DynamicResource SurfaceBrush}"
+                        BorderBrush="{DynamicResource BorderBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="16"
+                        Margin="0,0,0,16">
+                    <StackPanel>
+                        <TextBlock Text="Data export" Style="{StaticResource SectionTitleStyle}"/>
+                        <TextBlock Text="Download your data as CSV. You choose where to save each file."
+                                   Style="{StaticResource SubtleTextStyle}"
+                                   Margin="0,4,0,12"/>
+                        <WrapPanel>
+                            <Button Content="Export messages"
+                                    Command="{Binding ExportMessagesCommand}"
+                                    Style="{StaticResource PrimaryBtnStyle}" Margin="0,0,8,8"/>
+                            <Button Content="Export lists"
+                                    Command="{Binding ExportListsCommand}"
+                                    Style="{StaticResource PrimaryBtnStyle}" Margin="0,0,8,8"/>
+                            <Button Content="Export list rows"
+                                    Command="{Binding ExportListRowsCommand}"
+                                    Style="{StaticResource PrimaryBtnStyle}" Margin="0,0,8,8"/>
+                            <Button Content="Export follows"
+                                    Command="{Binding ExportFollowsCommand}"
+                                    Style="{StaticResource PrimaryBtnStyle}" Margin="0,0,8,8"/>
+                        </WrapPanel>
+                    </StackPanel>
+                </Border>
+
+            </StackPanel>
+        </ScrollViewer>
+    </Grid>
+</UserControl>
diff --git a/InterlinedList/Views/SettingsView.xaml.cs b/InterlinedList/Views/SettingsView.xaml.cs
new file mode 100644
index 0000000..8bd2fab
--- /dev/null
+++ b/InterlinedList/Views/SettingsView.xaml.cs
@@ -0,0 +1,15 @@
+using System.Windows.Controls;
+using InterlinedList.ViewModels;
+
+namespace InterlinedList.Views;
+
+public partial class SettingsView : UserControl
+{
+    public SettingsView()
+    {
+        InitializeComponent();
+        var vm = new SettingsViewModel(Services.AppServices.Session);
+        DataContext = vm;
+        _ = vm.LoadCommand.ExecuteAsync(null);
+    }
+}
diff --git a/the-gaps.md b/the-gaps.md
new file mode 100644
index 0000000..3934932
--- /dev/null
+++ b/the-gaps.md
@@ -0,0 +1,435 @@
+# The Gaps — InterlinedList Windows App vs. interlinedlist.com
+
+> **Generated:** 2026-07-31 · **Method:** compared the app's implemented API
+> surface (`InterlinedList/Services/InterlinedApiClient*.cs`) against the live
+> OpenAPI 3.1 spec (`https://interlinedlist.com/api/openapi.json` — **189 paths,
+> 244 operations**) and the product's own help docs (`/help`, `/help/api`).
+>
+> **Headline:** the desktop client implements ~**32** endpoints. The web
+> product exposes on the order of **~190 user-facing operations** (excluding
+> cron/webhooks/admin/internal plumbing). Feature parity is therefore roughly
+> **15–20 %** by endpoint count — the app is a solid *read-mostly* client for a
+> handful of domains (Feed, Lists, Documents, Orgs browse, Search, Connected
+> Accounts) and is missing several whole product pillars: **Direct Messages,
+> the social graph (follow/unfollow), People/profiles, Moderation, Account &
+> Settings, replies/threads, media, exports, GitHub, and billing.**
+
+---
+
+## Progress — Session 1 (2026-07-31)
+
+Live-probed the API with the `.env` test account, then built a large parity
+increment. **The whole app compiles clean** (`dotnet build` on macOS). Shipped:
+
+**Verified against the live API (test account `messenger`):**
+- The account is a **subscriber** (`customerStatus: "subscriber"`) → subscriber-gated
+  features (media upload, creates) are exercisable.
+- **Two CLAUDE.md "constraints" were outdated** and are now corrected: `GET
+  /api/organizations/{id}/members`, `/api/linkedin/targets`, and
+  `/api/linkedin/posting-targets` return **200** with the bearer token (were
+  documented as 401 walls) — Organizations member-management and LinkedIn
+  per-page targeting are now buildable. And the sync-token **does** have a
+  server-side revoke: `GET /api/user/sessions` + `DELETE /api/user/sessions/{id}`
+  (the test account has **502** accumulated stale tokens — a concrete reason to
+  surface this).
+- Genuinely cookie-session-only (401 w/ bearer): `/api/user/engagement`,
+  `/api/user/dashboard-layout`, Stripe billing. Those stay browser-handoff / out
+  of scope.
+
+**Service layer (all compiling, shapes live-verified):** Phase-0 shared HTTP
+helpers; new partials for Messages-depth, People, Follow, Direct Messages,
+Moderation, Account/Sessions, Exports; Lists row edit/delete + metadata; compose
+now supports reply (`parentId`), scheduling (`scheduledAt`), and LinkedIn cross-post.
+
+**UI shipped:**
+- ✅ **Feed depth** — reply, view replies (thread), edit & delete own posts,
+  report others' posts, inline on each card.
+- ✅ **Direct Messages** — new nav item; recipient list + conversation thread +
+  composer (send is read-after-write; POST body shape flagged for verification).
+- ✅ **People** — new nav item; profile lookup, follow/unfollow, follow-request
+  approve/reject, a user's messages, follower/following counts.
+- ✅ **Settings** — new nav item; profile edit, **API-session list + revoke**,
+  notification-preference toggles, blocked/muted lists with unblock/unmute.
+
+**Built but not yet surfaced in UI (service methods exist):** CSV exports
+(4 endpoints), list row edit/delete. **Still open:** see remaining unchecked
+boxes below (media-upload UI, scheduled-post UI, list folders/watchers/sharing,
+doc folders/sharing/collab, org member mgmt UI [now unblocked], Materialize,
+GitHub, billing handoff, register/forgot-password), plus wiring feed/search
+cards to open a profile, and a DM-unread badge on the nav.
+
+---
+
+## Progress — Session 2 (2026-07-31)
+
+Continued toward parity. New live-verified shapes (org members `{members:[{id,
+username,displayName,avatar,role,active,joinedAt}]}`, member add `{userId,role}`,
+folders `{name,parentId}`). **Materialize (`{source}`, opaque) and media upload
+(multipart, undocumented response) were deferred** — they need a live write to
+pin down, unlike everything below.
+
+**Services added (compiling):** org member management (list/add/change-role/remove)
++ org update/delete; document folder CRUD + create-doc-in-folder.
+
+**UI shipped this session:**
+- ✅ **CSV data export** (Settings) — messages / lists / list-rows / follows, each
+  via a native Save-file dialog.
+- ✅ **List rows: edit + delete** (Lists) — inline JSON editor + per-row delete;
+  rows are no longer write-once.
+- ✅ **Block / mute / report a user from their profile** (People).
+- ✅ **Organizations: member management** — list members, add (via user search),
+  change role, remove, edit/delete org (owner/admin gated). *[sub-agent]*
+- ✅ **Documents: folder management** — create/rename/delete folders, new doc in
+  folder. *[sub-agent]*
+
+**Still deferred / open:** media-upload + scheduled-post compose UI, Materialize
+("Create from…"), list folders/watchers/sharing, doc sharing/collaborators,
+GitHub (needs the account to link GitHub first), billing handoff, register/
+forgot-password, profile-navigation from feed cards, DM inbox-folder + polling +
+image attach.
+
+---
+
+## Progress — Session 3 (2026-07-31) — ship-readiness batch
+
+Verified the last write shapes live (image upload: multipart field **`file`** →
+`{url}`; avatar `{url}`; email `{newEmail}`; delete `{username,email}`), then
+built the remaining ship-critical features. **App builds clean in Debug AND
+Release, and the self-contained `win-x64` publish succeeds** (exactly what the
+WiX MSI job harvests).
+
+**Shipped this session:**
+- ✅ **Image attachments on posts** — upload from disk in compose (multipart),
+  pending-thumbnail strip with remove, and images render in feed cards.
+- ✅ **Profile navigation** — author names in the feed are clickable → open that
+  user in the People tab (via a new `Navigator` hub).
+- ✅ **Granular notifications** — mark-one-read + delete-one in the Alerts rail.
+- ✅ **Account settings** — avatar-from-URL + email-change request in Settings.
+- Services: multipart helper, message image upload, avatar/email/delete-account,
+  notification mark-one/delete. (`DeleteAccountAsync` exists but is intentionally
+  **not** surfaced — destructive + untestable.)
+
+Feature set is now broad enough to ship as a capable native client. Remaining
+items (scheduled-post UI, video upload, list/doc sharing, Materialize, GitHub,
+billing, register/forgot-password) are tracked below as post-v1.
+
+---
+
+## 1. Parity snapshot by domain
+
+| Domain (product's name) | Web/API has | App has today | Status |
+|---|---|---|---|
+| **Messages / Feed** | feed, post, dig, search, **replies/threads, edit, delete, report, link-unfurl, scheduled, image+video upload, per-user timeline** | feed, post, dig/undig, search | 🟡 Partial |
+| **Direct Messages** | full 1:1 DM: inbox, threads, send, read/unread, trash/restore, image attach | — nothing | 🔴 Missing |
+| **People / Profiles** | public profile, user lookup, a user's messages/lists/documents | — (search returns users but no profile view) | 🔴 Missing |
+| **Social graph (Follow)** | follow/unfollow, requests, approve/reject, remove follower, status, followers/following/mutual, counts | counts only | 🔴 Missing (read-only stub) |
+| **Blocking / Muting / Reporting** | block, mute, report user, report message, list blocks/mutes | — nothing | 🔴 Missing |
+| **Lists** | browse, create, delete, rows, **edit/delete row, single-list metadata, update, schema DSL, folders, watchers/sharing, share-links, connections, contributors, watching, GitHub refresh** | browse, create, delete, view rows, add row, search | 🟡 Partial |
+| **Documents** | CRUD, templates, search, **folder CRUD, tree, delta-sync, images, share-links, collaborators, presence/live cursors, seed-defaults** | root list, folders (read), templates (read), CRUD, from-template, search | 🟡 Partial |
+| **Organizations** | browse, create, get, **update, delete, members mgmt, org users, LinkedIn org integration** | browse (public + mine), get, create | 🟡 Partial (some member endpoints are cookie-auth-only) |
+| **Notifications** | tray, mark-all-read, **mark-one, delete-one, preferences** | tray, mark-all-read | 🟡 Partial |
+| **Account & Security / Settings** | profile edit, avatar, change-email, delete account, **sessions/token revoke**, notification prefs, dashboard/front-wall layout, engagement, identities verify | — (identities list/remove only) | 🔴 Missing |
+| **Auth flows** | login (sync-token), register, forgot/reset password, verify-email, logout, multi-account switch | sync-token login only | 🟡 Partial |
+| **Cross-Platform Syndication** | link/unlink identities, compose-time cross-post toggles (Mastodon/Bluesky/LinkedIn/Twitter) | identities list/remove, browser OAuth handoff, compose toggles | 🟢 Mostly done (LinkedIn per-page targeting blocked by auth model) |
+| **Create from… (Materialize)** | turn message(s) into a List/Document | — nothing | 🔴 Missing |
+| **Exporting Data** | CSV export: messages, lists, list-rows, follows | — nothing | 🔴 Missing |
+| **GitHub integration** | repos, issues (list/create/update/comment), assignees, labels | — nothing | 🔴 Missing |
+| **Billing / Subscription** | Stripe checkout + portal; subscriber-gated features | — nothing (can't see plan or upgrade) | 🔴 Missing |
+| **Dashboard / Widgets** | dashboard & front-wall layout, weather/location, markets/news/bike-share widgets | — nothing | 🔴 Missing (low priority for desktop) |
+| **Search** | messages, people, lists, documents | all four | 🟢 Done |
+| **Admin** | blog + user administration | — nothing | ⚪ Out of scope (admin-only) |
+
+Legend: 🟢 done · 🟡 partial · 🔴 missing · ⚪ intentionally out of scope
+
+---
+
+## 2. The gap list (prioritized)
+
+Each item cites the real endpoint(s). Tiers reflect user impact for a desktop
+client, not raw endpoint count.
+
+### P0 — Core social pillars that make the app feel incomplete without them
+
+- [x] **Replies / threads** — ✅ read + post replies inline on each feed card
+      (`GET /api/messages/{id}/replies`, reply via `POST /api/messages` w/ parentId).
+- [x] **Edit / delete your own messages** — ✅ inline on own cards
+      (`PATCH`/`DELETE /api/messages/{id}`).
+- [x] **Follow / unfollow + requests** — ✅ People view: follow/unfollow,
+      request approve/reject, status, followers/following. (`.../mutual` service
+      exists, not yet surfaced.)
+- [x] **People / profile view** — ✅ People view (lookup + profile + their
+      messages + counts). *Remaining:* open a profile directly from a feed/search
+      card (nav plumbing), and their public lists/documents tabs.
+- [x] **Direct Messages** — ✅ MVP shipped (recipient list + thread + send + mark
+      read). *Remaining:* the `/api/dm` inbox-folder view, `.../updates` polling,
+      trash/restore UI, image attachments; verify the `POST /api/dm` body shape live.
+
+### P1 — Expected table-stakes for a "real" client
+
+- [x] **Moderation: block / mute / report** — ✅ report a message (feed),
+      ✅ blocked/muted lists (Settings), ✅ block/mute/report a user from their
+      profile (People). All shipped.
+- [~] **Account & Settings** — ✅ profile edit (`PATCH /api/user/update`) and
+      notification preferences (`GET`/`PATCH`). *Remaining:* avatar upload
+      (`POST /api/user/avatar/*`, needs multipart), email change, delete account.
+- [x] **Session / token management** — ✅ **VERIFIED REAL & SHIPPED.** Settings
+      lists active sync-tokens and revokes them (`GET /api/user/sessions`,
+      `DELETE /api/user/sessions/{id}`). CLAUDE.md corrected — the "no revoke
+      endpoint" claim was stale. (Test account had 502 stale tokens.)
+- [x] **List rows: edit + delete** — ✅ shipped: inline JSON editor + per-row
+      delete in ListsView (`UpdateListRowAsync`/`DeleteListRowAsync`).
+- [x] **List metadata & update** — service done (`GetListAsync`/`UpdateListAsync`).
+- [ ] **Media attachments on posts** — `POST /api/messages/images/upload`,
+      `POST /api/messages/videos/upload` (subscriber-gated; multipart — deferred).
+- [ ] **Notifications: granular** — `PATCH /api/notifications/{id}/read`,
+      `DELETE /api/notifications/{id}`.
+- [x] **Data export** — ✅ shipped: Settings → messages/lists/list-rows/follows
+      as CSV via Save-file dialog (`GET /api/exports/*`).
+
+### P2 — Depth features that unlock collaboration & organization
+
+- [ ] **Scheduled messages** — `GET /api/messages/scheduled` + scheduled-post
+      option on `POST /api/messages`.
+- [ ] **List folders** — `GET`/`POST`/`PUT`/`DELETE /api/folders`.
+- [ ] **List watchers / sharing** — `GET`/`POST /api/lists/{id}/watchers`,
+      `.../me`, `.../users`, `PUT`/`DELETE .../watchers/{userId}`;
+      share-links `GET`/`POST /api/lists/{id}/share-links`, `DELETE .../{token}`;
+      resolve `GET`/`POST /api/lists/shared/{token}`, `.../data`;
+      `GET /api/lists/watching`, `GET /api/lists/{id}/contributors`.
+- [ ] **List connections** — `GET`/`POST /api/lists/connections`,
+      `DELETE /api/lists/connections/{id}`.
+- [~] **Document folders (full CRUD) + tree** — ✅ create/rename/delete folder +
+      new-doc-in-folder shipped in DocumentsView. *Remaining:* `GET /api/documents/tree`,
+      move/reparent.
+- [ ] **Document sharing & collaboration** — share-links
+      `GET`/`POST`/`DELETE /api/documents/{id}/share-links`;
+      collaborators `GET`/`POST /api/documents/{id}/collaborators`, `.../users`,
+      `PUT`/`DELETE .../{userId}`; images `POST /api/documents/{id}/images/upload`.
+- [ ] **"Create from…" (Materialize)** — `POST /api/materialize` (message → List/Document).
+- [ ] **Message link unfurl** — `POST /api/messages/{id}/metadata`.
+
+### P3 — Nice-to-have / platform-gated / lower desktop value
+
+- [x] **Organizations: manage** — ✅ shipped: member list/add/change-role/remove
+      + edit/delete org (owner/admin gated) in OrganizationsView.
+      **Correction:** `.../members` is **not** cookie-session-only — it returns
+      200 with the bearer token (re-verified 2026-07-31); the old 401 note was stale.
+- [ ] **GitHub integration** — `GET /api/github/repos|issues`, `POST /api/github/issues`,
+      `PATCH /api/github/issues/{owner}/{repo}/{number}`, comments, assignees, labels.
+- [ ] **Billing / subscription** — `POST /api/stripe/create-checkout-session`,
+      `create-portal-session` (both cookie-session-only → likely browser handoff).
+- [ ] **Auth self-service** — register / forgot-password / reset-password /
+      verify-email / logout / multi-account switch (`/api/auth/*`).
+- [ ] **Document delta-sync** — `GET`/`POST /api/documents/sync` (offline/merge; big lift).
+- [ ] **Live presence / cursors in documents** — `POST`/`DELETE /api/documents/{id}/presence`.
+- [ ] **Dashboard / front-wall layout + widgets** — `GET`/`PUT /api/user/dashboard-layout`,
+      `.../front-wall-layout`, `/api/widgets/*`, `/api/weather`, `/api/location`,
+      `GET /api/user/engagement`.
+
+### ⚪ Deliberately excluded (not client features)
+Cron (`/api/cron/*`), webhooks (`/api/webhooks/*`), admin (`/api/admin/*`),
+`test-db`, `analytics/ingest`, `architecture-aggregates`, `oauth/client-metadata`,
+`images/proxy`, `openapi.json`, push device registration (`/api/push/*` — mobile).
+
+---
+
+## 3. Implementation plan
+
+The plan closes gaps in **priority order**, front-loading a small amount of
+reusable plumbing so each subsequent domain is cheap. Every phase follows the
+codebase's existing conventions: one partial-class file per domain in
+`Services/`, a `ViewModel` per view (`CommunityToolkit.Mvvm`), a self-contained
+`UserControl` in `Views/` that news up its own VM from `AppServices.Session`,
+and Strata design tokens only. **Read-after-write** stays the default for any
+write whose response envelope isn't live-verified (§5).
+
+### Phase 0 — Shared plumbing (do first, ~small)
+
+Nothing user-visible; makes everything after it faster and consistent.
+
+1. **Generic paginated GET helper + typed error surfacing.** The five domain
+   partials each hand-roll `SendAsync → EnsureSuccessAsync → ReadFromJsonAsync`.
+   Extract `GetJsonAsync<T>(path)` / `PostJsonAsync<T>(path, body)` helpers on
+   `InterlinedApiClient` so new endpoints are one line.
+2. **Multipart upload helper** for the four image/video upload endpoints
+   (`SendMultipartAsync(path, stream, fileName, contentType)`). Needed by DM,
+   messages, documents, avatar.
+3. **Profile navigation contract.** Add a lightweight `NavigateToProfile(username)`
+   hook on the shell (`MainWindow`) so feed cards, search results, DM threads,
+   and follower lists can all open a `ProfileView` (built in Phase 2).
+4. **New models** land in `Models/` per domain as each phase needs them (wire
+   types matching real JSON — keep the "don't strictly type unverified write
+   envelopes" rule).
+
+### Phase 1 — Complete the Feed (P0 messages depth)
+
+*Endpoints:* `GET /api/messages/{id}`, `GET /api/messages/{id}/replies`,
+`POST /api/messages/{id}/reply-counts`, `PATCH`/`DELETE /api/messages/{id}`,
+`POST /api/messages/{id}/report`, `POST /api/messages/{id}/metadata`,
+`POST /api/messages/images/upload` / `videos/upload`, `GET /api/messages/scheduled`.
+
+- **Services:** extend `InterlinedApiClient.cs` (or a new `.Messages.cs` partial)
+  with `GetMessageAsync`, `GetRepliesAsync`, `PostReplyAsync` (POST with parent
+  id), `EditMessageAsync`, `DeleteMessageAsync`, `ReportMessageAsync`,
+  `FetchLinkMetadataAsync`, `UploadMessageImageAsync`, `GetScheduledAsync`.
+- **ViewModels/Views:** add a **thread/detail view** (message + reply list +
+  inline reply composer) reachable by clicking a feed card; add edit/delete/report
+  affordances to `MessageItemViewModel`; add an image-attach picker + scheduled-post
+  toggle to the composer in `FeedViewModel`.
+- **Design:** replies indent under the parent; the amber "Dug" left-edge rule
+  already exists — reuse it. Report uses a small confirm dialog (no browser modal
+  dialogs).
+- **Risks:** reply payload shape and `reply-counts` body must be live-probed;
+  media upload is subscriber-gated → handle `402/403` gracefully.
+
+### Phase 2 — People & the social graph (P0)
+
+*Endpoints:* `GET /api/users/{username}`, `GET /api/user/{username}/messages`,
+`GET /api/users/{username}/lists|documents`, `GET /api/users/lookup`;
+all of `/api/follow/*`.
+
+- **Services:** new `InterlinedApiClient.People.cs` (profile fetch + a user's
+  public content) and `InterlinedApiClient.Follow.cs` (follow/unfollow, requests,
+  approve/reject, remove, status, followers/following/mutual — counts already
+  exist, move it here).
+- **ViewModels/Views:** new **`ProfileView`** (`ProfileViewModel`) showing
+  avatar/bio/counts, a Follow/Unfollow button reflecting `.../status`, tabs for
+  the user's messages/lists/documents; a **Follow Requests** panel (approve/reject)
+  surfaced in the right rail or Alerts area. Wire `NavigateToProfile` from Phase 0
+  into feed cards and search results.
+- **Payoff:** turns the existing user-search stub into a real social experience;
+  unblocks "who follows me" and request management.
+
+### Phase 3 — Direct Messages (P0, whole new nav item)
+
+*Endpoints:* all of `/api/dm/*`.
+
+- **Services:** new `InterlinedApiClient.DirectMessages.cs`.
+- **ViewModels/Views:** new **`MessagesView`** (rename-safe: call it *Direct
+  Messages* to avoid clashing with Feed) — left column = conversation list
+  (`GET /api/dm`, unread badges from `GET /api/dm/unread-count`), right column =
+  thread (`GET /api/dm/thread/{username}` + composer + image attach). Poll
+  `.../updates` on a timer for near-real-time; mark read on open
+  (`POST /api/dm/{id}/read`); trash/restore in a context menu.
+- **Shell:** add a **DM** entry to the left nav in `MainWindow.xaml.cs`
+  `NavItem_Click` (per-tag `_views` cache pattern already there) and a global
+  unread badge on that nav item.
+- **Risks:** polling cadence vs. rate limits (`GET /api/limits`); this is the
+  largest single new surface — budget accordingly.
+
+### Phase 4 — Moderation + Account & Settings (P1)
+
+*Endpoints:* `/api/users/{username}/block|mute|report`, `GET /api/user/blocks|mutes`,
+`POST /api/messages/{id}/report` (from Phase 1); `PATCH /api/user/update`,
+`POST /api/user/avatar/*`, `POST /api/user/change-email/request`,
+`GET`/`PATCH /api/user/notification-preferences`, `POST /api/user/delete`,
+`GET /api/user/sessions`, `DELETE /api/user/sessions/{id}`.
+
+- **Services:** `InterlinedApiClient.Moderation.cs` + `InterlinedApiClient.Account.cs`.
+- **ViewModels/Views:** a new **Settings** view with tabs — *Profile* (edit +
+  avatar upload), *Notifications* (prefs), *Blocked & Muted* (lists with unblock/
+  unmute), *Sessions* (list active tokens, revoke — **pending §5 verification**),
+  *Account* (change email, delete). Add block/mute/report to profile and message
+  context menus (Phase 1/2 hooks).
+- **Security note:** if `DELETE /api/user/sessions/{id}` is real, update
+  `CLAUDE.md` and the `CredentialStore` docs — the standing-credential caveat
+  would no longer be strictly true.
+
+### Phase 5 — Lists & Documents depth (P1→P2)
+
+*Lists:* row edit/delete (`GET`/`PUT`/`DELETE /api/lists/{id}/data/{rowId}`),
+metadata/update (`GET`/`PUT /api/lists/{id}`), folders (`/api/folders`), watchers
+& share-links, connections, contributors, `GET /api/lists/watching`,
+`POST /api/lists/{id}/refresh`.
+*Documents:* folder CRUD + `GET /api/documents/tree`, share-links, collaborators,
+image upload, `seed-defaults`.
+
+- **Services:** extend `.Lists.cs` and `.Documents.cs` partials.
+- **ViewModels/Views:** add inline **row editing/deletion** to `ListsView`
+  (biggest immediate value — today rows are write-once); a folder tree for both
+  Lists and Documents; a **Share** dialog (create/revoke links, invite
+  watchers/collaborators by user search) shared between the two domains.
+- **Schema DSL:** still deferred — `PUT /api/lists/{id}/schema` is only partially
+  reverse-engineered (`CLAUDE.md`); keep freeform rows as the supported path
+  until the DSL is verified against a test account.
+
+### Phase 6 — Cross-cutting extras (P2→P3)
+
+- **Exports:** `GET /api/exports/*` → a simple "Export to CSV" menu (save-file
+  dialog) per domain. Cheap, high perceived value.
+- **Create from… / Materialize:** `POST /api/materialize` → a "Turn into
+  List/Document" action on feed cards and multi-select.
+- **Organizations manage:** `PUT`/`DELETE /api/organizations/{id}`, org users.
+  **Skip members mgmt** — cookie-session-only (401 with bearer). Note the block
+  in-UI rather than shipping a failing button.
+- **GitHub integration:** repos/issues panel (P3) — only if users ask; sizable
+  and orthogonal to the social core.
+- **Billing:** surface plan status + "Manage subscription" that opens the Stripe
+  portal **in the OS browser** (same handoff pattern as OAuth), since checkout/
+  portal creation is cookie-session-only. This at least makes subscriber-gated
+  features (media upload, some creates) explainable in-app.
+- **Auth self-service:** register / forgot-password as pre-login screens; logout;
+  multi-account switch. Lower priority because sync-token login already works.
+
+### Phase 7 — Deferred / research-grade (P3)
+
+Document delta-sync (`/api/documents/sync`), live presence/cursors, dashboard &
+front-wall layouts, widgets/weather. These are either large (offline-merge),
+low desktop value, or web-dashboard-specific. Track but don't schedule until the
+core social parity above is closed.
+
+---
+
+## 4. Suggested sequencing & milestones
+
+| Milestone | Phases | Outcome |
+|---|---|---|
+| **M1 — "A real feed"** | 0, 1 | Threads, edit/delete, report, media, scheduled posts |
+| **M2 — "Social"** | 2, 3 | Profiles, follow graph, Direct Messages |
+| **M3 — "Trust & self-service"** | 4 | Moderation + full Settings/Account |
+| **M4 — "Power features"** | 5 | Editable list rows, folders, sharing/collab |
+| **M5 — "Everything else"** | 6, (7) | Exports, materialize, GitHub, billing handoff |
+
+M1–M2 close the visible parity gap for a *social* product; M3 makes it
+trustworthy; M4–M5 reach functional parity minus the auth-model-blocked and
+web-dashboard-specific corners.
+
+---
+
+## 5. Cross-cutting engineering notes & verification checklist
+
+These apply to **every** phase and encode the constraints already learned in
+this codebase (`CLAUDE.md` "load-bearing constraints"):
+
+1. **Live-verify before typing write responses.** Keep the read-after-write
+   pattern for any mutating endpoint whose envelope hasn't been confirmed against
+   a real (test) account. Don't strictly deserialize an unverified body.
+2. **Re-probe the auth model per endpoint.** Bearer sync-token works for most,
+   but **not all** — org members (`/api/organizations/{id}/members*`) and
+   LinkedIn targets return 401 with bearer. Before building any `session`-scoped
+   endpoint (billing, some auth/account flows), confirm it accepts the bearer
+   token; if not, it's either browser-handoff (like OAuth) or genuinely blocked.
+3. **⚠️ Resolve the sessions/revoke contradiction (do this early).**
+   `CLAUDE.md` says the sync-token has no server-side revoke; the spec advertises
+   `GET /api/user/sessions` + `DELETE /api/user/sessions/{id}`. Probe both with
+   the `.env` test account. Whichever is true, **update `CLAUDE.md` and the
+   memory note** so the standing-credential guidance is correct.
+4. **Subscriber gating is real.** Many creates + media uploads require a
+   subscriber (`POST /api/lists`, `/api/folders`, doc creates, image/video
+   upload). Handle `402/403` as a first-class "upgrade needed" state, not a
+   generic error — this is why Phase 6 billing (plan visibility) matters.
+5. **Media = multipart, not JSON.** The current client only sends JSON. Image/
+   video/avatar uploads need the Phase 0 multipart helper.
+6. **Pagination everywhere.** Follow lists, DM threads, replies, blocks/mutes,
+   a user's messages all paginate — reuse the existing `Pagination`/`limit+offset`
+   convention and infinite-scroll pattern from `FeedViewModel`.
+7. **OAuth / browser handoffs stay external.** No WebView2 in this app — OAuth
+   linking (existing) and any Stripe portal/checkout (Phase 6) open the OS
+   default browser and rely on the user returning and refreshing. Don't attempt
+   inline web auth.
+8. **Design tokens only.** New views (Profile, DM, Settings, Share dialogs) must
+   use Strata tokens — teal structure, green actions, amber for live/Dig — sharp
+   3–4px corners, the 4pt grid. No new colors/fonts/radii.
+9. **Avoid modal browser dialogs / native message boxes that block** the WPF
+   dispatcher during long polls (DM updates) — prefer non-blocking toasts and
+   confirm-in-place UI.