Did a lot.

Author: Adron

API-backend-prompts-to-build.md

@@ -15,14 +15,15 @@
 import AppKit
 import SwiftUI
 import UserNotifications
+import InterlinedDomain
 
 /// `NSApplicationDelegate` adapter installed via
 /// `@NSApplicationDelegateAdaptor` in `InterlinedListApp`. Owns:
 ///
 /// 1. The dock-tile badge writer (`updateDockBadge(unreadCount:)`).
-/// 2. The `UNUserNotificationCenterDelegate` hook so that activating a
-///    delivered notification brings the app forward (deep-link routing
-///    proper lands in a follow-up — see `// TODO(M5.x)` below).
+/// 2. The `UNUserNotificationCenterDelegate` hook that activates the app
+///    and routes to the relevant content when the user taps a delivered
+///    banner — see `userNotificationCenter(_:didReceive:withCompletionHandler:)`.
 ///
 /// Everything else stays pure SwiftUI.
 final class AppDelegate: NSObject, NSApplicationDelegate {
@@ -62,17 +63,27 @@ extension AppDelegate: UNUserNotificationCenterDelegate {
         completionHandler([.banner, .sound])
     }
 
-    /// Called when the user clicks a delivered notification. Routes the
-    /// main window to the Notifications sidebar section and activates
-    /// the app. The `NotificationsRootView` will refresh on appear so
-    /// the relevant item is visible.
+    /// Called when the user taps a delivered notification banner. Brings
+    /// the app forward, then resolves a typed `NotificationTarget` from
+    /// the banner's `userInfo` dict and posts `.notificationDeepLink` so
+    /// `MainWindowView` can route the sidebar and feature views can push
+    /// the relevant detail on their own navigation stacks.
+    ///
+    /// Fallback: when the `userInfo` dict does not carry enough keys to
+    /// produce a typed target — e.g. any notification scheduled before
+    /// this routing was added — the resolved target is
+    /// `.unknown(actionURL: nil)` and `MainWindowView` falls back to
+    /// selecting the Notifications sidebar section, preserving the
+    /// pre-M5.x behaviour.
     func userNotificationCenter(
         _ center: UNUserNotificationCenter,
         didReceive response: UNNotificationResponse,
         withCompletionHandler completionHandler: @escaping () -> Void
     ) {
         NSApp.activate(ignoringOtherApps: true)
-        NotificationCenter.default.post(name: .notificationsShow, object: nil)
+        let userInfo = response.notification.request.content.userInfo
+        let target = NotificationTarget(userInfo: userInfo)
+        NotificationCenter.default.post(name: .notificationDeepLink, object: target)
         completionHandler()
     }
 }

App/Composition/AppDelegate.swift

@@ -0,0 +1,108 @@
+// NotificationDeepLinkRouter
+//
+// App-layer extension that closes the loop between
+// `LocalNotificationScheduler` (which embeds a typed `userInfo` dict
+// into every scheduled banner) and `AppDelegate` (which reads that dict
+// back from a tapped `UNNotificationResponse` and reconstructs a
+// `NotificationTarget`).
+//
+// The keys are namespaced under `"interlinedlist."` to avoid collisions
+// with any APNs aps payload keys the server might include in a push
+// notification's userInfo dict.
+//
+// Architecture notes
+// ------------------
+// * This file lives in `App/Composition/`, which is allowed to cross
+//   every layer boundary per Decision 0003.
+// * It extends `NotificationTarget` (a domain type) with an App-layer
+//   initialiser that understands the `userInfo` key contract. The domain
+//   package itself stays ignorant of userInfo dicts — that detail belongs
+//   at the app boundary, not in the reusable domain layer.
+// * `NotificationUserInfoKeys` is `enum` (no instantiation) to serve as
+//   a namespace; all values are compile-time `static let` strings.
+
+import Foundation
+import InterlinedDomain
+
+// MARK: - userInfo key constants
+
+/// Stable string constants for the keys
+/// `LocalNotificationScheduler` writes into
+/// `UNMutableNotificationContent.userInfo` when scheduling a local
+/// notification banner, and that `AppDelegate` reads back from a tapped
+/// `UNNotificationResponse`.
+enum NotificationUserInfoKeys {
+    /// The domain `Notification.id` — used to identify which row to mark
+    /// read after the user taps the banner.
+    static let notificationId   = "interlinedlist.notificationId"
+    /// The raw `NotificationKind` string (`"dig"`, `"reply"`, …). Used
+    /// to reconstruct the kind so `NotificationTarget.init(userInfo:)`
+    /// can follow the same dispatch table as `NotificationMappers.swift`.
+    static let type             = "interlinedlist.type"
+    /// Present when the target is `.message(id:)`.
+    static let targetMessageId  = "interlinedlist.targetMessageId"
+    /// Present when the target is `.list(id:)`.
+    static let targetListId     = "interlinedlist.targetListId"
+    /// Present when the target is `.user(id:)`.
+    static let targetUserId     = "interlinedlist.targetUserId"
+    /// Present when the target is `.organization(id:)`.
+    static let targetOrgId      = "interlinedlist.targetOrgId"
+    /// The actor's username — purely informational, not used for routing.
+    static let actorUsername    = "interlinedlist.actorUsername"
+    /// Fallback URL string for `.unknown(actionURL:)` targets.
+    static let actionUrl        = "interlinedlist.actionUrl"
+}
+
+// MARK: - NotificationTarget + userInfo parsing
+
+extension NotificationTarget {
+
+    /// Reconstructs a typed `NotificationTarget` from the `userInfo` dict
+    /// embedded by `LocalNotificationScheduler`. Returns
+    /// `.unknown(actionURL:)` whenever the dict does not carry enough
+    /// information to produce a more specific target — callers can still
+    /// open a web fallback via the `actionURL` associated value in that
+    /// case.
+    ///
+    /// Mirrors the dispatch table in `NotificationMappers.swift` so the
+    /// two ends of the banner round-trip stay in sync: the mapper turns
+    /// server DTO metadata into a target; this initialiser turns app
+    /// userInfo back into the same target.
+    init(userInfo: [AnyHashable: Any]) {
+        let typeString  = userInfo[NotificationUserInfoKeys.type] as? String
+        let kind        = NotificationKind(rawValue: typeString)
+        let actionURL   = (userInfo[NotificationUserInfoKeys.actionUrl] as? String)
+            .flatMap(URL.init(string:))
+
+        switch kind {
+        case .dig, .reply, .mention:
+            if let id = userInfo[NotificationUserInfoKeys.targetMessageId] as? String {
+                self = .message(id: id)
+                return
+            }
+
+        case .listShared, .listRowAdded:
+            if let id = userInfo[NotificationUserInfoKeys.targetListId] as? String {
+                self = .list(id: id)
+                return
+            }
+
+        case .followRequest, .followAccepted:
+            if let id = userInfo[NotificationUserInfoKeys.targetUserId] as? String {
+                self = .user(id: id)
+                return
+            }
+
+        case .orgInvite:
+            if let id = userInfo[NotificationUserInfoKeys.targetOrgId] as? String {
+                self = .organization(id: id)
+                return
+            }
+
+        case .other:
+            break
+        }
+
+        self = .unknown(actionURL: actionURL)
+    }
+}

App/Composition/NotificationDeepLinkRouter.swift

@@ -65,7 +65,30 @@ struct ComposerWindowView: View {
             }
         }
         .onChange(of: viewModel?.didFinish) { _, finished in
-            if finished == true { dismiss() }
+            // When cross-post results are present the sheet owns the final
+            // dismiss (the Done button calls dismissCrossPostResults then
+            // dismiss). Only auto-dismiss here when there is nothing to show.
+            if finished == true, viewModel?.crossPostResults == nil {
+                dismiss()
+            }
+        }
+        // NW-2: present the per-platform cross-post status sheet after a
+        // successful publish. The sheet's Done button calls
+        // `dismissCrossPostResults()` and then closes the window.
+        .sheet(isPresented: Binding(
+            get: { viewModel?.crossPostResults != nil },
+            set: { newValue in
+                if !newValue {
+                    viewModel?.dismissCrossPostResults()
+                }
+            }
+        )) {
+            if let results = viewModel?.crossPostResults {
+                CrossPostResultsSheet(results: results) {
+                    viewModel?.dismissCrossPostResults()
+                    dismiss()
+                }
+            }
         }
     }
 

App/Features/Compose/ComposerWindowView.swift

@@ -0,0 +1,125 @@
+// LocalNotificationScheduler
+//
+// Schedules a macOS `UNUserNotification` banner for a single
+// `InterlinedDomain.Notification` value. The scheduler embeds a typed
+// `userInfo` dict — keyed by `NotificationUserInfoKeys` — so that
+// `AppDelegate` can reconstruct a `NotificationTarget` when the user
+// taps the delivered banner (the deep-link routing half of the
+// notification feature, per PLAN.md §6 M5.x).
+//
+// Responsibilities
+// ----------------
+// * Build a `UNMutableNotificationContent` with title, sound, and userInfo.
+// * Schedule an immediate `UNNotificationRequest` via the shared
+//   `UNUserNotificationCenter`.
+// * NOT request UN permission — that belongs to
+//   `NotificationsPermissionCoordinator`.
+// * NOT de-duplicate previously-shown notifications — callers own that
+//   set. The composition root can track shown IDs in `UserDefaults`.
+//
+// Per Decision 0003 this file imports only `InterlinedDomain`; it does
+// not import `InterlinedKit`. The `NotificationUserInfoKeys` constants
+// are in `App/Composition/` and are visible to all files in the
+// `InterlinedList` module without an extra import.
+
+import Foundation
+import UserNotifications
+import InterlinedDomain
+
+// MARK: - Protocol
+
+/// Narrow scheduling surface for App-layer code that needs to surface
+/// an `InterlinedDomain.Notification` as a macOS system banner. A
+/// protocol so unit tests can inject a recording stub without touching
+/// `UNUserNotificationCenter`.
+protocol LocalNotificationScheduling: Sendable {
+    /// Schedules a local notification banner for `notification`.
+    /// Idempotent by request identifier (`notification.id`) — scheduling
+    /// the same id twice replaces the earlier pending request.
+    func schedule(_ notification: InterlinedDomain.Notification) async
+}
+
+// MARK: - Live implementation
+
+/// Production scheduler. Delegates to `UNUserNotificationCenter`; the
+/// center is injected so test overrides work without the real system.
+final class LocalNotificationScheduler: LocalNotificationScheduling, @unchecked Sendable {
+
+    private let center: UNUserNotificationCenter
+
+    init(center: UNUserNotificationCenter = .current()) {
+        self.center = center
+    }
+
+    func schedule(_ notification: InterlinedDomain.Notification) async {
+        let content = UNMutableNotificationContent()
+        content.title = derivedTitle(for: notification)
+        if let body = notification.body, !body.isEmpty {
+            content.body = body
+        }
+        content.sound = .default
+        content.userInfo = Self.userInfo(for: notification)
+
+        let request = UNNotificationRequest(
+            identifier: notification.id,
+            content: content,
+            trigger: nil // nil trigger = deliver immediately
+        )
+        // Swallow scheduling errors: if the user has denied permission the
+        // banner silently drops; the in-app tray still shows the row.
+        try? await center.add(request)
+    }
+
+    // MARK: - userInfo builder
+
+    /// Assembles the `userInfo` dict that `AppDelegate` reads back from
+    /// `UNNotificationResponse.notification.request.content.userInfo`
+    /// when the user taps the delivered banner.
+    ///
+    /// All keys use the `NotificationUserInfoKeys` constants so the
+    /// writing and reading sides of the contract share a single source of
+    /// truth and are immune to typos.
+    static func userInfo(
+        for notification: InterlinedDomain.Notification
+    ) -> [String: String] {
+        var dict: [String: String] = [:]
+        dict[NotificationUserInfoKeys.notificationId]  = notification.id
+        dict[NotificationUserInfoKeys.type]            = notification.kind.rawValue
+
+        if let username = notification.actor?.username, !username.isEmpty {
+            dict[NotificationUserInfoKeys.actorUsername] = username
+        }
+
+        switch notification.target {
+        case .message(let id):
+            dict[NotificationUserInfoKeys.targetMessageId] = id
+        case .list(let id):
+            dict[NotificationUserInfoKeys.targetListId]    = id
+        case .user(let id):
+            dict[NotificationUserInfoKeys.targetUserId]    = id
+        case .organization(let id):
+            dict[NotificationUserInfoKeys.targetOrgId]     = id
+        case .unknown(let url):
+            if let urlString = url?.absoluteString {
+                dict[NotificationUserInfoKeys.actionUrl] = urlString
+            }
+        case .none:
+            break
+        }
+
+        return dict
+    }
+
+    // MARK: - Title derivation
+
+    /// Falls back to `NotificationRowCopy.copy` when the server-supplied
+    /// title is absent so every banner has human-readable text.
+    private func derivedTitle(for note: InterlinedDomain.Notification) -> String {
+        NotificationRowCopy.copy(
+            for: note.kind,
+            actor: note.actor,
+            title: note.title,
+            body: nil
+        )
+    }
+}

App/Features/Notifications/LocalNotificationScheduler.swift

@@ -6,10 +6,10 @@
 // error / empty logic in the view model so unit tests cover the
 // behavior without touching SwiftUI.
 //
-// v1 is read-only (backend ask P3.3 — no cancel / reschedule endpoint):
-// the list surfaces what is queued and the empty state points the user
-// at the composer for scheduling a new post. Rows carry no destructive
-// affordance.
+// Rows support cancel (DELETE /api/messages/[id]) and reschedule
+// (PUT /api/messages/[id] with a new `scheduledAt`). Both operations
+// use the optimistic-UI pattern (NW-3): the list is updated locally
+// before the network call and rolled back on failure.
 //
 // Per Decision 0003 the view consumes only `InterlinedDomain`.
 

App/Features/Scheduled/ScheduledPostsRootView.swift

@@ -1,15 +1,15 @@
 // ScheduledPostsViewModel
 //
-// Drives `ScheduledPostsRootView`: the read-only list of the caller's
-// pending scheduled posts (PLAN.md §1 "Scheduled posts", §5 "Scheduled
-// sidebar section", §6 M6). Reads through `MessagesServicing.scheduledPosts()`
-// only — no direct API access — so unit tests substitute a stub service.
+// Drives `ScheduledPostsRootView`: the list of the caller's pending
+// scheduled posts (PLAN.md §1 "Scheduled posts", §5 "Scheduled sidebar
+// section", §6 M6). Reads through `MessagesServicing.scheduledPosts()` —
+// no direct API access — so unit tests substitute a stub service.
 //
-// v1 is intentionally read-only. The API exposes no cancel / reschedule
-// endpoint (backend ask P3.3), so the list shows what is queued and links
-// the user to the composer for creating new scheduled posts; rows carry no
-// delete / edit affordance. When P3.3 lands, the row gains a destructive
-// action and this view model grows an optimistic-removal path.
+// NW-3: cancel and reschedule are now supported. Both use the optimistic-UI
+// pattern (snapshot → mutate locally → service call → on success replace
+// with server copy; on failure restore snapshot). The row context menu
+// surfaces both actions; `actionError` captures the last mutation failure
+// without replacing the loaded list.
 //
 // Per Decision 0003 this view model consumes only `InterlinedDomain`.
 

App/Features/Scheduled/ScheduledPostsViewModel.swift

@@ -61,6 +61,9 @@ struct LinkedAccountsView: View {
             }
 
             Section("Link an account") {
+                Text("Linking an account opens your default browser to complete authorization. Return to InterlinedList when done.")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
                 if viewModel.isLinking {
                     HStack {
                         ProgressView()

App/Features/Settings/LinkedAccountsView.swift

@@ -230,6 +230,19 @@ struct MessageRowView: View {
                 }
             }
         }
+
+        // Report — visible for every message regardless of ownership
+        // (App Store Review Guideline 1.2: User-Generated Content requires
+        // a mechanism to report objectionable content). No backend report
+        // endpoint exists yet — open the support URL so users can contact
+        // the team directly.
+        Button {
+            if let url = URL(string: "https://interlinedlist.com/support") {
+                NSWorkspace.shared.open(url)
+            }
+        } label: {
+            Label("Report\u{2026}", systemImage: "flag")
+        }
     }
 
     private func repostBanner(original: Message) -> some View {