From e62c0614910f87891918dc6410b519dabef68cf4 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:40:19 -0700
Subject: [PATCH 01/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/LiveActivityManager.swift | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index 0ed2631..ee99985 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -88,6 +88,12 @@ final class LiveActivityManager {
             if let existing = Activity<NucleicSessionAttributes>.activities.first {
                 activity = existing
                 observePushToken(existing)
+                // Dismiss any duplicates so only the adopted Activity renders. iOS stacks multiple
+                // Activities of one type in the Dynamic Island — an orphan (from a prior launch that
+                // was killed before `end()`) then shows *its* stale state in the collapsed pill while
+                // expanding reveals the fresh one, and `end()` on completion would leave it lingering
+                // on the last "needs attention" glance. Keep exactly one.
+                endStrays(keeping: existing.id)
                 enqueue(state)
             } else {
                 // `pushType: .token` opts the activity into APNs updates — the Macs push new

From b128256cd39ea17adcfb0fbc0cc79a2b65d25244 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:40:34 -0700
Subject: [PATCH 02/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/LiveActivityManager.swift   | 28 +++++++++++++++----
 1 file changed, 23 insertions(+), 5 deletions(-)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index ee99985..7831ce0 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -143,13 +143,31 @@ final class LiveActivityManager {
         tokenObservation = nil
         pendingState = nil
         lastState = nil
-        guard let activity else { return }
+        let tracked = activity
         self.activity = nil
-        onActivityEnded?(activity.id)  // let the Macs stop pushing to this token
+        if let tracked { onActivityEnded?(tracked.id) }  // let the Macs stop pushing to this token
+        // Dismiss the tracked Activity *and any strays*: ending only the one we track would leave an
+        // orphan (from a prior launch killed before `end()`) rendering a stale "needs attention"
+        // glance in the Dynamic Island after the work it described has finished. Clear them all so
+        // "everything idle" can't get stuck on screen.
         Task {
-            await activity.end(
-                ActivityContent(state: activity.content.state, staleDate: nil),
-                dismissalPolicy: .immediate)
+            for activity in Activity<NucleicSessionAttributes>.activities {
+                await activity.end(
+                    ActivityContent(state: activity.content.state, staleDate: nil),
+                    dismissalPolicy: .immediate)
+            }
+        }
+    }
+
+    /// Dismiss every live Activity except `keep` — collapses accidental duplicates down to one so
+    /// iOS can't render a stale orphan alongside the tracked glance.
+    private func endStrays(keeping keep: String) {
+        for stray in Activity<NucleicSessionAttributes>.activities where stray.id != keep {
+            Task {
+                await stray.end(
+                    ActivityContent(state: stray.content.state, staleDate: nil),
+                    dismissalPolicy: .immediate)
+            }
         }
     }
 

From 547d2a0c29eb1cb1c5c514cfa23eb032c5d8c178 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:07 -0700
Subject: [PATCH 03/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/HostConnection.swift | 1 +
 1 file changed, 1 insertion(+)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index d3234e9..a0a929e 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -115,6 +115,7 @@ final class HostConnection {
     private var eventTask: Task<Void, Never>?
     private var connectTask: Task<Void, Never>?
     private var retryTask: Task<Void, Never>?
+    private var revalidateTask: Task<Void, Never>?
     private var lanConnectTimeout: Task<Void, Never>?
     private var reconnectAttempts = 0
     private var seenSeq: Set<UInt64> = []

From 88a004ca1ea728e50452caf24a7a631350341b54 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:08 -0700
Subject: [PATCH 04/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/LiveActivityManager.swift | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index 7831ce0..25bd6e8 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -15,6 +15,13 @@ final class LiveActivityManager {
     /// still summarize everything, this just bounds the per-session list.
     private static let maxLines = 3
 
+    /// How long the terminal "all clear / Done" glance lingers before the Activity dismisses. Long
+    /// enough to read at a glance, short enough not to loiter on the lock screen.
+    private static let doneLinger: Duration = .seconds(4)
+    /// The delayed dismissal after the Done glance is shown, cancelled if work resumes first — so a
+    /// completed run flashes "Done" and then clears instead of vanishing the instant it finishes.
+    private var dismissTask: Task<Void, Never>?
+
     private var activity: Activity<NucleicSessionAttributes>?
 
     /// The last content we pushed. Updates that don't change it are skipped so we don't spend

From 810d791bf945e2301362ba5d4d447fc80e95775e Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:16 -0700
Subject: [PATCH 05/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/HostConnection.swift | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index a0a929e..c58860d 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -689,6 +689,33 @@ final class HostConnection {
         }
     }
 
+    /// Foreground liveness check — the fast-reconnect path. iOS suspends the app when it's
+    /// backgrounded, which silently kills the socket; but no `.closed`/`.failed` reaches us while
+    /// we're frozen, so this connection can wake still marked `.connected`. Trusting that stale
+    /// state means nothing reconnects until the 55s keepalive deadline (or ~15s TCP keepalive)
+    /// finally notices — the several-second (or worse) stall on return. Instead: if we're already
+    /// not live, re-dial now with no backoff; if we *look* live, actively ping and re-dial the
+    /// instant the link fails to answer within a tight deadline. A pinned host only (a host
+    /// mid-pairing runs its own one-shot chain and has no `pinnedHost`).
+    func revalidate() {
+        guard let host = pinnedHost else { return }
+        guard connectivity.isLive, let client else {
+            reconnectAttempts = 0
+            reconnect(to: host)
+            return
+        }
+        revalidateTask?.cancel()
+        revalidateTask = Task { [weak self] in
+            let alive = await client.probeAlive(within: .milliseconds(800))
+            guard !Task.isCancelled, let self, self.client === client,
+                  self.connectivity.isLive else { return }
+            if !alive {
+                self.reconnectAttempts = 0
+                self.reconnect(to: host)
+            }
+        }
+    }
+
     private func scheduleRetry(host: PairedHost?) {
         guard let host else { return }
         reconnectAttempts += 1

From 8c52dbdda0a3ca18dfba1814e6f0048e8d5ce905 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:18 -0700
Subject: [PATCH 06/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/LiveActivityManager.swift | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index 25bd6e8..4dd1dc3 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -51,9 +51,13 @@ final class LiveActivityManager {
         let needsYou = live.filter { $0.status.needsYou($0.disposition) }
 
         guard !running.isEmpty || !needsYou.isEmpty else {
-            end()
+            finishWithDoneGlance(hostName: hostName, live: live)
             return
         }
+        // Work is active again — abort any pending "Done" dismissal so the glance doesn't clear
+        // out from under a run that just resumed (or a new one that just started).
+        dismissTask?.cancel()
+        dismissTask = nil
 
         // Everything in flight or waiting on the user, attention-first (approvals, then waiting
         // input, then running), freshest within a rank. This is both the detail-row source and

From 0bb4e453b774f1fe2be78ec7cf1c0e8bed63509b Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:21 -0700
Subject: [PATCH 07/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/HostConnection.swift | 1 +
 1 file changed, 1 insertion(+)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index c58860d..0644e40 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -730,6 +730,7 @@ final class HostConnection {
 
     func teardown() {
         retryTask?.cancel(); retryTask = nil
+        revalidateTask?.cancel(); revalidateTask = nil
         connectTask?.cancel(); connectTask = nil
         connectPlan = nil
         teardownClient()

From ecfec2690f02ebf110f8e7581345ecee0be41555 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:27 -0700
Subject: [PATCH 08/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 8260c82..50b4c47 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -3,6 +3,9 @@ import Network
 import SwiftUI
 import NucleicProtocol
 import NucleicTailnet
+#if canImport(UIKit)
+import UIKit
+#endif
 
 /// On the phone there's no app-side `SessionSummary` view-model to collide with, so the wire
 /// type *is* the model. Alias it under the host's name so the shared vocabulary reads the same.

From 41f0f62beb4b7ededd09b9b9cb2b843a2b607856 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:31 -0700
Subject: [PATCH 09/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/LiveActivityManager.swift   | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index 4dd1dc3..1507e4c 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -87,6 +87,41 @@ final class LiveActivityManager {
         push(state, hostName: hostName)
     }
 
+    /// Nothing is running or waiting. If the glance was showing active work, flash a brief "Done"
+    /// summary of the just-completed sessions and then dismiss (UX_IOS §5.3 — a run should read as
+    /// *finished*, not just vanish). If nothing was on screen, there's nothing to close.
+    private func finishWithDoneGlance(hostName: String, live: [WireSessionSummary]) {
+        // Already flashing "Done" and scheduled to dismiss — let that run rather than restart it.
+        guard dismissTask == nil else { return }
+        // Nothing tracked on screen: only reach into ActivityKit if an untracked orphan is lingering.
+        guard activity != nil else {
+            if !Activity<NucleicSessionAttributes>.activities.isEmpty { end() }
+            return
+        }
+        // The sessions that just finished — completed conversational turns and finished runs. These
+        // are exactly the ones the active-work filter above drops, surfaced now as `.done` rows.
+        let done = live
+            .filter {
+                $0.status == .finished
+                    || ($0.status == .awaitingInput && $0.disposition == .completed)
+            }
+            .sorted(by: StatusStyle.attentionThenRecency)
+            .prefix(Self.maxLines)
+            .map(Self.line(for:))
+        // Nothing to celebrate (e.g. the work was discarded/deleted) → just dismiss.
+        guard !done.isEmpty else { end(); return }
+
+        let state = NucleicSessionAttributes.ContentState(
+            runningCount: 0, needsYouCount: 0, approvalCount: 0,
+            filesChanged: 0, linesAdded: 0, linesRemoved: 0, lines: Array(done))
+        push(state, hostName: hostName)
+        dismissTask = Task { [weak self] in
+            try? await Task.sleep(for: Self.doneLinger)
+            guard !Task.isCancelled else { return }
+            self?.end()
+        }
+    }
+
     /// Apply `state` to the Activity — deduped against the last push and coalesced through one
     /// serial task so the newest state always wins.
     private func push(_ state: NucleicSessionAttributes.ContentState, hostName: String) {

From 7b11a1862870bf3b034c71daf9bcc58d2ab2bd2f Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:39 -0700
Subject: [PATCH 10/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/LiveActivityManager.swift | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index 1507e4c..19ece0d 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -187,6 +187,8 @@ final class LiveActivityManager {
         updateTask = nil
         tokenObservation?.cancel()
         tokenObservation = nil
+        dismissTask?.cancel()
+        dismissTask = nil
         pendingState = nil
         lastState = nil
         let tracked = activity

From f257e4d66fce3e5280558d15e72e2bcb755a5f35 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:40 -0700
Subject: [PATCH 11/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift    | 40 ++++++++++++++++++-
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 50b4c47..6decb92 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -320,12 +320,48 @@ final class RemoteStore: ObservableObject {
     }
 
     /// Returning to the foreground: the network may have changed while the app was suspended (and
-    /// path/keepalive callbacks were frozen). Re-read the path and re-dial anything not live so the
-    /// transport is correct by the time the UI is on screen, rather than after a backoff.
+    /// path/keepalive callbacks were frozen). Re-read the path, re-dial anything not live, then
+    /// actively revalidate the connections that still *look* live — a socket the OS killed while we
+    /// were suspended wakes marked `.connected`, and trusting that would stall the reconnect until
+    /// the 55s keepalive deadline. `revalidate` pings each such link and re-dials the instant it
+    /// fails to answer, so the transport is correct (and fast) by the time the UI is on screen.
     func onForeground() {
+        endBackgroundHold()
         guard !demoMode, isPaired else { return }
         pathMonitor.refresh()
+        // Ensure a connection exists for every paired host (and drop unpaired); this re-dials the
+        // ones already known to be offline.
         reconnect()
+        // The zombies from suspension still read `.connected` — probe and re-dial the dead ones.
+        for conn in connections.values where conn.connectivity.isLive { conn.revalidate() }
+    }
+
+    #if canImport(UIKit)
+    /// Held while backgrounded so iOS keeps the process (and thus the live sockets + 20s keepalive)
+    /// running for its short grant, instead of suspending us the moment we background.
+    private var backgroundTask: UIBackgroundTaskIdentifier = .invalid
+    #endif
+
+    /// Entering the background: ask iOS to keep us running briefly so a quick app-switch (glance at
+    /// another app, tap a Live Activity, answer a banner) doesn't tear the connection down and force
+    /// a cold reconnect on return. The grant is short (~30s) and best-effort; once it lapses the OS
+    /// suspends us and the socket dies, which the next `onForeground` revalidation reconnects fast.
+    func onBackground() {
+        guard !demoMode else { return }
+        #if canImport(UIKit)
+        endBackgroundHold()
+        backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "nucleic.sync.hold") {
+            [weak self] in self?.endBackgroundHold()
+        }
+        #endif
+    }
+
+    private func endBackgroundHold() {
+        #if canImport(UIKit)
+        guard backgroundTask != .invalid else { return }
+        UIApplication.shared.endBackgroundTask(backgroundTask)
+        backgroundTask = .invalid
+        #endif
     }
 
     private func seedDemo() {

From 468af9dd4a649c59fe4799175381672d6fe7bce0 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:45:55 -0700
Subject: [PATCH 12/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift          | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 6decb92..2cda3d5 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -76,6 +76,19 @@ final class RemoteStore: ObservableObject {
     private var openSessionHostID: String?
     @Published private(set) var openEvents: [AgentEvent] = []
     @Published private(set) var openApprovals: [ApprovalRequest] = []
+
+    /// The open session is blocked on an approval whose details haven't arrived yet — the state
+    /// right after opening from a Live Activity or notification while the channel is still
+    /// (re)connecting. The summary says `.awaitingApproval`, but `openApprovals` (which is filled
+    /// from the live snapshot) is empty because there's no live channel yet. Drives a lightweight
+    /// "loading approval" placeholder so a tap from the lock screen lands on the request-in-progress
+    /// instead of a blank transcript; it flips off the instant the real card arrives (sub-second,
+    /// thanks to the fast foreground reconnect). Never shown once live — then the snapshot is truth.
+    var openApprovalLoading: Bool {
+        guard !connectivity.isLive, openApprovals.isEmpty, let id = openSessionID,
+              let summary = sessions.first(where: { $0.sessionID == id }) else { return false }
+        return summary.status == .awaitingApproval || summary.pendingApprovalCount > 0
+    }
     /// Whether the compact (iPhone) Sessions tab currently has a session detail pushed. Distinct
     /// from `openSessionID`, which is the *data* subscription and is only torn down on the detail's
     /// `onDisappear` — and SwiftUI fires that at the *end* of the pop transition, so keying the

From 9a0a46bc8baf02df822e64ad270aa9d3caf013ae Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:46:02 -0700
Subject: [PATCH 13/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/NucleicRemoteApp.swift | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/NucleicRemoteApp.swift b/NucleicRemote/NucleicRemote/NucleicRemoteApp.swift
index 3546d9a..0337176 100644
--- a/NucleicRemote/NucleicRemote/NucleicRemoteApp.swift
+++ b/NucleicRemote/NucleicRemote/NucleicRemoteApp.swift
@@ -31,11 +31,18 @@ struct NucleicRemoteApp: App {
                 // activity flag current so it only notifies for background transitions.
                 .onChange(of: scenePhase) { _, phase in
                     store.setScenePhaseActive(phase == .active)
-                    if phase == .active {
+                    switch phase {
+                    case .active:
                         // Re-plan transports immediately on foreground — the network may have
                         // changed while suspended, so don't wait for a dead socket to notice.
                         store.onForeground()
                         Task { await HeartbeatReporter.reportIfDue() }
+                    case .background:
+                        // Hold the process (and its live sockets) briefly so a quick app-switch
+                        // doesn't drop the connection and force a cold reconnect on return.
+                        store.onBackground()
+                    default:
+                        break
                     }
                 }
         }

From 303cdcc86d73f9eed7a90603de00d68ad35df620 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:46:13 -0700
Subject: [PATCH 14/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Views/SessionDetailView.swift | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Views/SessionDetailView.swift b/NucleicRemote/NucleicRemote/Views/SessionDetailView.swift
index 7bbcefd..0c6c60a 100644
--- a/NucleicRemote/NucleicRemote/Views/SessionDetailView.swift
+++ b/NucleicRemote/NucleicRemote/Views/SessionDetailView.swift
@@ -310,6 +310,12 @@ struct SessionDetailView: View {
                 } else {
                     ApprovalCardView(approval: approval, availableHeight: availableHeight)
                 }
+            } else if store.openApprovalLoading {
+                // Opened from a Live Activity / notification for a session blocked on approval, but
+                // the channel is still (re)connecting — bridge the gap with a placeholder so the tap
+                // lands on the request-in-progress, not a blank transcript. Replaced by the real
+                // ApprovalCardView the instant the snapshot arrives (sub-second reconnect).
+                approvalLoadingCard
             } else if let status = summary?.status {
                 let running = status == .running
                 let canCompose = running || status == .awaitingInput || status.isTerminal

From d07ab7ec982bc096c0563a239910c399ad271b0e Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:46:24 -0700
Subject: [PATCH 15/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../Views/SessionDetailView.swift             | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Views/SessionDetailView.swift b/NucleicRemote/NucleicRemote/Views/SessionDetailView.swift
index 0c6c60a..8247caf 100644
--- a/NucleicRemote/NucleicRemote/Views/SessionDetailView.swift
+++ b/NucleicRemote/NucleicRemote/Views/SessionDetailView.swift
@@ -375,6 +375,28 @@ struct SessionDetailView: View {
         }
     }
 
+    /// The placeholder shown while an approval's details are still loading — mirrors the approval
+    /// card's frame (orange warning header, glass surface) so the real `ApprovalCardView` swaps in
+    /// without a jump. Non-actionable: the real approval id isn't known yet, so there's nothing to
+    /// Allow/Deny until the snapshot lands.
+    private var approvalLoadingCard: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            HStack(spacing: 6) {
+                Image(systemName: "exclamationmark.triangle.fill").foregroundStyle(.orange)
+                Text("Permission requested").font(.subheadline.weight(.semibold))
+            }
+            HStack(spacing: 8) {
+                ProgressView().controlSize(.small)
+                Text("Connecting to your Mac to load this approval…")
+                    .font(.footnote).foregroundStyle(.secondary)
+                Spacer(minLength: 0)
+            }
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(.horizontal, 14).padding(.vertical, 12)
+        .glassSurface(cornerRadius: 26)
+    }
+
     /// A queued follow-up shown above the composer: its text (or attachment names) with the
     /// attachments as chips, and — at control scope — a ✕ that cancels just this message.
     @ViewBuilder

From 5248bc0ff486fdce706b8a21f3de1d7e2531d7ae Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:49:20 -0700
Subject: [PATCH 16/65] Network Reconnection Delay

Nucleic-Session: 4BE3E40C-E939-444C-8AED-93C0AFE13C07
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/HostConnection.swift | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index 0644e40..7d8ce76 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -706,7 +706,10 @@ final class HostConnection {
         }
         revalidateTask?.cancel()
         revalidateTask = Task { [weak self] in
-            let alive = await client.probeAlive(within: .milliseconds(800))
+            // A generous bound on a pong round-trip (LAN <10ms, relay <200ms) — only paid in full
+            // when the link is actually dead; a live one answers and exits in ~1 RTT. Kept well
+            // under the follow-on re-dial so the whole dead-link reconnect stays sub-second.
+            let alive = await client.probeAlive(within: .milliseconds(600))
             guard !Task.isCancelled, let self, self.client === client,
                   self.connectivity.isLive else { return }
             if !alive {

From 7e61921a4a8327072797f016bc3f2b5c8bb0b15a Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:53:22 -0700
Subject: [PATCH 17/65] Adjust Push Notification Logic

Nucleic-Session: 0F065CD6-20FE-4941-ACF5-C57A4572A5A3
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Info.plist | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Info.plist b/NucleicRemote/NucleicRemote/Info.plist
index dccb57d..d5d5e4b 100644
--- a/NucleicRemote/NucleicRemote/Info.plist
+++ b/NucleicRemote/NucleicRemote/Info.plist
@@ -20,6 +20,14 @@
 	     target's "Stamp git commit into Info.plist" build phase (git rev-parse --short HEAD). -->
 	<key>NucleicCommit</key>
 	<string></string>
+	<!-- Wake the app in the background for the relay's silent "clear" push, which recalls the
+	     "waiting for your approval" tickle once the approval is resolved on another device
+	     (docs/CLOUD_INFRA.md §3). Without this mode iOS drops the content-available push and the
+	     stale notification lingers until the next launch. -->
+	<key>UIBackgroundModes</key>
+	<array>
+		<string>remote-notification</string>
+	</array>
 	<key>NSSupportsLiveActivities</key>
 	<true/>
 	<!-- Let the Macs' APNs pushes refresh the glance promptly while the phone is locked — without

From 3dfd28b28dbd6cf3e006dfb0275a0d11864d9f64 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:53:32 -0700
Subject: [PATCH 18/65] Adjust Push Notification Logic

Nucleic-Session: 0F065CD6-20FE-4941-ACF5-C57A4572A5A3
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/PushRegistrar.swift | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/PushRegistrar.swift b/NucleicRemote/NucleicRemote/PushRegistrar.swift
index e2b1b32..ceb5a73 100644
--- a/NucleicRemote/NucleicRemote/PushRegistrar.swift
+++ b/NucleicRemote/NucleicRemote/PushRegistrar.swift
@@ -45,4 +45,20 @@ final class PushAppDelegate: NSObject, UIApplicationDelegate {
     ) {
         // Best-effort: no token → the phone still works on LAN, just no remote wake.
     }
+
+    /// Silent pushes. The relay sends a content-free `clear` (content-available) to recall the
+    /// "waiting for your approval" tickle once the approval is resolved on another device — we
+    /// wake in the background just long enough to withdraw the stale notification. Other silent
+    /// pushes (e.g. the wake tickle itself, which is an alert) don't route here.
+    func application(
+        _ application: UIApplication,
+        didReceiveRemoteNotification userInfo: [AnyHashable: Any],
+        fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
+    ) {
+        guard userInfo["clear"] != nil else { completionHandler(.noData); return }
+        Task { @MainActor in
+            NotificationRouter.shared.withdrawApprovalAttention()
+            completionHandler(.noData)
+        }
+    }
 }

From b31d19aa8a1f4881cbcdeed4f89e51e036317cb6 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:53:39 -0700
Subject: [PATCH 19/65] Adjust Push Notification Logic

Nucleic-Session: 0F065CD6-20FE-4941-ACF5-C57A4572A5A3
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Notifications.swift | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Notifications.swift b/NucleicRemote/NucleicRemote/Notifications.swift
index c12a4b5..c6c3cb6 100644
--- a/NucleicRemote/NucleicRemote/Notifications.swift
+++ b/NucleicRemote/NucleicRemote/Notifications.swift
@@ -20,6 +20,12 @@ final class NotificationRouter: NSObject {
     /// The store notifications act on; set once at app start.
     weak var store: RemoteStore?
 
+    /// The delivered identifier of the remote wake tickle ("A session is waiting for your
+    /// approval"). A remote notification's identifier equals its `apns-collapse-id`, so this must
+    /// match the relay's `APPROVAL_COLLAPSE_ID` (cloud/nucleic-edge/src/apns.ts) for the recall to
+    /// target the right notification.
+    static let approvalTickleIdentifier = "approval-pending"
+
     // Category / action identifiers (also referenced from the notification service side).
     static let approvalCategory = "NUCLEIC_APPROVAL"
     static let approvalActionableCategory = "NUCLEIC_APPROVAL_ACTIONABLE"

From d8138a4fc07ddc910551ab9044ac87a9ca07f3b7 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:53:50 -0700
Subject: [PATCH 20/65] Adjust Push Notification Logic

Nucleic-Session: 0F065CD6-20FE-4941-ACF5-C57A4572A5A3
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Notifications.swift | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Notifications.swift b/NucleicRemote/NucleicRemote/Notifications.swift
index c6c3cb6..228a539 100644
--- a/NucleicRemote/NucleicRemote/Notifications.swift
+++ b/NucleicRemote/NucleicRemote/Notifications.swift
@@ -108,6 +108,23 @@ final class NotificationRouter: NSObject {
         center.removePendingNotificationRequests(withIdentifiers: [identifier])
     }
 
+    /// Recall the shared "waiting for your approval" attention notification once nothing is pending
+    /// anywhere. This is the remote wake tickle (delivered under `approvalTickleIdentifier`) that a
+    /// prior push left on the lock screen — the counterpart to the per-approval `withdrawApproval`.
+    /// Arrives two ways: the relay's silent `clear` push (phone was away), or the store's own
+    /// reconcile when a live socket sees the last approval resolve. Also sweeps any per-approval
+    /// locals a live socket posted but hasn't individually withdrawn, so the lock screen ends clean.
+    func withdrawApprovalAttention() {
+        let center = UNUserNotificationCenter.current()
+        center.removeDeliveredNotifications(withIdentifiers: [Self.approvalTickleIdentifier])
+        center.removePendingNotificationRequests(withIdentifiers: [Self.approvalTickleIdentifier])
+        center.getDeliveredNotifications { delivered in
+            let stale = delivered.map(\.request.identifier).filter { $0.hasPrefix("approval-") }
+            guard !stale.isEmpty else { return }
+            center.removeDeliveredNotifications(withIdentifiers: stale)
+        }
+    }
+
     /// Keep the app-icon badge equal to the NEEDS YOU count (UX_IOS §8).
     func updateBadge(_ count: Int) {
         UNUserNotificationCenter.current().setBadgeCount(count)

From c71150d5ab1ea9665de77a20ad444d9d019fdc61 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:54:02 -0700
Subject: [PATCH 21/65] Adjust Push Notification Logic

Nucleic-Session: 0F065CD6-20FE-4941-ACF5-C57A4572A5A3
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 2cda3d5..297536e 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -773,6 +773,17 @@ final class RemoteStore: ObservableObject {
     /// Activity summary. `sessions`/`liveSessions` are already the merged aggregate.
     private func refreshAggregate() {
         NotificationRouter.shared.updateBadge(needsYouCount)
+        // When no session is blocked on an approval anymore, recall the "waiting for your approval"
+        // wake tickle a prior push may have left on the lock screen. Complements the relay's silent
+        // clear (which covers phones that were away): this catches the phone that saw the tickle and
+        // then connected, so the resolution arrives as a broadcast rather than a push. Idempotent —
+        // a no-op when the tickle isn't there. Per-approval locals are withdrawn as each resolves.
+        let approvalsPending = liveSessions.contains {
+            $0.pendingApprovalCount > 0 || $0.status == .awaitingApproval
+        }
+        if !approvalsPending {
+            NotificationRouter.shared.withdrawApprovalAttention()
+        }
         LiveActivityManager.shared.sync(hostName: hostName, sessions: liveSessions)
     }
 

From 0c6841a8fbdb454c6d46633f2dd040d2a373f1b8 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:55:08 -0700
Subject: [PATCH 22/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../Shared/SessionActivityAttributes.swift          | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/NucleicRemote/Shared/SessionActivityAttributes.swift b/NucleicRemote/Shared/SessionActivityAttributes.swift
index 281d720..9809710 100644
--- a/NucleicRemote/Shared/SessionActivityAttributes.swift
+++ b/NucleicRemote/Shared/SessionActivityAttributes.swift
@@ -64,6 +64,19 @@ struct NucleicSessionAttributes: ActivityAttributes {
         /// The most urgent sessions, attention-first (capped, typically ≤3): the detail rows.
         var lines: [SessionLine]
 
+        /// The attention-bearing fingerprint of the glance: the headline counts plus each row's
+        /// identity and `kind`. Deliberately EXCLUDES the mid-turn churn (files/±lines and the
+        /// churn-derived detail), which ticks on every transcript edit while the agent works.
+        /// `LiveActivityManager` gates its `activity.update` on this so the glance refreshes on a
+        /// status change — a session starting, finishing, needing approval/input — not on every diff
+        /// delta mid-turn (which would burn ActivityKit's update budget for an illegible number).
+        /// Mirrors the host's `LiveActivitySnapshot.attentionSignature`.
+        var attentionSignature: [String] {
+            var parts = ["run:\(runningCount)", "need:\(needsYouCount)", "appr:\(approvalCount)"]
+            parts.append(contentsOf: lines.map { "\($0.id):\($0.kind.rawValue)" })
+            return parts
+        }
+
         /// The single most urgent session (drives the compact/minimal regions).
         var top: SessionLine? { lines.first }
         /// Whether anything needs the user (waiting session or a pending approval).

From 52df910d6c5b6889764e5c4906bb7c84e429f8b1 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:55:21 -0700
Subject: [PATCH 23/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/LiveActivityManager.swift | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index 19ece0d..c0564b6 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -122,10 +122,12 @@ final class LiveActivityManager {
         }
     }
 
-    /// Apply `state` to the Activity — deduped against the last push and coalesced through one
-    /// serial task so the newest state always wins.
+    /// Apply `state` to the Activity — coalesced through one serial task so the newest state always
+    /// wins, and gated on the attention signature so a mid-turn churn tick (which changes the diff
+    /// totals on every transcript edit but no status) doesn't spend ActivityKit's update budget. The
+    /// fresh churn still rides along on the next status-driven push.
     private func push(_ state: NucleicSessionAttributes.ContentState, hostName: String) {
-        guard state != lastState else { return }
+        guard state.attentionSignature != lastState?.attentionSignature else { return }
         lastState = state
 
         guard let activity else {

From 345840d9ccc66f2031206be37835b4f32ba0087e Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:56:34 -0700
Subject: [PATCH 24/65] Adjust Push Notification Logic

Nucleic-Session: 0F065CD6-20FE-4941-ACF5-C57A4572A5A3
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/PushRegistrar.swift | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/NucleicRemote/NucleicRemote/PushRegistrar.swift b/NucleicRemote/NucleicRemote/PushRegistrar.swift
index ceb5a73..0f0b7b5 100644
--- a/NucleicRemote/NucleicRemote/PushRegistrar.swift
+++ b/NucleicRemote/NucleicRemote/PushRegistrar.swift
@@ -55,10 +55,11 @@ final class PushAppDelegate: NSObject, UIApplicationDelegate {
         didReceiveRemoteNotification userInfo: [AnyHashable: Any],
         fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
     ) {
-        guard userInfo["clear"] != nil else { completionHandler(.noData); return }
-        Task { @MainActor in
-            NotificationRouter.shared.withdrawApprovalAttention()
-            completionHandler(.noData)
+        if userInfo["clear"] != nil {
+            // Fire-and-forget on the main actor (NotificationRouter is @MainActor); the removal is a
+            // quick UNUserNotificationCenter call, so we can report .noData right away.
+            Task { @MainActor in NotificationRouter.shared.withdrawApprovalAttention() }
         }
+        completionHandler(.noData)
     }
 }

From 48fa58017fb0473b81cdbe15b0113fc4d1b79b8d Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 12:56:40 -0700
Subject: [PATCH 25/65] Adjust Push Notification Logic

Nucleic-Session: 0F065CD6-20FE-4941-ACF5-C57A4572A5A3
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Notifications.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/Notifications.swift b/NucleicRemote/NucleicRemote/Notifications.swift
index 228a539..fb2d0dc 100644
--- a/NucleicRemote/NucleicRemote/Notifications.swift
+++ b/NucleicRemote/NucleicRemote/Notifications.swift
@@ -121,7 +121,7 @@ final class NotificationRouter: NSObject {
         center.getDeliveredNotifications { delivered in
             let stale = delivered.map(\.request.identifier).filter { $0.hasPrefix("approval-") }
             guard !stale.isEmpty else { return }
-            center.removeDeliveredNotifications(withIdentifiers: stale)
+            UNUserNotificationCenter.current().removeDeliveredNotifications(withIdentifiers: stale)
         }
     }
 

From 2c911b19117f152af2ab21e6db1dfbcb9994fb8c Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:03:11 -0700
Subject: [PATCH 26/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/LiveActivityManager.swift | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index c0564b6..5d245ab 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -29,6 +29,15 @@ final class LiveActivityManager {
     /// connectivity, pong, diff ticks…), most of which leave the aggregate identical. Burning the
     /// budget on those is exactly what makes a *real* change land late and the glance read stale.
     private var lastState: NucleicSessionAttributes.ContentState?
+    /// When the last update was applied — the clock for the mid-turn churn refresh. A status change
+    /// (attention-signature shift) updates immediately regardless; a churn-only change (diff totals
+    /// ticking as the agent edits) only re-applies once `churnRefreshInterval` has elapsed, so a busy
+    /// turn refreshes the numbers slowly instead of on every transcript delta. A passive timestamp
+    /// check on the normal path — no timer sits in front of a status update.
+    private var lastPushAt: Date?
+    /// How slowly the mid-turn diff totals refresh while nothing else about a session changes —
+    /// mirrors the host's `SyncHost.churnRefreshInterval` so the local and pushed glances agree.
+    private static let churnRefreshInterval: TimeInterval = 45
     /// The newest state waiting to be applied, and the single task draining it. Coalescing to the
     /// latest through one serial task means the newest data always wins — firing an unstructured
     /// `Task` per `sync` let a later update lose a race to an earlier one and freeze the glance.

From 27375bda4d0116d1779032b8babec975439e5cc5 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:03:19 -0700
Subject: [PATCH 27/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/LiveActivityManager.swift          | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index 5d245ab..c9fa109 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -136,8 +136,18 @@ final class LiveActivityManager {
     /// totals on every transcript edit but no status) doesn't spend ActivityKit's update budget. The
     /// fresh churn still rides along on the next status-driven push.
     private func push(_ state: NucleicSessionAttributes.ContentState, hostName: String) {
-        guard state.attentionSignature != lastState?.attentionSignature else { return }
+        // Apply immediately when the attention signature shifts (start/finish/approval/input — the
+        // alert-worthy changes). Otherwise the only difference is mid-turn churn (diff totals); let
+        // that refresh on a slow cadence so it stays roughly current without spending ActivityKit's
+        // budget on every delta. Elapsed-time gate, not a sleeping timer — a status change is never
+        // held behind it.
+        let signatureChanged = state.attentionSignature != lastState?.attentionSignature
+        let churnRefreshDue = lastPushAt.map {
+            Date().timeIntervalSince($0) >= Self.churnRefreshInterval
+        } ?? true
+        guard signatureChanged || (state != lastState && churnRefreshDue) else { return }
         lastState = state
+        lastPushAt = Date()
 
         guard let activity else {
             // Recover an Activity that survived an app relaunch before starting a new one; the

From 5394ae677a389fa98d5986a609aa0efc821f066c Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:03:23 -0700
Subject: [PATCH 28/65] iOS Live Activity Updates

Nucleic-Session: 665980BA-E8A5-4E84-9DF4-1757CF792353
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/LiveActivityManager.swift | 1 +
 1 file changed, 1 insertion(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index c9fa109..c9bde83 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -212,6 +212,7 @@ final class LiveActivityManager {
         dismissTask = nil
         pendingState = nil
         lastState = nil
+        lastPushAt = nil
         let tracked = activity
         self.activity = nil
         if let tracked { onActivityEnded?(tracked.id) }  // let the Macs stop pushing to this token

From 546ef4eb3f2bda89101bee223f3465ddf7cb0261 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:36:09 -0700
Subject: [PATCH 29/65] Network Connection Logic Enhancement

Nucleic-Session: 93A70648-2057-4092-9372-860E1BA151D8
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/HostConnection.swift | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index 7d8ce76..85d84c1 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -117,6 +117,9 @@ final class HostConnection {
     private var retryTask: Task<Void, Never>?
     private var revalidateTask: Task<Void, Never>?
     private var lanConnectTimeout: Task<Void, Never>?
+    /// In-flight LAN-reachability probe (the tailnet/relay → LAN return leg). Nil unless a probe is
+    /// running; at most one at a time so repeated path-change events don't stack.
+    private var lanUpgradeProbe: Task<Void, Never>?
     private var reconnectAttempts = 0
     private var seenSeq: Set<UInt64> = []
 

From f1385adc72fad9e7ea9316a7ef73a2c827fa1844 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:36:28 -0700
Subject: [PATCH 30/65] Network Connection Logic Enhancement

Nucleic-Session: 93A70648-2057-4092-9372-860E1BA151D8
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/HostConnection.swift | 66 +++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index 85d84c1..cd74552 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -689,6 +689,72 @@ final class HostConnection {
         if !connectivity.isLive, pathMonitor.isSatisfied {
             reconnectAttempts = 0
             reconnect(to: host)
+            return
+        }
+        // Live over a fallback transport (tailnet/relay) and a LAN path just reappeared (rejoined the
+        // Mac's Wi-Fi) → the return leg of the switch above. The tunnel survives the interface change
+        // on its own, so nothing else would ever re-plan back down to the direct path — probe LAN and
+        // swap to it if the Mac actually answers here.
+        maybeUpgradeToLAN()
+    }
+
+    /// Probe whether the pinned Mac is reachable over LAN right now and, if so, switch back to the
+    /// direct connection — the tailnet/relay → LAN return leg. Only meaningful while live over a
+    /// non-LAN transport with a LAN-capable path available; a bare TCP connect to the pinned LAN
+    /// endpoint that reaches `.ready` is the "the Mac is on this network" signal. The probe runs
+    /// entirely off the live connection, so joining a *foreign* Wi-Fi (no Mac here) costs one short,
+    /// silent connect attempt and leaves the working tunnel untouched.
+    private func maybeUpgradeToLAN() {
+        guard let host = pinnedHost, connectivity.isLive, activeTransport != .lan,
+              pathMonitor.canUseLAN, lanUpgradeProbe == nil,
+              let endpoint = discovery.endpoint(
+                forFingerprint: host.fingerprint, lanHost: host.lanHost, lanPort: host.lanPort)
+        else { return }
+        lanUpgradeProbe = Task { [weak self] in
+            let reachable = await Self.probeReachable(endpoint)
+            guard let self else { return }
+            self.lanUpgradeProbe = nil
+            // Re-check the world didn't move under us during the probe (still live, still not on LAN,
+            // LAN still available) before tearing a working connection down.
+            guard !Task.isCancelled, reachable, self.connectivity.isLive,
+                  self.activeTransport != .lan, self.pathMonitor.canUseLAN,
+                  let host = self.pinnedHost
+            else { return }
+            self.reconnectAttempts = 0
+            self.reconnect(to: host)  // rebuilds the candidate chain LAN-first
+        }
+    }
+
+    /// Bare TCP reachability check for `maybeUpgradeToLAN`: does `endpoint` accept a connection within
+    /// `timeoutSeconds`? Tears the probe socket down regardless — it only tests reachability, never
+    /// carries traffic. A short timeout so a foreign Wi-Fi (Mac absent) doesn't stall the check.
+    private static func probeReachable(_ endpoint: NWEndpoint, timeoutSeconds: Double = 3) async -> Bool {
+        let params = NWParameters.tcp
+        params.includePeerToPeer = true
+        let connection = NWConnection(to: endpoint, using: params)
+        let queue = DispatchQueue(label: "nucleic.remote.lanprobe")
+        let once = ProbeOnce()
+        return await withTaskCancellationHandler {
+            await withCheckedContinuation { (cont: CheckedContinuation<Bool, Never>) in
+                connection.stateUpdateHandler = { state in
+                    switch state {
+                    case .ready:
+                        if once.take() { cont.resume(returning: true) }
+                        connection.cancel()
+                    case .failed, .cancelled:
+                        if once.take() { cont.resume(returning: false) }
+                    default:
+                        break
+                    }
+                }
+                queue.asyncAfter(deadline: .now() + timeoutSeconds) {
+                    if once.take() { cont.resume(returning: false) }
+                    connection.cancel()
+                }
+                connection.start(queue: queue)
+            }
+        } onCancel: {
+            connection.cancel()
         }
     }
 

From 475447d1037531ab10324556d630f14555cba8ab Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:36:37 -0700
Subject: [PATCH 31/65] Network Connection Logic Enhancement

Nucleic-Session: 93A70648-2057-4092-9372-860E1BA151D8
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/HostConnection.swift | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index cd74552..4083836 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -773,6 +773,10 @@ final class HostConnection {
             reconnect(to: host)
             return
         }
+        // Already live — but if we're on a fallback transport and a LAN path exists now, try to move
+        // back to the direct connection (foregrounding on the Mac's Wi-Fi after being away on cellular,
+        // where no path-change event fired while suspended).
+        maybeUpgradeToLAN()
         revalidateTask?.cancel()
         revalidateTask = Task { [weak self] in
             // A generous bound on a pong round-trip (LAN <10ms, relay <200ms) — only paid in full

From 1a99d5cae36649fbb3f9733021bb3530435621fb Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:36:45 -0700
Subject: [PATCH 32/65] Network Connection Logic Enhancement

Nucleic-Session: 93A70648-2057-4092-9372-860E1BA151D8
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/HostConnection.swift | 1 +
 1 file changed, 1 insertion(+)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index 4083836..ab42506 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -808,6 +808,7 @@ final class HostConnection {
         retryTask?.cancel(); retryTask = nil
         revalidateTask?.cancel(); revalidateTask = nil
         connectTask?.cancel(); connectTask = nil
+        lanUpgradeProbe?.cancel(); lanUpgradeProbe = nil
         connectPlan = nil
         teardownClient()
     }

From afeeff96b1079c43cabbe5906e534778f063ff14 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:36:54 -0700
Subject: [PATCH 33/65] Network Connection Logic Enhancement

Nucleic-Session: 93A70648-2057-4092-9372-860E1BA151D8
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/HostConnection.swift      | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/HostConnection.swift b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
index ab42506..6021e0a 100644
--- a/NucleicRemote/NucleicRemote/Models/HostConnection.swift
+++ b/NucleicRemote/NucleicRemote/Models/HostConnection.swift
@@ -820,3 +820,17 @@ final class HostConnection {
         client = nil
     }
 }
+
+/// A thread-safe "fire once" latch: the `NWConnection` reachability probe resolves its continuation
+/// from a state callback *or* a timeout, on the same queue but from different closures — `take()`
+/// returns true to exactly one caller so the continuation is resumed exactly once.
+private final class ProbeOnce: @unchecked Sendable {
+    private let lock = NSLock()
+    private var done = false
+    func take() -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        if done { return false }
+        done = true
+        return true
+    }
+}

From 72cdf813bf5c22d633f0e938b9f392a1abbd9701 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:43:48 -0700
Subject: [PATCH 34/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/LiveActivityManager.swift          | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index c9bde83..e34e18b 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -49,8 +49,20 @@ final class LiveActivityManager {
     /// is backgrounded and its sync socket is suspended (UX_IOS §5.3).
     var onPushToken: ((_ token: String, _ activityID: String) -> Void)?
     var onActivityEnded: ((_ activityID: String) -> Void)?
+    /// Set by `RemoteStore` to ship this device's **push-to-start** token to the paired Macs. Unlike
+    /// `onPushToken` (a per-activity update token that exists only once an Activity does), this token
+    /// is device-scoped and exists before any Activity — it's what lets a Mac *create* the glance
+    /// over APNs when work starts while the app is closed, so it appears without the user opening the
+    /// app first (iOS 17.2+, UX_IOS §5.3).
+    var onPushToStartToken: ((_ token: String) -> Void)?
     /// Streams the activity's per-activity APNS update token (it can rotate); cancelled on end.
     private var tokenObservation: Task<Void, Never>?
+    /// Streams this device's push-to-start token (it can rotate). Device-scoped, so — unlike
+    /// `tokenObservation` — it lives for the whole process and is never cancelled on `end()`.
+    private var pushToStartObservation: Task<Void, Never>?
+    /// Observes Activities that appear without us creating them — i.e. ones a Mac push-started while
+    /// the app was closed — so we adopt them and forward their update token. Also process-lived.
+    private var activityAdoptionObservation: Task<Void, Never>?
 
     /// Reconcile the Activity with the current session set.
     func sync(hostName: String, sessions: [WireSessionSummary]) {

From aa6e9761374c4305c0829976b87c898a478f1d75 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:44:01 -0700
Subject: [PATCH 35/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/LiveActivityManager.swift   | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index e34e18b..14b2c9b 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -189,6 +189,41 @@ final class LiveActivityManager {
         enqueue(state)
     }
 
+    /// Start the process-lived observers that make push-to-start work: the device's push-to-start
+    /// token (forwarded to the Macs so they can create the glance over APNs) and adoption of any
+    /// Activity a Mac push-started while the app was closed. Idempotent — safe to call on every
+    /// bridge setup; the guards keep a single observer each.
+    func beginPushToStartObservation() {
+        guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }
+        if pushToStartObservation == nil {
+            pushToStartObservation = Task { [weak self] in
+                for await data in Activity<NucleicSessionAttributes>.pushToStartTokenUpdates {
+                    let hex = data.map { String(format: "%02x", $0) }.joined()
+                    self?.onPushToStartToken?(hex)
+                }
+            }
+        }
+        if activityAdoptionObservation == nil {
+            activityAdoptionObservation = Task { [weak self] in
+                for await activity in Activity<NucleicSessionAttributes>.activityUpdates {
+                    self?.adopt(activity)
+                }
+            }
+        }
+    }
+
+    /// Adopt an Activity we didn't create locally — almost always one a Mac push-started while the
+    /// app was closed. Taking ownership wires up its update-token stream (`observePushToken`) so the
+    /// Macs can keep the glance fresh the normal way, and collapses any strays to one. If we already
+    /// track an Activity, leave it: the local `Activity.request` path and `endStrays` already keep a
+    /// single glance, and re-adopting would just churn the token observation.
+    private func adopt(_ activity: Activity<NucleicSessionAttributes>) {
+        guard self.activity == nil else { return }
+        self.activity = activity
+        observePushToken(activity)
+        endStrays(keeping: activity.id)
+    }
+
     /// Forward the activity's APNS update token (and its rotations) to `RemoteStore`.
     private func observePushToken(_ activity: Activity<NucleicSessionAttributes>) {
         tokenObservation?.cancel()

From 7a6bb5df801236518a5f2f7c78e5edc50603eb75 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:44:23 -0700
Subject: [PATCH 36/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 297536e..4960e4d 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -563,8 +563,10 @@ final class RemoteStore: ObservableObject {
             self.refreshAggregate()
             self.flushPendingNotificationDecision()
             // A host that just connected (or reconnected) needs the current Live Activity token
-            // so it can push while the phone is away.
+            // so it can push while the phone is away — and the push-to-start token so it can create
+            // the glance cold when work starts before the app is opened.
             self.syncLiveActivityRegistration()
+            self.syncPushToStartRegistration()
         }
         cb.openSnapshot = { [weak self] snap in
             guard let self, hostID == self.openSessionHostID, snap.summary.sessionID == self.openSessionID else { return }

From 0d3894a4282c031ec440d784bf7e3a1d29333341 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:44:35 -0700
Subject: [PATCH 37/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift        | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 4960e4d..aa0093b 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -1203,6 +1203,12 @@ final class RemoteStore: ObservableObject {
     /// Host ids that already have the current token (re-sent to a host that (re)connects, and
     /// re-sent to everyone when the token rotates).
     private var liveActivitySentTo: Set<String> = []
+    /// This device's push-to-start token (iOS 17.2+), shipped to every capable Mac so it can create
+    /// the Live Activity over APNs when work starts before the app is opened. Device-scoped, so —
+    /// unlike `liveActivityReg` — it persists across activities and isn't cleared when one ends.
+    private var pushToStartToken: String?
+    /// Host ids that already have the current push-to-start token (mirrors `liveActivitySentTo`).
+    private var pushToStartSentTo: Set<String> = []
 
     private func setupLiveActivityBridge() {
         LiveActivityManager.shared.onPushToken = { [weak self] token, activityID in
@@ -1211,6 +1217,15 @@ final class RemoteStore: ObservableObject {
             self.liveActivitySentTo.removeAll()  // a fresh token must reach every host again
             self.syncLiveActivityRegistration()
         }
+        LiveActivityManager.shared.onPushToStartToken = { [weak self] token in
+            guard let self, self.pushToStartToken != token else { return }
+            self.pushToStartToken = token
+            self.pushToStartSentTo.removeAll()  // a fresh token must reach every host again
+            self.syncPushToStartRegistration()
+        }
+        // Start observing the push-to-start token (and adopting any push-started activity) now — it's
+        // device-scoped and must be captured even before any Activity exists.
+        LiveActivityManager.shared.beginPushToStartObservation()
         LiveActivityManager.shared.onActivityEnded = { [weak self] activityID in
             guard let self else { return }
             self.liveActivityReg = nil

From 5d818f061f1152800476ed3e533c211332736925 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:44:49 -0700
Subject: [PATCH 38/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift        | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index aa0093b..50f56b4 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -1251,6 +1251,21 @@ final class RemoteStore: ObservableObject {
         }
     }
 
+    /// Send the current push-to-start token to every live, capable host that hasn't got it yet — the
+    /// mirror of `syncLiveActivityRegistration` for the device-scoped token that lets a host create
+    /// the glance over APNs when work starts before the app is opened (iOS 17.2+).
+    private func syncPushToStartRegistration() {
+        guard let token = pushToStartToken else { return }
+        // A host that dropped should re-register when it returns.
+        pushToStartSentTo = pushToStartSentTo.filter { connections[$0]?.connectivity.isLive == true }
+        for (id, conn) in connections {
+            guard conn.connectivity.isLive, conn.capabilities.canPushLiveActivity,
+                  !pushToStartSentTo.contains(id) else { continue }
+            conn.send(.registerPushToStartToken(token))
+            pushToStartSentTo.insert(id)
+        }
+    }
+
     // MARK: - Demo simulator (offline, interactive)
     //
     // In demo mode there's no host, so writes can't go over the wire. Instead they mutate the

From 408a842d6689b5f74f0401d2f52247a3f8eba10b Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:44:56 -0700
Subject: [PATCH 39/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 50f56b4..5157477 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -1186,7 +1186,7 @@ final class RemoteStore: ObservableObject {
         // `requestPairingCode`/`cancelPairingCode` are sent straight to the chosen host by
         // `requestPairingCode()`/`cancelPairingCode()`, not through this owner-routing switch.
         case .hello, .ping, .listPeers, .addressUpdate, .meshRoster,
-             .registerLiveActivity, .endLiveActivity,
+             .registerLiveActivity, .endLiveActivity, .registerPushToStartToken,
              .transferOffer, .transferChunk, .transferCommit, .transferCancel, .fetchTranscript,
              .requestPairingCode, .cancelPairingCode, .respondMacPair:
             break

From 8bcae08604fece17616d140545126311cab52f8e Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:45:21 -0700
Subject: [PATCH 40/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 5157477..be50f16 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -1323,7 +1323,7 @@ final class RemoteStore: ObservableObject {
              .addressUpdate, .meshRoster,
              // Live Activity push registration is a real-connection concern (there's no host to
              // push in demo), so it's inert here.
-             .registerLiveActivity, .endLiveActivity,
+             .registerLiveActivity, .endLiveActivity, .registerPushToStartToken,
              // Session transfer (mesh P5) is a Mac↔Mac flow — the phone never originates these,
              // and demo has no peer Macs, so they're inert here.
              .transferOffer, .transferChunk, .transferCommit, .transferCancel,

From 0578f5bcc0e5f54001315158d50a83996f9dbb23 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:51:05 -0700
Subject: [PATCH 41/65] Investigate Live Activity Session Load

Nucleic-Session: 044A9B93-AB31-4B6B-9A27-3631261269B1
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index be50f16..419fdde 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -558,6 +558,11 @@ final class RemoteStore: ObservableObject {
         var cb = HostConnection.Callbacks()
         cb.didUpdate = { [weak self] in
             guard let self else { return }
+            // Complete a session opened before its owning Mac was live — a Live Activity /
+            // notification cold-launch deep link opens the detail while the app is still dialing, so
+            // `open()` couldn't bind it to a connection that didn't exist yet. Runs before the merge
+            // so the aggregate picks up the freshly-bound host's connectivity/scope this pass.
+            self.bindOpenSessionIfNeeded()
             // Any host's change re-merges the aggregate the flat state binds to (mesh P3).
             self.rebuildAggregate()
             self.refreshAggregate()

From 6fc6bf80f55edfb01aa43a48503cf2d673e8bb3e Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:51:24 -0700
Subject: [PATCH 42/65] Investigate Live Activity Session Load

Nucleic-Session: 044A9B93-AB31-4B6B-9A27-3631261269B1
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift    | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 419fdde..fbc55a8 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -929,6 +929,26 @@ final class RemoteStore: ObservableObject {
         connection(owningSession: sessionID)?.fetchFullTranscript(sessionID)
     }
 
+    /// Bind the open session to its owning Mac once that Mac is live — the deferred half of `open()`
+    /// for a session opened before any connection existed (a Live Activity / notification cold-launch
+    /// deep link). Because `open()` ran while the app was still dialing, `connection(owningSession:)`
+    /// found nothing: the host binding stayed nil, no `subscribe` went out, and the transcript
+    /// callbacks — all gated on `openSessionHostID` — dropped everything the host later sent, leaving
+    /// the detail stuck on "Disconnected" with an empty transcript and a dead composer. Once a host
+    /// connects and lists its sessions, `didUpdate` calls this: it finds the owner and finishes the
+    /// subscription so the transcript loads and connectivity/scope follow the bound host. Idempotent
+    /// and cheap — a no-op on the common path where `open()` already bound a live connection.
+    private func bindOpenSessionIfNeeded() {
+        guard !demoMode, let sessionID = openSessionID,
+              let conn = connection(owningSession: sessionID), conn.connectivity.isLive else { return }
+        // Already bound to this live host with its subscription in place — nothing to redo.
+        guard openSessionHostID != conn.hostID || conn.openSessionID != sessionID else { return }
+        openSessionHostID = conn.hostID
+        conn.openSessionID = sessionID
+        conn.send(.subscribe(Subscribe(sessionID: sessionID, sinceSeq: nil, verbosity: .full)))
+        conn.fetchFullTranscript(sessionID)
+    }
+
     /// Ask the host for the open session's full patch (Diff tab). No-op when the host
     /// doesn't advertise the capability — the view falls back to the diffstat summary.
     func fetchDiff(_ sessionID: SessionID) {

From adf311b1e175f7f5f3a3fc9cbae95e81c557c6d1 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 13:51:59 -0700
Subject: [PATCH 43/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index fbc55a8..16f7556 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -1284,7 +1284,9 @@ final class RemoteStore: ObservableObject {
         // A host that dropped should re-register when it returns.
         pushToStartSentTo = pushToStartSentTo.filter { connections[$0]?.connectivity.isLive == true }
         for (id, conn) in connections {
-            guard conn.connectivity.isLive, conn.capabilities.canPushLiveActivity,
+            // Gate on the dedicated push-to-start bit, not `canPushLiveActivity`: an older host can
+            // advertise the latter yet throw on the unknown `registerPushToStartToken` tag.
+            guard conn.connectivity.isLive, conn.capabilities.canPushToStartLiveActivity,
                   !pushToStartSentTo.contains(id) else { continue }
             conn.send(.registerPushToStartToken(token))
             pushToStartSentTo.insert(id)

From b803313477d9a9eb59ecd852a94d3f9467927fe5 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:03:19 -0700
Subject: [PATCH 44/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 16f7556..62f4a3d 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -230,6 +230,12 @@ final class RemoteStore: ObservableObject {
 
     var canControl: Bool { grantedScope >= .control }
 
+    /// The process-wide store. The SwiftUI `App` binds its `@StateObject` to this instance so the
+    /// UI and any headless entry point share one store — in particular the background push handler
+    /// (`PushAppDelegate`), which on a silent launch has no mounted scene (`onAppear` never fires)
+    /// and so must reach the store directly to bring it online and adopt a push-started Live Activity.
+    static let shared = RemoteStore()
+
     private let identity = IdentityStore.loadOrCreateIdentity()
     let discovery = LANDiscovery()
     /// Proactive network-path awareness (shared across every host connection): flips transports the

From 7aa202f3ad7847527c0ed76039b2684b40df8b4f Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:03:24 -0700
Subject: [PATCH 45/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/NucleicRemoteApp.swift | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/NucleicRemoteApp.swift b/NucleicRemote/NucleicRemote/NucleicRemoteApp.swift
index 0337176..7209464 100644
--- a/NucleicRemote/NucleicRemote/NucleicRemoteApp.swift
+++ b/NucleicRemote/NucleicRemote/NucleicRemoteApp.swift
@@ -2,7 +2,9 @@ import SwiftUI
 
 @main
 struct NucleicRemoteApp: App {
-    @StateObject private var store = RemoteStore()
+    // Bind to the shared instance so the background push handler (which runs with no mounted scene)
+    // and the UI drive the same store.
+    @StateObject private var store = RemoteStore.shared
     @Environment(\.scenePhase) private var scenePhase
     @UIApplicationDelegateAdaptor(PushAppDelegate.self) private var pushDelegate
 

From c362480c8ab3ef477b3544f7a8b69ccfd01f3bb8 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:03:36 -0700
Subject: [PATCH 46/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift    | 22 ++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 62f4a3d..b592fd2 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -320,11 +320,7 @@ final class RemoteStore: ObservableObject {
     func onAppear() {
         setupLiveActivityBridge()
         if demoMode { seedDemo(); return }
-        // Re-plan every connection the moment the network path changes (left Wi-Fi, joined a
-        // network, cellular⇄Wi-Fi) — the proactive half of "immediate switchover".
-        pathMonitor.onChange = { [weak self] in self?.handlePathChange() }
-        pathMonitor.start()
-        discovery.start()
+        startNetworkingIfNeeded()
         if isPaired {
             // Show the saved chat history immediately, before any host connects.
             if sessions.isEmpty { sessions = cachedSummaries }
@@ -332,6 +328,22 @@ final class RemoteStore: ObservableObject {
         }
     }
 
+    /// Whether `startNetworkingIfNeeded` has already wired up path monitoring + LAN discovery.
+    private var networkingStarted = false
+
+    /// Start the shared network-path monitor and LAN discovery once. Factored out of `onAppear` so
+    /// the background push handler — which runs when `onAppear` never fired (silent launch, no scene)
+    /// — can bring the same machinery up before it dials.
+    private func startNetworkingIfNeeded() {
+        guard !networkingStarted else { return }
+        networkingStarted = true
+        // Re-plan every connection the moment the network path changes (left Wi-Fi, joined a
+        // network, cellular⇄Wi-Fi) — the proactive half of "immediate switchover".
+        pathMonitor.onChange = { [weak self] in self?.handlePathChange() }
+        pathMonitor.start()
+        discovery.start()
+    }
+
     /// A network-path change: tell each host connection to re-plan its transport now.
     private func handlePathChange() {
         guard !demoMode else { return }

From 3806229442a5bc380ed69851b94fba11e03d72ce Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:04:06 -0700
Subject: [PATCH 47/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift    | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index b592fd2..9bd57b2 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -395,6 +395,50 @@ final class RemoteStore: ObservableObject {
         #endif
     }
 
+    /// Handle the host's silent "adopt" wake (UX_IOS §5.3): a session started while the app was
+    /// closed, the host push-*started* the Live Activity, and now the phone must come online long
+    /// enough to harvest that activity's per-activity update token and register it — so live updates
+    /// (and a clean end) resume without the user ever opening the app. Called from `PushAppDelegate`
+    /// on a `content-available` background push, which may relaunch the app with no scene, so this
+    /// does the setup `onAppear` normally would. Holds a background-task assertion until the token is
+    /// registered with a host or the window closes, then calls `completion`. Best-effort: iOS may
+    /// deny background runtime (budget, force-quit), in which case the glance keeps its start-time
+    /// state until the app next runs.
+    func handleLiveActivityAdoptWake(completion: @escaping () -> Void) {
+        guard !demoMode, isPaired else { completion(); return }
+        setupLiveActivityBridge()   // starts the push-to-start + adoption observers if not already
+        startNetworkingIfNeeded()
+        #if canImport(UIKit)
+        var bgTask: UIBackgroundTaskIdentifier = .invalid
+        var finished = false
+        let finish = {
+            guard !finished else { return }
+            finished = true
+            if bgTask != .invalid {
+                UIApplication.shared.endBackgroundTask(bgTask)
+                bgTask = .invalid
+            }
+            completion()
+        }
+        bgTask = UIApplication.shared.beginBackgroundTask(withName: "nucleic.liveactivity.adopt") {
+            finish()   // the OS reclaimed the grant before we finished — report what we have
+        }
+        #else
+        let finish = completion
+        #endif
+        pathMonitor.refresh()
+        reconnect()
+        // Poll until the harvested update token has reached a host (`liveActivitySentTo` fills in via
+        // the adopt → onPushToken → syncLiveActivityRegistration chain), or we run out of runtime.
+        Task { @MainActor [weak self] in
+            for _ in 0..<50 {   // ~25s at a 0.5s cadence, inside iOS's ~30s background grant
+                guard let self, self.liveActivitySentTo.isEmpty else { break }
+                try? await Task.sleep(for: .milliseconds(500))
+            }
+            finish()
+        }
+    }
+
     private func seedDemo() {
         connectivity = .connected(.lan)
         hostName = "Andrew's Mac"

From 393b2f29f40c5fd1e9f75a52a8a02a0514632269 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:04:29 -0700
Subject: [PATCH 48/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 9bd57b2..f7fe423 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -1297,7 +1297,13 @@ final class RemoteStore: ObservableObject {
     /// Host ids that already have the current push-to-start token (mirrors `liveActivitySentTo`).
     private var pushToStartSentTo: Set<String> = []
 
+    /// Guards `setupLiveActivityBridge` — it's called from both `onAppear` and the background adopt
+    /// wake, and installing the callbacks / observers once is enough.
+    private var liveActivityBridgeSetup = false
+
     private func setupLiveActivityBridge() {
+        guard !liveActivityBridgeSetup else { return }
+        liveActivityBridgeSetup = true
         LiveActivityManager.shared.onPushToken = { [weak self] token, activityID in
             guard let self, self.liveActivityReg?.token != token else { return }
             self.liveActivityReg = (token, activityID)

From a5ba88bee2d768ceb7dcf910ff4316889fb8d080 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:04:38 -0700
Subject: [PATCH 49/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/LiveActivityManager.swift | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/LiveActivityManager.swift b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
index 14b2c9b..73dddd9 100644
--- a/NucleicRemote/NucleicRemote/LiveActivityManager.swift
+++ b/NucleicRemote/NucleicRemote/LiveActivityManager.swift
@@ -195,6 +195,12 @@ final class LiveActivityManager {
     /// bridge setup; the guards keep a single observer each.
     func beginPushToStartObservation() {
         guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }
+        // Grab an activity that already exists when we start observing — e.g. one a Mac push-started
+        // while the app was closed, which won't re-emit through `activityUpdates` for a late observer.
+        // This is what lets a background "adopt" wake harvest and forward its update token.
+        if activity == nil, let existing = Activity<NucleicSessionAttributes>.activities.first {
+            adopt(existing)
+        }
         if pushToStartObservation == nil {
             pushToStartObservation = Task { [weak self] in
                 for await data in Activity<NucleicSessionAttributes>.pushToStartTokenUpdates {

From aa159817f21e58c7836de0114881f3c1694766f7 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:04:53 -0700
Subject: [PATCH 50/65] Launch Activity Logic

Nucleic-Session: EBB24271-3AB2-4CBD-A47A-59FC73500371
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/PushRegistrar.swift         | 21 +++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/NucleicRemote/NucleicRemote/PushRegistrar.swift b/NucleicRemote/NucleicRemote/PushRegistrar.swift
index 0f0b7b5..1e9e16a 100644
--- a/NucleicRemote/NucleicRemote/PushRegistrar.swift
+++ b/NucleicRemote/NucleicRemote/PushRegistrar.swift
@@ -46,15 +46,28 @@ final class PushAppDelegate: NSObject, UIApplicationDelegate {
         // Best-effort: no token → the phone still works on LAN, just no remote wake.
     }
 
-    /// Silent pushes. The relay sends a content-free `clear` (content-available) to recall the
-    /// "waiting for your approval" tickle once the approval is resolved on another device — we
-    /// wake in the background just long enough to withdraw the stale notification. Other silent
-    /// pushes (e.g. the wake tickle itself, which is an alert) don't route here.
+    /// Silent pushes (content-available). Two kinds route here:
+    /// - `clear`: recall the "waiting for your approval" tickle once the approval is resolved on
+    ///   another device — wake briefly to withdraw the stale notification.
+    /// - `adopt`: a Mac push-started a Live Activity while the app was closed; come online long
+    ///   enough to harvest and register that activity's update token so live updates + a clean end
+    ///   resume without the user opening the app (UX_IOS §5.3). This one holds the completion handler
+    ///   until the token is registered (or the background window closes), so the process isn't
+    ///   suspended mid-connect.
+    /// Other pushes (e.g. the approval wake tickle, which is an alert) don't route here.
     func application(
         _ application: UIApplication,
         didReceiveRemoteNotification userInfo: [AnyHashable: Any],
         fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
     ) {
+        if userInfo["adopt"] != nil {
+            // The store manages its own background-task assertion for this; report .newData once it
+            // has brought the connection up and registered the token (or given up).
+            Task { @MainActor in
+                RemoteStore.shared.handleLiveActivityAdoptWake { completionHandler(.newData) }
+            }
+            return
+        }
         if userInfo["clear"] != nil {
             // Fire-and-forget on the main actor (NotificationRouter is @MainActor); the removal is a
             // quick UNUserNotificationCenter call, so we can report .noData right away.

From ef8aa79df4289d5c01d6cf75011697cdbba8ab56 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:37:03 -0700
Subject: [PATCH 51/65] Adjust Notification Content

Nucleic-Session: 4C62E994-D013-454A-B051-7D91EECFB69A
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Localizable.strings | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Localizable.strings b/NucleicRemote/NucleicRemote/Localizable.strings
index a690f5a..b9b26a0 100644
--- a/NucleicRemote/NucleicRemote/Localizable.strings
+++ b/NucleicRemote/NucleicRemote/Localizable.strings
@@ -3,3 +3,8 @@
    this localized alert is all the lock screen shows. The app pulls the real approval
    over the encrypted channel on open. */
 "approval.pending" = "A session is waiting for your approval";
+
+/* The same content-free wake, but the block is an agent question (`AskUserQuestion`) rather than
+   a tool approval — the host tags the wake `kind:"question"` so the lock screen reads accurately.
+   Still content-free: the real question is pulled over the encrypted channel on open. */
+"question.pending" = "A session is waiting for your answer";

From 4434bb09c1e58c82fbdaf275919a76a20de2cca2 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:41:56 -0700
Subject: [PATCH 52/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift    | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index f7fe423..3510394 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -1225,6 +1225,59 @@ final class RemoteStore: ObservableObject {
     func setSessionAutoShip(_ id: SessionID, _ autoShip: Bool) { send(.setSessionAutoShip(id, autoShip)) }
     func setSessionShipBranch(_ id: SessionID, _ branch: String?) { send(.setSessionShipBranch(id, branch)) }
 
+    // MARK: - App Intents support
+
+    /// Bring networking online and dial the paired host(s) for an App Intent that runs in a *cold*
+    /// background process (Siri / Shortcuts / a widget or Live Activity button), where the SwiftUI
+    /// scene never mounts and `onAppear` never fires. Mirrors the push handler's silent-launch
+    /// bootstrap (`startNetworkingIfNeeded` + `reconnect`). Idempotent; a no-op in demo mode.
+    func bootstrapForIntent() {
+        guard !demoMode else { return }
+        startNetworkingIfNeeded()
+        if isPaired { reconnect() }
+    }
+
+    /// Whether any paired Mac currently has a live channel.
+    var hasLiveConnection: Bool { connections.values.contains { $0.connectivity.isLive } }
+
+    /// Await a live connection to any paired Mac, up to `timeout` seconds — an intent must act over a
+    /// *live* channel or fail clean (UX_IOS §6, §3.1). Brings networking up first if it's cold, then
+    /// polls until a link comes up or the deadline passes. Returns whether a link is live.
+    func awaitLiveConnection(timeout: TimeInterval = 6) async -> Bool {
+        if demoMode || hasLiveConnection { return true }
+        bootstrapForIntent()
+        let deadline = Date().addingTimeInterval(timeout)
+        while Date() < deadline {
+            try? await Task.sleep(for: .milliseconds(200))
+            if hasLiveConnection { return true }
+        }
+        return hasLiveConnection
+    }
+
+    /// Resolve an approval by id from an App Intent with a full `Decision`. Like
+    /// `respondFromNotification`, it prefers the owning Mac, else broadcasts to every live Mac (the
+    /// owner resolves; the rest see an unknown / `alreadyResolved` id and no-op), and queues briefly
+    /// on a dropped link so a decision made just as the socket blips still lands. `sessionID` (when
+    /// the surface knows it) routes directly. Returns whether it went out over a live channel now.
+    @discardableResult
+    func respondToApproval(id: ApprovalID, sessionID: SessionID?, decision: Decision) -> Bool {
+        if demoMode { demoHandle(.approvalRespond(id, decision)); return true }
+        if let sessionID, let conn = connection(owningSession: sessionID), conn.connectivity.isLive {
+            conn.send(.approvalRespond(id, decision))
+            openApprovals.removeAll { $0.id == id }
+            return true
+        }
+        let live = connections.values.filter { $0.connectivity.isLive }
+        if !live.isEmpty {
+            for conn in live { conn.send(.approvalRespond(id, decision)) }
+            openApprovals.removeAll { $0.id == id }
+            return true
+        }
+        pendingNotificationDecision = (id, decision, Date())
+        reconnect()
+        return false
+    }
+
     // MARK: - Plumbing
 
     /// Route an intent to the Mac that owns its target (mesh P3). Sessions/projects/to-dos are shown

From 3fccb63b3fb448c1167510913aab9b9ededfd623 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:43:37 -0700
Subject: [PATCH 53/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Models/RemoteStore.swift | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index 3510394..e02ecd0 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -1234,7 +1234,12 @@ final class RemoteStore: ObservableObject {
     func bootstrapForIntent() {
         guard !demoMode else { return }
         startNetworkingIfNeeded()
-        if isPaired { reconnect() }
+        if isPaired {
+            // Show the persisted session list immediately so a cold intent query (Siri/Spotlight)
+            // has data to answer with before any host connects — same seed as `onAppear`.
+            if sessions.isEmpty { sessions = cachedSummaries }
+            reconnect()
+        }
     }
 
     /// Whether any paired Mac currently has a live channel.

From 4764f483ffaa96d390dd6b3830f0d02fd5a6cb53 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:44:03 -0700
Subject: [PATCH 54/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../AppIntents/SessionEntity.swift            | 80 +++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 NucleicRemote/NucleicRemote/AppIntents/SessionEntity.swift

diff --git a/NucleicRemote/NucleicRemote/AppIntents/SessionEntity.swift b/NucleicRemote/NucleicRemote/AppIntents/SessionEntity.swift
new file mode 100644
index 0000000..fff0b8e
--- /dev/null
+++ b/NucleicRemote/NucleicRemote/AppIntents/SessionEntity.swift
@@ -0,0 +1,80 @@
+import AppIntents
+import NucleicProtocol
+
+/// A Nucleic agent session exposed to Siri / Shortcuts / Spotlight (docs/APP_INTENTS_OPPORTUNITIES
+/// §4.6). Backed by the host's `SessionSummary` projection the phone already holds; the entity id
+/// is the wire `SessionID`, so it maps straight onto the deep-link and control APIs.
+///
+/// A thin, `Sendable` value snapshot — never the live store row. The `EntityQuery` re-reads
+/// `RemoteStore` each time so a stale Siri suggestion never acts on outdated state.
+struct SessionEntity: AppEntity, Identifiable {
+    static let typeDisplayRepresentation = TypeDisplayRepresentation(name: "Session")
+    static let defaultQuery = SessionEntityQuery()
+
+    /// `SessionID.rawValue`.
+    var id: String
+    var title: String
+    var projectName: String
+    var statusLabel: String
+    /// Whether this session is waiting on the user (approval, or a non-completed input turn).
+    var needsAttention: Bool
+
+    var displayRepresentation: DisplayRepresentation {
+        DisplayRepresentation(
+            title: "\(title)",
+            subtitle: "\(projectName) · \(statusLabel)")
+    }
+}
+
+extension SessionEntity {
+    /// Project a wire summary into the entity (falling back to the project name for an untitled
+    /// session, exactly as the session list does).
+    init(_ s: WireSessionSummary) {
+        self.init(
+            id: s.sessionID.rawValue,
+            title: s.title.isEmpty ? s.projectName : s.title,
+            projectName: s.projectName,
+            statusLabel: StatusStyle.label(s.status, disposition: s.disposition),
+            needsAttention: s.status.needsYou(s.disposition))
+    }
+}
+
+/// Resolves `SessionEntity` values for Shortcuts/Siri from the phone's current (or cached) session
+/// list. Discovery paths (`suggestedEntities`, string matching) bootstrap the channel first so a
+/// cold intent process still has data; id resolution stays fast and offline-tolerant.
+struct SessionEntityQuery: EntityQuery {
+    @MainActor
+    func entities(for identifiers: [SessionEntity.ID]) async throws -> [SessionEntity] {
+        let wanted = Set(identifiers)
+        return RemoteStore.shared.liveSessions
+            .filter { wanted.contains($0.sessionID.rawValue) }
+            .map(SessionEntity.init)
+    }
+
+    @MainActor
+    func suggestedEntities() async throws -> [SessionEntity] {
+        let store = RemoteStore.shared
+        store.bootstrapForIntent()
+        return store.liveSessions
+            .sorted(by: StatusStyle.attentionThenRecency)
+            .prefix(12)
+            .map(SessionEntity.init)
+    }
+}
+
+/// Lets Siri match a session by spoken name ("open payment-flow") against title or project.
+extension SessionEntityQuery: EntityStringQuery {
+    @MainActor
+    func entities(matching string: String) async throws -> [SessionEntity] {
+        let store = RemoteStore.shared
+        store.bootstrapForIntent()
+        let needle = string.lowercased()
+        return store.liveSessions
+            .filter {
+                let title = ($0.title.isEmpty ? $0.projectName : $0.title).lowercased()
+                return title.contains(needle) || $0.projectName.lowercased().contains(needle)
+            }
+            .sorted(by: StatusStyle.attentionThenRecency)
+            .map(SessionEntity.init)
+    }
+}

From 8218d6042efbe501b527aee806e5802594c34beb Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:44:18 -0700
Subject: [PATCH 55/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../AppIntents/IntentError.swift              | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 NucleicRemote/NucleicRemote/AppIntents/IntentError.swift

diff --git a/NucleicRemote/NucleicRemote/AppIntents/IntentError.swift b/NucleicRemote/NucleicRemote/AppIntents/IntentError.swift
new file mode 100644
index 0000000..fb71770
--- /dev/null
+++ b/NucleicRemote/NucleicRemote/AppIntents/IntentError.swift
@@ -0,0 +1,24 @@
+import AppIntents
+
+/// Friendly, spoken-safe failures for Nucleic's App Intents. The phone is a thin client with no
+/// local authority (docs/APP_INTENTS_OPPORTUNITIES §3.1): an intent that can't reach the paired
+/// Mac must fail *clean* with a dialog, never silently or with a raw error.
+enum IntentError: Error, CustomLocalizedStringResourceConvertible {
+    /// No live channel to any paired Mac (and none came up within the wait window).
+    case macUnreachable
+    /// Not paired with a Mac yet — nothing to act on.
+    case notPaired
+    /// The action needs `control` scope, which this device hasn't been granted.
+    case controlScopeRequired
+
+    var localizedStringResource: LocalizedStringResource {
+        switch self {
+        case .macUnreachable:
+            "Your Mac isn't reachable right now. Try again when it's online."
+        case .notPaired:
+            "Pair this iPhone with your Mac in Nucleic first."
+        case .controlScopeRequired:
+            "This device can view and approve, but isn't allowed to control sessions."
+        }
+    }
+}

From 8f0e72167415a30444dba2f8fe073fcd34d73284 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:44:37 -0700
Subject: [PATCH 56/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../AppIntents/SessionIntents.swift           | 101 ++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 NucleicRemote/NucleicRemote/AppIntents/SessionIntents.swift

diff --git a/NucleicRemote/NucleicRemote/AppIntents/SessionIntents.swift b/NucleicRemote/NucleicRemote/AppIntents/SessionIntents.swift
new file mode 100644
index 0000000..8e0f0d9
--- /dev/null
+++ b/NucleicRemote/NucleicRemote/AppIntents/SessionIntents.swift
@@ -0,0 +1,101 @@
+import AppIntents
+import NucleicProtocol
+
+// MARK: - Open a session (deep-link intent, §4.4)
+
+/// Open a specific session in the app. Reuses the existing `nucleic://session/<id>` route via
+/// `RemoteStore.route(to:)` — so a Spotlight result, a Siri phrase, or a Shortcut jumps straight
+/// into the waiting session. `openAppWhenRun` foregrounds the app (this is a navigation action).
+struct OpenSessionIntent: AppIntent {
+    static let title: LocalizedStringResource = "Open Session"
+    static let description = IntentDescription("Open a Nucleic agent session.")
+    static let openAppWhenRun = true
+
+    @Parameter(title: "Session")
+    var session: SessionEntity
+
+    init() {}
+    init(session: SessionEntity) { self.session = session }
+
+    @MainActor
+    func perform() async throws -> some IntentResult {
+        RemoteStore.shared.route(to: SessionID(rawValue: session.id))
+        return .result()
+    }
+
+    static var parameterSummary: some ParameterSummary {
+        Summary("Open \(\.$session)")
+    }
+}
+
+// MARK: - Unblock with a follow-up (§4.2, approve-scope)
+
+/// Send a follow-up prompt to a paused agent — the "type the next step to unblock it" flow that
+/// stays at `approve` scope (docs/UX_IOS §2). Runs in the background over the app's live channel
+/// (no foregrounding); if the Mac isn't reachable it fails clean with a spoken error (§3.1).
+struct SendFollowUpIntent: AppIntent {
+    static let title: LocalizedStringResource = "Send Follow-Up"
+    static let description = IntentDescription(
+        "Send a follow-up prompt to a Nucleic agent to unblock or steer it.")
+
+    @Parameter(title: "Session")
+    var session: SessionEntity
+
+    @Parameter(title: "Message", requestValueDialog: "What should the agent do next?")
+    var text: String
+
+    init() {}
+    init(session: SessionEntity, text: String) {
+        self.session = session
+        self.text = text
+    }
+
+    @MainActor
+    func perform() async throws -> some IntentResult & ProvidesDialog {
+        let store = RemoteStore.shared
+        guard store.isPaired else { throw IntentError.notPaired }
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return .result(dialog: "That message was empty.") }
+        guard await store.awaitLiveConnection() else { throw IntentError.macUnreachable }
+        store.sendInput(trimmed, to: SessionID(rawValue: session.id))
+        return .result(dialog: "Sent to \(session.title).")
+    }
+
+    static var parameterSummary: some ParameterSummary {
+        Summary("Tell \(\.$session) to \(\.$text)")
+    }
+}
+
+// MARK: - "What needs me?" (§4.3)
+
+/// List the agents waiting on the user — for approval, or a next prompt — using the same attention
+/// rule as the badge and NEEDS YOU section (`SessionStatus.needsYou`). Answers Siri's "what needs me
+/// in Nucleic?" and feeds Shortcuts automations. Runs in the background; returns the list plus a
+/// spoken summary.
+struct SessionsNeedingMeIntent: AppIntent {
+    static let title: LocalizedStringResource = "Sessions Needing Me"
+    static let description = IntentDescription(
+        "List the Nucleic agents waiting on you — for approval or your next prompt.")
+
+    @MainActor
+    func perform() async throws -> some IntentResult & ReturnsValue<[SessionEntity]> & ProvidesDialog {
+        let store = RemoteStore.shared
+        guard store.isPaired else { throw IntentError.notPaired }
+        store.bootstrapForIntent()
+        // Give a cold process a brief moment to bring a channel up so the answer is current; fall
+        // back to the persisted list if the Mac stays unreachable.
+        _ = await store.awaitLiveConnection(timeout: 4)
+        let needy = store.liveSessions
+            .filter { $0.status.needsYou($0.disposition) }
+            .sorted(by: StatusStyle.attentionThenRecency)
+            .map(SessionEntity.init)
+
+        let dialog: IntentDialog
+        switch needy.count {
+        case 0: dialog = "Nothing needs you right now."
+        case 1: dialog = "One agent needs you: \(needy[0].title)."
+        default: dialog = "\(needy.count) agents need you."
+        }
+        return .result(value: needy, dialog: dialog)
+    }
+}

From 67693a1be9b4a1d6f72642f7e299100fa1cc49e1 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:45:29 -0700
Subject: [PATCH 57/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/AppIntents/IntentError.swift | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/AppIntents/IntentError.swift b/NucleicRemote/NucleicRemote/AppIntents/IntentError.swift
index fb71770..9a73fd3 100644
--- a/NucleicRemote/NucleicRemote/AppIntents/IntentError.swift
+++ b/NucleicRemote/NucleicRemote/AppIntents/IntentError.swift
@@ -10,6 +10,9 @@ enum IntentError: Error, CustomLocalizedStringResourceConvertible {
     case notPaired
     /// The action needs `control` scope, which this device hasn't been granted.
     case controlScopeRequired
+    /// A high-risk approval (destructive/network/host-exec) can't be allowed inline — it must be
+    /// confirmed on the app's guarded card (docs/APP_INTENTS_OPPORTUNITIES §3.3).
+    case needsAppConfirmation
 
     var localizedStringResource: LocalizedStringResource {
         switch self {
@@ -19,6 +22,8 @@ enum IntentError: Error, CustomLocalizedStringResourceConvertible {
             "Pair this iPhone with your Mac in Nucleic first."
         case .controlScopeRequired:
             "This device can view and approve, but isn't allowed to control sessions."
+        case .needsAppConfirmation:
+            "This one's high-risk — open Nucleic to confirm it on the approval card."
         }
     }
 }

From 16f704cc2ce2ee99b2420ae0eaf5a065b6db51de Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:45:56 -0700
Subject: [PATCH 58/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../AppIntents/ApprovalIntents.swift          | 138 ++++++++++++++++++
 1 file changed, 138 insertions(+)
 create mode 100644 NucleicRemote/NucleicRemote/AppIntents/ApprovalIntents.swift

diff --git a/NucleicRemote/NucleicRemote/AppIntents/ApprovalIntents.swift b/NucleicRemote/NucleicRemote/AppIntents/ApprovalIntents.swift
new file mode 100644
index 0000000..e1beebf
--- /dev/null
+++ b/NucleicRemote/NucleicRemote/AppIntents/ApprovalIntents.swift
@@ -0,0 +1,138 @@
+import AppIntents
+import NucleicProtocol
+
+// MARK: - Decision option (§6 enums)
+
+/// The decision an approval intent can carry, mapped from the wire `Decision` (`Approval.swift`).
+/// The `allowAlways` cases are the safe subset (session / this-tool); pattern scopes and any allow
+/// on a destructive request are handled by the risk gate, not offered here.
+enum ApprovalDecisionOption: String, AppEnum {
+    case allow
+    case deny
+    case allowAlwaysSession
+    case allowAlwaysTool
+
+    static let typeDisplayRepresentation = TypeDisplayRepresentation(name: "Decision")
+    static let caseDisplayRepresentations: [ApprovalDecisionOption: DisplayRepresentation] = [
+        .allow: "Allow",
+        .deny: "Deny",
+        .allowAlwaysSession: "Always Allow (this session)",
+        .allowAlwaysTool: "Always Allow (this tool)",
+    ]
+
+    /// Whether this decision grants the request (everything but `deny`) — the half the risk gate
+    /// forbids inline on a high-risk approval.
+    var isAllow: Bool { self != .deny }
+
+    /// The wire `Decision` this option resolves to.
+    func decision() -> Decision {
+        switch self {
+        case .allow: .allow(updatedInput: nil)
+        case .deny: .deny(reason: nil)
+        case .allowAlwaysSession: .allowAlways(.session)
+        case .allowAlwaysTool: .allowAlways(.toolName)
+        }
+    }
+}
+
+// MARK: - Approval entity (§4.6)
+
+/// A pending approval exposed to Shortcuts/Siri. Backed by `RemoteStore.openApprovals`, which the
+/// phone holds in full (id, risk, title) only for the *subscribed* session — so today this surfaces
+/// the approvals of the session you're looking at. (A global pending-approvals feed would need the
+/// host to carry the top approval's id/risk on the wire summary; see §4.1 / the Live Activity note.)
+struct ApprovalEntity: AppEntity, Identifiable {
+    static let typeDisplayRepresentation = TypeDisplayRepresentation(name: "Approval")
+    static let defaultQuery = ApprovalEntityQuery()
+
+    /// `ApprovalID.rawValue`.
+    var id: String
+    /// `SessionID.rawValue` of the owning session — routes the decision to the right Mac.
+    var sessionID: String
+    var toolName: String
+    var requestTitle: String
+    /// `Risk.rawValue`, kept for display; the gate uses `isHighRisk`.
+    var riskLabel: String
+    /// Destructive / network / host-exec — never allowed inline (§3.3).
+    var isHighRisk: Bool
+
+    var displayRepresentation: DisplayRepresentation {
+        DisplayRepresentation(
+            title: "\(toolName): \(requestTitle)",
+            subtitle: "\(riskLabel)")
+    }
+}
+
+extension ApprovalEntity {
+    init(_ r: ApprovalRequest) {
+        self.init(
+            id: r.id.rawValue,
+            sessionID: r.sessionID.rawValue,
+            toolName: r.toolName,
+            requestTitle: r.title,
+            riskLabel: r.risk.label,
+            isHighRisk: r.risk.isHigh)
+    }
+}
+
+struct ApprovalEntityQuery: EntityQuery {
+    @MainActor
+    func entities(for identifiers: [ApprovalEntity.ID]) async throws -> [ApprovalEntity] {
+        let wanted = Set(identifiers)
+        return RemoteStore.shared.openApprovals
+            .filter { wanted.contains($0.id.rawValue) }
+            .map(ApprovalEntity.init)
+    }
+
+    @MainActor
+    func suggestedEntities() async throws -> [ApprovalEntity] {
+        RemoteStore.shared.openApprovals.map(ApprovalEntity.init)
+    }
+}
+
+// MARK: - Answer an approval (§4.1, the flagship)
+
+/// Allow or deny what an agent is asking to do. The risk gate (§3.3) is enforced here so an intent
+/// can never be a softer approval path than the UI: a high-risk request (destructive / network /
+/// host-exec) is never granted inline — it routes to the app's guarded card. Deny always goes
+/// straight through. "Already resolved elsewhere" is a friendly no-op (§3.4), not an error, because
+/// the host de-dupes a lost first-responder race.
+struct AnswerApprovalIntent: AppIntent {
+    static let title: LocalizedStringResource = "Answer Approval"
+    static let description = IntentDescription(
+        "Allow or deny what a Nucleic agent is asking to do.")
+
+    @Parameter(title: "Approval")
+    var approval: ApprovalEntity
+
+    @Parameter(title: "Decision", default: .allow)
+    var decision: ApprovalDecisionOption
+
+    init() {}
+    init(approval: ApprovalEntity, decision: ApprovalDecisionOption) {
+        self.approval = approval
+        self.decision = decision
+    }
+
+    @MainActor
+    func perform() async throws -> some IntentResult & ProvidesDialog {
+        let store = RemoteStore.shared
+        guard store.isPaired else { throw IntentError.notPaired }
+        let approvalID = ApprovalID(rawValue: approval.id)
+        let sessionID = SessionID(rawValue: approval.sessionID)
+
+        // §3.3 — high-risk can't be granted inline; route to the app's biometric-gated card.
+        if approval.isHighRisk, decision.isAllow {
+            store.route(to: sessionID)
+            throw IntentError.needsAppConfirmation
+        }
+
+        guard await store.awaitLiveConnection() else { throw IntentError.macUnreachable }
+        store.respondToApproval(id: approvalID, sessionID: sessionID, decision: decision.decision())
+        return .result(dialog: decision.isAllow ? "Allowed." : "Denied.")
+    }
+
+    static var parameterSummary: some ParameterSummary {
+        Summary("\(\.$decision) \(\.$approval)")
+    }
+}

From 0740495552cd62d335061a2cdd782759dbda1256 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:46:14 -0700
Subject: [PATCH 59/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../AppIntents/NucleicShortcuts.swift         | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 NucleicRemote/NucleicRemote/AppIntents/NucleicShortcuts.swift

diff --git a/NucleicRemote/NucleicRemote/AppIntents/NucleicShortcuts.swift b/NucleicRemote/NucleicRemote/AppIntents/NucleicShortcuts.swift
new file mode 100644
index 0000000..6e16131
--- /dev/null
+++ b/NucleicRemote/NucleicRemote/AppIntents/NucleicShortcuts.swift
@@ -0,0 +1,45 @@
+import AppIntents
+
+/// Curates the handful of genuinely voice-worthy actions for Siri / Spotlight (§8: keep the spoken
+/// set to ~4 — approve, unblock, open, "what needs me" — and expose the long tail through Shortcuts
+/// only). Every phrase must name the app; `\(.applicationName)` resolves to "Nucleic".
+struct NucleicShortcuts: AppShortcutsProvider {
+    static var appShortcuts: [AppShortcut] {
+        AppShortcut(
+            intent: SessionsNeedingMeIntent(),
+            phrases: [
+                "What needs me in \(.applicationName)",
+                "What's waiting in \(.applicationName)",
+                "Which agents need me in \(.applicationName)",
+            ],
+            shortTitle: "What Needs Me",
+            systemImageName: "bell.badge")
+
+        AppShortcut(
+            intent: AnswerApprovalIntent(),
+            phrases: [
+                "Approve in \(.applicationName)",
+                "Answer an approval in \(.applicationName)",
+            ],
+            shortTitle: "Answer Approval",
+            systemImageName: "checkmark.shield")
+
+        AppShortcut(
+            intent: SendFollowUpIntent(),
+            phrases: [
+                "Send a follow-up in \(.applicationName)",
+                "Tell an agent in \(.applicationName)",
+            ],
+            shortTitle: "Send Follow-Up",
+            systemImageName: "arrowshape.turn.up.right")
+
+        AppShortcut(
+            intent: OpenSessionIntent(),
+            phrases: [
+                "Open a session in \(.applicationName)",
+                "Open \(.applicationName)",
+            ],
+            shortTitle: "Open Session",
+            systemImageName: "bubble.left.and.text.bubble.right")
+    }
+}

From f73b1de5bc729dd88f53b22260849e440609183d Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:48:38 -0700
Subject: [PATCH 60/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../Shared/SessionActivityAttributes.swift    | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/NucleicRemote/Shared/SessionActivityAttributes.swift b/NucleicRemote/Shared/SessionActivityAttributes.swift
index 9809710..b352ef9 100644
--- a/NucleicRemote/Shared/SessionActivityAttributes.swift
+++ b/NucleicRemote/Shared/SessionActivityAttributes.swift
@@ -48,6 +48,30 @@ struct NucleicSessionAttributes: ActivityAttributes {
         /// A compact right-aligned status: its diff ("3 files +42 −7"), "2 to approve",
         /// "Waiting on you", "Working…", etc.
         var detail: String
+        /// The single most-urgent pending approval on this session, when it has one — the id the
+        /// inline Allow/Deny buttons resolve (`ApproveFromActivityIntent`). `nil` when the session
+        /// isn't blocked on an approval, or when the producer doesn't carry it (an older host, or a
+        /// summary that predates the field) — in which case the row falls back to a plain deep-link
+        /// tap, exactly as before. Optional so a host that omits it still decodes.
+        var approvalID: String?
+        /// Whether that approval is high-risk (destructive / network / host-exec). The surface hides
+        /// inline Allow on a high-risk request (§3.3) — only Deny / open-the-app is offered. `nil`
+        /// (treated as unknown → no inline Allow) when the producer doesn't carry it.
+        var approvalIsHighRisk: Bool?
+
+        init(
+            id: String, title: String, project: String, backend: Backend, kind: Kind,
+            detail: String, approvalID: String? = nil, approvalIsHighRisk: Bool? = nil
+        ) {
+            self.id = id
+            self.title = title
+            self.project = project
+            self.backend = backend
+            self.kind = kind
+            self.detail = detail
+            self.approvalID = approvalID
+            self.approvalIsHighRisk = approvalIsHighRisk
+        }
     }
 
     struct ContentState: Codable, Hashable {

From 853bb27486ab1c17002048d49280f4be34add35d Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:48:58 -0700
Subject: [PATCH 61/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../Shared/ApproveFromActivityIntent.swift    | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 NucleicRemote/Shared/ApproveFromActivityIntent.swift

diff --git a/NucleicRemote/Shared/ApproveFromActivityIntent.swift b/NucleicRemote/Shared/ApproveFromActivityIntent.swift
new file mode 100644
index 0000000..51cad25
--- /dev/null
+++ b/NucleicRemote/Shared/ApproveFromActivityIntent.swift
@@ -0,0 +1,65 @@
+import AppIntents
+#if canImport(NucleicProtocol)
+import NucleicProtocol
+#endif
+
+/// The interactive approve / deny an aggregate Live Activity (or widget) button fires — the flagship
+/// "resolve from the lock screen without unlocking" path (docs/APP_INTENTS_OPPORTUNITIES §4.1).
+///
+/// It lives in the **Shared** group so both the app and the widget extension can reference it in
+/// `Button(intent:)`. The widget extension links no `NucleicProtocol`, so this intent carries plain
+/// `String` ids and compiles its real work only into the app (`#if canImport(NucleicProtocol)`).
+/// That's sound because iOS runs a widget/Live-Activity button's intent in the **app's background
+/// process** — where `RemoteStore` owns the live E2EE channel — never in the extension. The
+/// extension-side copy exists solely to satisfy the `Button(intent:)` type reference.
+///
+/// Not discoverable in Shortcuts/Spotlight: it's button-only, driven by ids embedded at render time
+/// (a human uses `AnswerApprovalIntent` for the spoken/Shortcuts path).
+struct ApproveFromActivityIntent: AppIntent {
+    static let title: LocalizedStringResource = "Approve from Live Activity"
+    static let isDiscoverable = false
+
+    @Parameter(title: "Approval ID")
+    var approvalID: String
+    @Parameter(title: "Session ID")
+    var sessionID: String
+    @Parameter(title: "High Risk")
+    var isHighRisk: Bool
+    /// `true` = allow, `false` = deny.
+    @Parameter(title: "Allow")
+    var allow: Bool
+
+    init() {}
+    init(approvalID: String, sessionID: String, isHighRisk: Bool, allow: Bool) {
+        self.approvalID = approvalID
+        self.sessionID = sessionID
+        self.isHighRisk = isHighRisk
+        self.allow = allow
+    }
+
+    @MainActor
+    func perform() async throws -> some IntentResult {
+        #if canImport(NucleicProtocol)
+        let store = RemoteStore.shared
+        // §3.3 — a high-risk allow is never resolved inline; route to the app's biometric-gated card.
+        // (Surfaces shouldn't render an inline Allow for high-risk in the first place; this is the
+        // backstop so the intent can never be a softer path than the UI.)
+        if isHighRisk, allow {
+            store.route(to: SessionID(rawValue: sessionID))
+            throw IntentError.needsAppConfirmation
+        }
+        // Best-effort bring-up; `respondToApproval` queues briefly on a dropped link (§3.1). A lost
+        // first-responder race is de-duped host-side (§3.4), so we never surface an error for it.
+        _ = await store.awaitLiveConnection()
+        let decision: Decision = allow ? .allow(updatedInput: nil) : .deny(reason: nil)
+        store.respondToApproval(
+            id: ApprovalID(rawValue: approvalID),
+            sessionID: SessionID(rawValue: sessionID),
+            decision: decision)
+        return .result()
+        #else
+        // Widget-extension build: never executed (the system performs this in the app process).
+        return .result()
+        #endif
+    }
+}

From d37263145bfcc04c22f018da7957923040990cb6 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:49:42 -0700
Subject: [PATCH 62/65] Read App Intents Documentation

Nucleic-Session: 56C5F781-4444-466B-91CE-A7734A8E117F
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../SessionLiveActivity.swift                 | 64 ++++++++++++++++++-
 1 file changed, 62 insertions(+), 2 deletions(-)

diff --git a/NucleicRemote/NucleicRemoteWidgets/SessionLiveActivity.swift b/NucleicRemote/NucleicRemoteWidgets/SessionLiveActivity.swift
index 5e2f336..38632c7 100644
--- a/NucleicRemote/NucleicRemoteWidgets/SessionLiveActivity.swift
+++ b/NucleicRemote/NucleicRemoteWidgets/SessionLiveActivity.swift
@@ -131,15 +131,42 @@ private struct LockScreenView: View {
 private struct SessionRow: View {
     let line: NucleicSessionAttributes.SessionLine
 
+    /// An approval this row can resolve inline: it's blocked on an approval, carries that approval's
+    /// id, and isn't high-risk (§3.3 — high-risk keeps the plain tap-to-open row and is answered on
+    /// the app's guarded card). `nil` until the producer populates `approvalID` — an older host, or
+    /// today's summary that doesn't yet carry it, so the row stays a deep-link exactly as before.
+    private var inlineApprovalID: String? {
+        guard line.kind == .approval, (line.approvalIsHighRisk ?? false) == false else { return nil }
+        return line.approvalID
+    }
+
     var body: some View {
-        if let url = NucleicDeepLink.session(line.id) {
+        if let approvalID = inlineApprovalID {
+            actionableRow(approvalID: approvalID)
+        } else if let url = NucleicDeepLink.session(line.id) {
             Link(destination: url) { rowContent }
         } else {
             rowContent
         }
     }
 
-    private var rowContent: some View {
+    /// An approval row with inline Allow/Deny. The identity still deep-links to the session; the
+    /// buttons fire `ApproveFromActivityIntent`, which the system performs in the app's background
+    /// process — allow/deny without unlocking (§4.1).
+    private func actionableRow(approvalID: String) -> some View {
+        HStack(spacing: 8) {
+            if let url = NucleicDeepLink.session(line.id) {
+                Link(destination: url) { rowIdentity }
+            } else {
+                rowIdentity
+            }
+            Spacer(minLength: 6)
+            ApprovalButtons(sessionID: line.id, approvalID: approvalID)
+        }
+    }
+
+    /// The glyph + title + "project · Backend" — the row's identity, minus the trailing status.
+    private var rowIdentity: some View {
         HStack(spacing: 8) {
             Image(systemName: ActivityPalette.glyph(line.kind))
                 .font(.footnote)
@@ -159,6 +186,12 @@ private struct SessionRow: View {
                 .foregroundStyle(.secondary)
                 .lineLimit(1)
             }
+        }
+    }
+
+    private var rowContent: some View {
+        HStack(spacing: 8) {
+            rowIdentity
             Spacer(minLength: 6)
             Text(line.detail)
                 .font(.caption2.weight(.medium))
@@ -169,6 +202,33 @@ private struct SessionRow: View {
     }
 }
 
+/// The compact inline Allow/Deny pair for an actionable approval row. Each button fires
+/// `ApproveFromActivityIntent` (a low/medium-risk decision — high-risk never reaches here).
+private struct ApprovalButtons: View {
+    let sessionID: String
+    let approvalID: String
+
+    var body: some View {
+        HStack(spacing: 6) {
+            Button(intent: intent(allow: false)) {
+                Image(systemName: "xmark").font(.caption2.bold())
+            }
+            .tint(ActivityPalette.danger)
+            Button(intent: intent(allow: true)) {
+                Image(systemName: "checkmark").font(.caption2.bold())
+            }
+            .tint(ActivityPalette.success)
+        }
+        .buttonStyle(.borderedProminent)
+        .controlSize(.small)
+    }
+
+    private func intent(allow: Bool) -> ApproveFromActivityIntent {
+        ApproveFromActivityIntent(
+            approvalID: approvalID, sessionID: sessionID, isHighRisk: false, allow: allow)
+    }
+}
+
 /// Headline count chips: running (blue), waiting (teal), approvals (amber). Only nonzero show.
 private struct CountChips: View {
     let state: NucleicSessionAttributes.ContentState

From 87ec40fd580189f69850443c0ac893aa03d82e03 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 14:53:37 -0700
Subject: [PATCH 63/65] Adjust Push Notification Logic

Nucleic-Session: 0F065CD6-20FE-4941-ACF5-C57A4572A5A3
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 NucleicRemote/NucleicRemote/Notifications.swift | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/NucleicRemote/NucleicRemote/Notifications.swift b/NucleicRemote/NucleicRemote/Notifications.swift
index fb2d0dc..b2c601f 100644
--- a/NucleicRemote/NucleicRemote/Notifications.swift
+++ b/NucleicRemote/NucleicRemote/Notifications.swift
@@ -108,21 +108,15 @@ final class NotificationRouter: NSObject {
         center.removePendingNotificationRequests(withIdentifiers: [identifier])
     }
 
-    /// Recall the shared "waiting for your approval" attention notification once nothing is pending
-    /// anywhere. This is the remote wake tickle (delivered under `approvalTickleIdentifier`) that a
-    /// prior push left on the lock screen — the counterpart to the per-approval `withdrawApproval`.
-    /// Arrives two ways: the relay's silent `clear` push (phone was away), or the store's own
-    /// reconcile when a live socket sees the last approval resolve. Also sweeps any per-approval
-    /// locals a live socket posted but hasn't individually withdrawn, so the lock screen ends clean.
+    /// Recall the generic remote wake tickle ("A session is waiting for your approval") once no
+    /// approval is pending anywhere. This targets *only* the shared tickle (delivered under
+    /// `approvalTickleIdentifier`, its APNs collapse-id) — the content-free push a phone gets while
+    /// away. Per-approval notifications are each recalled by `withdrawApproval(_:)` as they resolve,
+    /// so a still-pending approval's own banner is never swept away by this.
     func withdrawApprovalAttention() {
         let center = UNUserNotificationCenter.current()
         center.removeDeliveredNotifications(withIdentifiers: [Self.approvalTickleIdentifier])
         center.removePendingNotificationRequests(withIdentifiers: [Self.approvalTickleIdentifier])
-        center.getDeliveredNotifications { delivered in
-            let stale = delivered.map(\.request.identifier).filter { $0.hasPrefix("approval-") }
-            guard !stale.isEmpty else { return }
-            UNUserNotificationCenter.current().removeDeliveredNotifications(withIdentifiers: stale)
-        }
     }
 
     /// Keep the app-icon badge equal to the NEEDS YOU count (UX_IOS §8).

From e8ac67093a25b8246270bf4ff3e4a9f6569662c9 Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 15:02:02 -0700
Subject: [PATCH 64/65] Investigate Live Activity Session Load

Nucleic-Session: 044A9B93-AB31-4B6B-9A27-3631261269B1
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift     | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index e02ecd0..d257c53 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -550,6 +550,24 @@ final class RemoteStore: ObservableObject {
         dashboard = DashboardSnapshot.merged([host1Dashboard, host2Dashboard])
         LiveActivityManager.shared.sync(hostName: hostName, sessions: liveSessions)
         NotificationRouter.shared.updateBadge(needsYouCount)
+        // TEMP DIAGNOSTIC: simulate a Live Activity cold-launch, where the detail opens while the
+        // channel is still offline and the connection lands a moment later (disconnected→live under
+        // an open detail). Gated on an env var so normal demo is untouched.
+        if ProcessInfo.processInfo.environment["NUCLEIC_DEMO_DELAY_CONNECT"] == "1" {
+            connectivity = .reconnecting
+            Task { @MainActor [weak self] in
+                try? await Task.sleep(for: .seconds(2))
+                guard let self else { return }
+                self.connectivity = .connected(.lan)
+                // The snapshot arriving for the open session (approval + a fresh event).
+                if let id = self.openSessionID {
+                    self.openApprovals = [ApprovalRequest(
+                        id: Self.demoApprovalID(for: id), sessionID: id, toolCallID: "t-appr",
+                        toolName: "Bash", input: ["command": "npm run deploy"],
+                        title: "Run npm run deploy", risk: .execute, createdAt: Date())]
+                }
+            }
+        }
     }
 
     /// Offline diff fixture (NUCLEIC_DEMO) so the full-patch Diff tab renders without a host.

From 39f2f9a279e275d6c10c697f743749ba76a280ef Mon Sep 17 00:00:00 2001
From: Andrew Blakeslee Moore <andrew@blakeslee.me>
Date: Mon, 6 Jul 2026 15:07:39 -0700
Subject: [PATCH 65/65] Investigate Live Activity Session Load

Nucleic-Session: 044A9B93-AB31-4B6B-9A27-3631261269B1
Co-authored-by: Nucleic <nucleic@blakeslee.xyz>
---
 .../NucleicRemote/Models/RemoteStore.swift     | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
index d257c53..e02ecd0 100644
--- a/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
+++ b/NucleicRemote/NucleicRemote/Models/RemoteStore.swift
@@ -550,24 +550,6 @@ final class RemoteStore: ObservableObject {
         dashboard = DashboardSnapshot.merged([host1Dashboard, host2Dashboard])
         LiveActivityManager.shared.sync(hostName: hostName, sessions: liveSessions)
         NotificationRouter.shared.updateBadge(needsYouCount)
-        // TEMP DIAGNOSTIC: simulate a Live Activity cold-launch, where the detail opens while the
-        // channel is still offline and the connection lands a moment later (disconnected→live under
-        // an open detail). Gated on an env var so normal demo is untouched.
-        if ProcessInfo.processInfo.environment["NUCLEIC_DEMO_DELAY_CONNECT"] == "1" {
-            connectivity = .reconnecting
-            Task { @MainActor [weak self] in
-                try? await Task.sleep(for: .seconds(2))
-                guard let self else { return }
-                self.connectivity = .connected(.lan)
-                // The snapshot arriving for the open session (approval + a fresh event).
-                if let id = self.openSessionID {
-                    self.openApprovals = [ApprovalRequest(
-                        id: Self.demoApprovalID(for: id), sessionID: id, toolCallID: "t-appr",
-                        toolName: "Bash", input: ["command": "npm run deploy"],
-                        title: "Run npm run deploy", risk: .execute, createdAt: Date())]
-                }
-            }
-        }
     }
 
     /// Offline diff fixture (NUCLEIC_DEMO) so the full-patch Diff tab renders without a host.