Skip to content

CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息

fix: 将任务等待通知扩展到阻塞式提问

Bobe44bed62e033
diff --git a/CodexBar/Models/ActivityModels.swift b/CodexBar/Models/ActivityModels.swift
index 73d8dd0..11f45f4 100644
--- a/CodexBar/Models/ActivityModels.swift
+++ b/CodexBar/Models/ActivityModels.swift
@@ -102,18 +102,16 @@ nonisolated struct ActivitySnapshot: Equatable {
runningTasks.filter { $0.presentation?.waiting == nil }
}
- /// 防睡眠将明确阻塞的提问归入等待, 不改变任务的审批和保护状态
+ /// 通知和防睡眠共用阻塞等待, 不改变面板展示或任务的审批和保护状态
+ var blockingWaitingTaskIDs: Set<UUID> {
+ Set(waitingTasks.map(\.id)).union(
+ runningTasks.lazy.filter { $0.presentation?.hasBlockingInputRequest == true }.map(\.id)
+ )
+ }
+
var keepAliveTaskIDs: (running: Set<UUID>, waiting: Set<UUID>) {
- var running = Set<UUID>()
- var waiting = Set(waitingTasks.map(\.id))
- for task in runningTasks {
- if task.presentation?.hasBlockingInputRequest == true {
- waiting.insert(task.id)
- } else {
- running.insert(task.id)
- }
- }
- return (running, waiting)
+ let waiting = blockingWaitingTaskIDs
+ return (Set(runningTasks.map(\.id)).subtracting(waiting), waiting)
}
var panelPrimaryActivity: CodexPrimaryActivity {
@@ -217,9 +215,9 @@ nonisolated enum CodexPrimaryActivity: Equatable {
case idle
}
-/// 只有 live 事件 或 turn 生命周期会发布 transition, bootstrap 永远不会触发历史通知
+/// 等待携带实际起点, monitor 在初始化和恢复期间屏蔽通知
nonisolated enum ActivityTransition: Equatable {
- case waitingApproval(ActivityTaskSnapshot)
+ case waiting(ActivityTaskSnapshot, since: Date)
case completed(ActivityCompletion)
}
diff --git a/CodexBar/Services/Activity/ActivityLivePresentation.swift b/CodexBar/Services/Activity/ActivityLivePresentation.swift
index 1d49aca..0d6676e 100644
--- a/CodexBar/Services/Activity/ActivityLivePresentation.swift
+++ b/CodexBar/Services/Activity/ActivityLivePresentation.swift
@@ -29,9 +29,13 @@ nonisolated struct ActivityLiveSummary: Equatable {
var toolCount: Int?
var planCompleted: Int?
var planTotal: Int?
- var hasBlockingInputRequest = false
+ var blockingInputSince: Date?
var isReviewing = false
var updatedAt: Date = .distantPast
+
+ var hasBlockingInputRequest: Bool {
+ blockingInputSince != nil
+ }
}
/// 与历史统计和审批策略独立的内存状态, 连接失效时整体丢弃
@@ -79,7 +83,7 @@ nonisolated struct ActivityLivePresentation {
current: waiting?.label ?? current.label, waiting: waiting, recent: recent,
toolCount: inventoryKnown ? items.values.filter(\.isTool).count : nil,
planCompleted: planCompleted, planTotal: planTotal,
- hasBlockingInputRequest: requests.values.contains { $0.isBlocking == true },
+ blockingInputSince: requests.values.filter { $0.isBlocking == true }.compactMap(\.since).min(),
isReviewing: isReviewing, updatedAt: current.at
)
}
diff --git a/CodexBar/Services/Activity/ActivityMonitor.swift b/CodexBar/Services/Activity/ActivityMonitor.swift
index 5636690..8e2b0f2 100644
--- a/CodexBar/Services/Activity/ActivityMonitor.swift
+++ b/CodexBar/Services/Activity/ActivityMonitor.swift
@@ -436,9 +436,9 @@ final class ActivityMonitor: ObservableObject {
let date: Date
switch transition {
case let .completed(completion): date = completion.completedAt
- case let .waitingApproval(snapshot):
- guard tasks.values.contains(where: { $0.displayID == snapshot.id && $0.state == .waitingApproval }) else { return false }
- date = snapshot.stateChangedAt
+ case let .waiting(task, since):
+ guard snapshot.blockingWaitingTaskIDs.contains(task.id) else { return false }
+ date = since
}
return date >= turnTransitionNotBefore && now.timeIntervalSince(date) <= 10
}
diff --git a/CodexBar/Services/Activity/ActivityTask.swift b/CodexBar/Services/Activity/ActivityTask.swift
index 2956966..3618661 100644
--- a/CodexBar/Services/Activity/ActivityTask.swift
+++ b/CodexBar/Services/Activity/ActivityTask.swift
@@ -139,10 +139,15 @@ nonisolated struct ActivityTask {
var result = (waiting ?? root ?? live.max { $0.1.updatedAt < $1.1.updatedAt })!.1
result.recent = live.compactMap(\.1.recent).max { $0.at < $1.at }
result.toolCount = live.allSatisfy { $0.1.toolCount != nil } ? live.reduce(0) { $0 + ($1.1.toolCount ?? 0) } : nil
- result.hasBlockingInputRequest = live.contains { $0.1.hasBlockingInputRequest }
+ result.blockingInputSince = live.compactMap(\.1.blockingInputSince).min()
return result
}
+ var blockingWaitStartedAt: Date? {
+ [state == .waitingApproval ? stateChangedAt : nil, livePresentation?.blockingInputSince]
+ .compactMap(\.self).min()
+ }
+
var turnReference: ActivityTurnReference {
ActivityTurnReference(
threadID: key.threadID,
diff --git a/CodexBar/Services/Activity/ActivityTaskGraph.swift b/CodexBar/Services/Activity/ActivityTaskGraph.swift
index c4f1ba4..7ca84b5 100644
--- a/CodexBar/Services/Activity/ActivityTaskGraph.swift
+++ b/CodexBar/Services/Activity/ActivityTaskGraph.swift
@@ -17,22 +17,32 @@ nonisolated struct ActivityTaskGraph {
mutating func update(
events: [ActivityDataRecord], source: ActivityEventSource, lifecycle: TurnLifecycleSnapshot
) -> [ActivityTransition] {
- let previouslyWaiting = Set(tasks.values.filter { $0.state == .waitingApproval }.map(\.displayID))
+ let previouslyWaiting = Set(tasks.values.filter { $0.blockingWaitStartedAt != nil }.map(\.displayID))
+ let previouslyAwaitingApproval = Set(tasks.values.filter { $0.state == .waitingApproval }.map(\.displayID))
var transitions = consume(events, source: source)
transitions += reconcile(lifecycle.lifecycleStates(for: lifecycleReferences()))
- for (key, task) in tasks where task.state == .waitingApproval && !previouslyWaiting.contains(task.displayID) {
+ for (key, task) in tasks where task.state == .waitingApproval && !previouslyAwaitingApproval.contains(task.displayID) {
if let approval = task.displayedApproval {
tasks[key]?.stateChangedAt = approval.requestedAt
}
}
- let waiting = Dictionary(uniqueKeysWithValues: tasks.values.filter { $0.state == .waitingApproval }.map { ($0.displayID, $0.snapshot) })
+ var waiting: [UUID: (snapshot: ActivityTaskSnapshot, since: Date)] = [:]
+ for task in tasks.values {
+ guard let since = task.blockingWaitStartedAt else { continue }
+ let snapshot = task.snapshot
+ waiting[task.displayID] = (snapshot, since)
+ // 提问只存在于实时内存状态, 不产生历史事件, 在生命周期核对后发布
+ if snapshot.presentation?.hasBlockingInputRequest == true {
+ transitions.append(.waiting(snapshot, since: since))
+ }
+ }
var notified = Set<UUID>()
// 事件中的等待只是候选, 提醒必须使用本次核对后的最终状态
return transitions.compactMap { transition in
- guard case let .waitingApproval(snapshot) = transition else { return transition }
+ guard case let .waiting(snapshot, _) = transition else { return transition }
guard !previouslyWaiting.contains(snapshot.id), let current = waiting[snapshot.id],
notified.insert(snapshot.id).inserted else { return nil }
- return .waitingApproval(current)
+ return .waiting(current.snapshot, since: current.since)
}
}
@@ -338,7 +348,7 @@ nonisolated struct ActivityTaskGraph {
var seen = Set<ActivityTaskKey>()
return keys.reversed().compactMap { key in
guard seen.insert(key).inserted, let task = tasks[key], task.state == .waitingApproval else { return nil }
- return .waitingApproval(task.snapshot)
+ return .waiting(task.snapshot, since: task.blockingWaitStartedAt ?? task.stateChangedAt)
}.reversed()
}
}
diff --git a/CodexBar/Services/Notifications/NotificationService.swift b/CodexBar/Services/Notifications/NotificationService.swift
index e22bc98..431da10 100644
--- a/CodexBar/Services/Notifications/NotificationService.swift
+++ b/CodexBar/Services/Notifications/NotificationService.swift
@@ -13,15 +13,38 @@ nonisolated enum AutoResetFailureNotice: String, Sendable {
/// 订阅额度与实时活动, 统一处理提醒条件, 去重, 触觉反馈与本地通知发送
@MainActor
final class NotificationService: NSObject {
+ struct Delivery {
+ var setDelegate: (any UNUserNotificationCenterDelegate) -> Void = {
+ UNUserNotificationCenter.current().delegate = $0
+ }
+
+ var add: (UNNotificationRequest) async throws -> Void = {
+ try await UNUserNotificationCenter.current().add($0)
+ }
+
+ var remove: ([String]) -> Void = {
+ let center = UNUserNotificationCenter.current()
+ center.removeDeliveredNotifications(withIdentifiers: $0)
+ center.removePendingNotificationRequests(withIdentifiers: $0)
+ }
+ }
+
private let settings: NotificationSettings
private let statusViewModel: CodexStatusViewModel
private let activityMonitor: ActivityMonitor
private let defaults: UserDefaults
+ private let delivery: Delivery
private nonisolated let openMenuSurface: @MainActor @Sendable () -> Void
private var cancellables = Set<AnyCancellable>()
private var taskHapticFeedbackTask: Task<Void, Never>?
private var taskWaitingNotificationIdentifiers = Set<String>()
+ #if CODEXBAR_TESTING
+ private(set) var lastSubmissionTaskForTesting: Task<Bool, Never>?
+ var taskWaitingNotificationIdentifiersForTesting: Set<String> {
+ taskWaitingNotificationIdentifiers
+ }
+ #endif
private let creditExpiryReminderScheduler = ReminderCheckScheduler()
private var latestQuotaSnapshot: CodexQuotaSnapshot?
@@ -56,12 +79,14 @@ final class NotificationService: NSObject {
statusViewModel: CodexStatusViewModel,
activityMonitor: ActivityMonitor,
defaults: UserDefaults = .standard,
+ delivery: Delivery = Delivery(),
openMenuSurface: @escaping @MainActor @Sendable () -> Void
) {
self.settings = settings
self.statusViewModel = statusViewModel
self.activityMonitor = activityMonitor
self.defaults = defaults
+ self.delivery = delivery
self.openMenuSurface = openMenuSurface
let storedDedupKeys = defaults.stringArray(forKey: Self.sentKeysKey) ?? []
sentDedupKeys = storedDedupKeys.filter { !$0.hasPrefix(Self.legacyResetDedupKeyPrefix) }
@@ -73,7 +98,7 @@ final class NotificationService: NSObject {
}
func start() {
- UNUserNotificationCenter.current().delegate = self
+ delivery.setDelegate(self)
settings.refreshAuthorizationStatus()
statusViewModel.$snapshot
@@ -126,7 +151,7 @@ final class NotificationService: NSObject {
}
switch transition {
- case let .waitingApproval(task):
+ case let .waiting(task, _):
guard settings.isTaskWaitingEnabled else {
return
}
@@ -138,10 +163,7 @@ final class NotificationService: NSObject {
sound: settings.taskWaitingSound,
identifier: identifier,
isStillRelevant: { [weak self] in
- self?.isTaskStillWaiting(
- taskID,
- notificationIdentifier: identifier
- ) ?? false
+ self?.activityMonitor.snapshot.blockingWaitingTaskIDs.contains(taskID) ?? false
},
onSubmissionFailure: { [weak self] in
self?.taskWaitingNotificationIdentifiers.remove(identifier)
@@ -160,22 +182,9 @@ final class NotificationService: NSObject {
}
}
- private func isTaskStillWaiting(
- _ taskID: UUID,
- notificationIdentifier: String
- ) -> Bool {
- let isStillWaiting = activityMonitor.snapshot.waitingTasks.contains {
- $0.id == taskID
- }
- if !isStillWaiting {
- taskWaitingNotificationIdentifiers.remove(notificationIdentifier)
- }
- return isStillWaiting
- }
-
private func reconcileTaskWaitingNotifications(with snapshot: ActivitySnapshot) {
- let activeIdentifiers = Set(snapshot.waitingTasks.map {
- Self.taskWaitingNotificationIdentifier(for: $0.id)
+ let activeIdentifiers = Set(snapshot.blockingWaitingTaskIDs.map {
+ Self.taskWaitingNotificationIdentifier(for: $0)
})
let obsoleteIdentifiers = taskWaitingNotificationIdentifiers.subtracting(activeIdentifiers)
guard !obsoleteIdentifiers.isEmpty else {
@@ -622,7 +631,7 @@ final class NotificationService: NSObject {
content: content,
trigger: nil
)
- return Task { @MainActor [weak self] in
+ let task = Task { @MainActor [weak self] in
await self?.deliver(
request,
kind: kind,
@@ -632,6 +641,10 @@ final class NotificationService: NSObject {
retryCount: retryCount
) ?? false
}
+ #if CODEXBAR_TESTING
+ lastSubmissionTaskForTesting = task
+ #endif
+ return task
}
/// 返回值是"这条通知真的提交出去了", 调用方据此决定要不要记下已通知
@@ -659,7 +672,7 @@ final class NotificationService: NSObject {
return false
}
do {
- try await UNUserNotificationCenter.current().add(request)
+ try await delivery.add(request)
guard isStillRelevant?() != false else {
// 投递后任务状态又变了, 撤回避免用户看到过期提醒
let details = LogFields.joined(
@@ -691,9 +704,7 @@ final class NotificationService: NSObject {
}
private func removeNotifications(withIdentifiers identifiers: [String]) {
- let center = UNUserNotificationCenter.current()
- center.removeDeliveredNotifications(withIdentifiers: identifiers)
- center.removePendingNotificationRequests(withIdentifiers: identifiers)
+ delivery.remove(identifiers)
}
private nonisolated static func accountKey(for snapshot: CodexQuotaSnapshot) -> String {
diff --git a/CodexBar/Services/Settings/NotificationSettings.swift b/CodexBar/Services/Settings/NotificationSettings.swift
index f732b4d..9ba8ff5 100644
--- a/CodexBar/Services/Settings/NotificationSettings.swift
+++ b/CodexBar/Services/Settings/NotificationSettings.swift
@@ -65,12 +65,19 @@ final class NotificationSettings: ObservableObject {
static let taskCompletionDurationOptions = [30, 60, 120, 300]
private let defaults: UserDefaults
+ private let readAuthorizationStatus: () async -> UNAuthorizationStatus
private var authorizationTask: Task<Void, Never>?
private var isRequestingAuthorization = false
private var appActivationObserver: AnyCancellable?
- init(defaults: UserDefaults = .standard) {
+ init(
+ defaults: UserDefaults = .standard,
+ readAuthorizationStatus: @escaping () async -> UNAuthorizationStatus = {
+ await UNUserNotificationCenter.current().notificationSettings().authorizationStatus
+ }
+ ) {
self.defaults = defaults
+ self.readAuthorizationStatus = readAuthorizationStatus
isEnabled = defaults.bool(forKey: Self.enabledKey)
isLowQuotaEnabled = Self.bool(from: defaults, key: Self.lowQuotaEnabledKey, defaultValue: true)
isQuotaResetEnabled = Self.bool(from: defaults, key: Self.quotaResetEnabledKey, defaultValue: true)
@@ -230,9 +237,8 @@ final class NotificationSettings: ObservableObject {
return
}
authorizationTask?.cancel()
- authorizationTask = Task { @MainActor [weak self] in
- let status = await UNUserNotificationCenter.current()
- .notificationSettings().authorizationStatus
+ authorizationTask = Task { @MainActor [weak self, readAuthorizationStatus] in
+ let status = await readAuthorizationStatus()
guard let self, !Task.isCancelled else {
return
}
diff --git a/Tests/App/Activity/ActivityUpdateTests.swift b/Tests/App/Activity/ActivityUpdateTests.swift
index d21f053..3eea810 100644
--- a/Tests/App/Activity/ActivityUpdateTests.swift
+++ b/Tests/App/Activity/ActivityUpdateTests.swift
@@ -46,12 +46,13 @@ struct ActivityUpdateTests {
#expect((task.state == .waitingApproval) == expectsWaiting)
#expect(transitions.count == (expectsWaiting ? 1 : 0))
if expectsWaiting {
- guard case let .waitingApproval(published) = try #require(transitions.first) else {
+ guard case let .waiting(published, since) = try #require(transitions.first) else {
Issue.record("Expected waiting transition")
return
}
#expect(published == task.snapshot)
#expect(published.stateChangedAt == now.addingTimeInterval(scenario == "replaced" ? -1 : -2))
+ #expect(since == published.stateChangedAt)
}
let repeated = graph.update(events: [], source: .bootstrap, lifecycle: snapshot)
#expect(repeated.isEmpty)
@@ -278,6 +279,138 @@ struct ActivityUpdateTests {
try server.finish()
}
+ @Test(arguments: [true, false, nil] as [Bool?], [false, true])
+ func inputWaitNotifiesOnlyWhenBlocking(isBlocking: Bool?, inChild: Bool) throws {
+ let now = Date()
+ var reducer = try approvalReducer(at: now)
+ var graph = ActivityTaskGraph()
+ _ = graph.update(events: [TestFixtures.event(at: now.addingTimeInterval(-60))], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ _ = try reducer.consume(inputRequest(id: "async", blocking: false), now: now.addingTimeInterval(-20))
+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)
+ let thread = inChild ? "child" : "thread-a"
+ let turn = inChild ? "child-turn" : "turn-a"
+ let since = now.addingTimeInterval(-1)
+ let input = try inputRequest(id: "blocking", blocking: isBlocking, thread: thread, turn: turn)
+ #expect(reducer.consume(input, now: since).isEmpty)
+ let transitions = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ let task = try #require(graph.tasks.values.first)
+ #expect(task.state == .running)
+ #expect(task.snapshot.presentation?.waiting?.since == now.addingTimeInterval(-20))
+ #expect(task.snapshot.presentation?.blockingInputSince == (isBlocking == true ? since : nil))
+ #expect(transitions == (isBlocking == true ? [.waiting(task.snapshot, since: since)] : []))
+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)
+
+ let userMessage = try TestFixtures.decode(ActivityInput.self, """
+ {"method":"item/completed","params":{"threadId":"\(thread)","turnId":"\(turn)",
+ "item":{"id":"reply","type":"userMessage","content":[{"type":"text","text":"Continue"}]}}}
+ """)
+ _ = reducer.consume(userMessage, now: now)
+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)
+ #expect(graph.tasks.values.first?.snapshot.presentation?.hasBlockingInputRequest == (isBlocking == true))
+
+ _ = try reducer.consume(resolvedRequest(id: "blocking", thread: thread), now: now)
+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)
+ #expect(graph.tasks.values.first?.blockingWaitStartedAt == nil)
+ _ = reducer.consume(input, now: now)
+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).count == (isBlocking == true ? 1 : 0))
+ }
+
+ @Test(arguments: [false, true])
+ func resolvedOrEndedInputDoesNotNotify(ended: Bool) throws {
+ let now = Date()
+ var reducer = try approvalReducer(at: now)
+ var graph = ActivityTaskGraph()
+ _ = graph.update(events: [TestFixtures.event(at: now.addingTimeInterval(-60))], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ _ = try reducer.consume(inputRequest(id: "input", blocking: true), now: now)
+ let resolution = try ended ? TestFixtures.decode(ActivityInput.self, """
+ {"method":"turn/completed","params":{"threadId":"thread-a","turn":{"id":"turn-a","status":"completed","completedAt":\(now.timeIntervalSince1970)}}}
+ """) : resolvedRequest(id: "input")
+ _ = reducer.consume(resolution, now: now)
+ let transitions = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ #expect(!transitions.contains {
+ if case .waiting = $0 {
+ true
+ } else {
+ false
+ }
+ })
+ #expect(graph.tasks.values.allSatisfy { $0.blockingWaitStartedAt == nil })
+ }
+
+ @Test func approvalAndBlockingInputsShareOneWaitingPeriod() throws {
+ let now = Date(timeIntervalSince1970: floor(Date().timeIntervalSince1970))
+ var reducer = try approvalReducer(at: now)
+ var graph = ActivityTaskGraph()
+ _ = graph.update(events: [TestFixtures.event(at: now.addingTimeInterval(-60))], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ let approvals = try reducer.consume(approvalRequest(id: "approval", at: now), now: now)
+ #expect(graph.update(events: approvals, source: .live, lifecycle: lifecycle(reducer, at: now)).count == 1)
+ for (id, thread, turn, offset) in [("first", "thread-a", "turn-a", 1.0), ("second", "child", "child-turn", 2.0)] {
+ _ = try reducer.consume(inputRequest(id: id, blocking: true, thread: thread, turn: turn), now: now.addingTimeInterval(offset))
+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)
+ }
+ for (id, thread, remaining) in [("approval", "child", 1.0), ("first", "thread-a", 2.0)] {
+ _ = try reducer.consume(resolvedRequest(id: id, thread: thread), now: now.addingTimeInterval(3))
+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)
+ #expect(graph.tasks.values.first?.blockingWaitStartedAt == now.addingTimeInterval(remaining))
+ }
+ _ = try reducer.consume(resolvedRequest(id: "second", thread: "child"), now: now.addingTimeInterval(4))
+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)
+ #expect(graph.tasks.values.first?.blockingWaitStartedAt == nil)
+ }
+
+ @Test(arguments: ["live", "bootstrap", "recovery", "unavailable", "stale", "before-cutoff"])
+ func monitorFiltersBlockingWaitsAndClearsResolvedRequests(scenario: String) throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let preferences = try TestPreferences()
+ defer { preferences.remove() }
+ let monitor = ActivityMonitor(
+ protectionSettings: ProtectionSettings(defaults: preferences.defaults),
+ protectionStore: ProtectionStore(directoryURL: directory.url), activityDataDirectoryURL: directory.url
+ )
+ let now = Date()
+ monitor.isActivitySourceHealthy = scenario != "unavailable"
+ monitor.isBootstrapping = scenario == "bootstrap"
+ monitor.isProtectionRecoveryInProgress = scenario == "recovery"
+ monitor.turnTransitionNotBefore = now.addingTimeInterval(scenario == "before-cutoff" ? 0 : -60)
+ var reducer = try approvalReducer(at: now)
+ var graph = ActivityTaskGraph()
+ _ = graph.update(events: [TestFixtures.event(at: now.addingTimeInterval(-60))], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ _ = try reducer.consume(inputRequest(id: "async", blocking: false), now: now.addingTimeInterval(-30))
+ _ = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ _ = try reducer.consume(inputRequest(id: "input", blocking: true), now: now.addingTimeInterval(scenario == "stale" ? -20 : -1))
+ let transitions = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ let readerID = UUID()
+ var published: [ActivityTransition] = []
+ let observation = monitor.transitionPublisher.sink { published.append($0) }
+ defer { observation.cancel() }
+ monitor.consume(update(graph, readerID: readerID, revision: 1, transitions: transitions))
+ #expect(published.count == (scenario == "live" ? 1 : 0))
+ #expect(monitor.snapshot.waitingTasks.isEmpty)
+ #expect(monitor.snapshot.blockingWaitingTaskIDs.count == 1)
+ #expect(monitor.snapshot.keepAliveTaskIDs.waiting == monitor.snapshot.blockingWaitingTaskIDs)
+ _ = try reducer.consume(resolvedRequest(id: "input"), now: now)
+ let resolved = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))
+ monitor.consume(update(graph, readerID: readerID, revision: 2, transitions: resolved))
+ #expect(monitor.snapshot.blockingWaitingTaskIDs.isEmpty)
+ #expect(monitor.snapshot.panelWaitingTasks.count == 1)
+ #expect(try !monitor.isCurrentTransition(#require(transitions.first), now: now))
+ #expect(published.count == (scenario == "live" ? 1 : 0))
+ }
+
+ private func inputRequest(id: String, blocking: Bool?, thread: String = "thread-a", turn: String = "turn-a") throws -> ActivityInput {
+ let blocking = blocking.map { String($0) } ?? "null"
+ return try TestFixtures.decode(ActivityInput.self, """
+ {"id":"\(id)","method":"item/tool/requestUserInput","params":{"threadId":"\(thread)","turnId":"\(turn)","isBlocking":\(blocking)}}
+ """)
+ }
+
+ private func resolvedRequest(id: String, thread: String = "thread-a") throws -> ActivityInput {
+ try TestFixtures.decode(ActivityInput.self, """
+ {"method":"serverRequest/resolved","params":{"threadId":"\(thread)","requestId":"\(id)"}}
+ """)
+ }
+
private func approvalReducer(at now: Date) throws -> AppServerActivityReducer {
var reducer = AppServerActivityReducer()
let root = try TestFixtures.decode(ActivityThread.self, #"{"id":"thread-a","source":"cli","status":{"type":"active"}}"#)
diff --git a/Tests/App/Notifications/TaskWaitingNotificationTests.swift b/Tests/App/Notifications/TaskWaitingNotificationTests.swift
new file mode 100644
index 0000000..d803655
--- /dev/null
+++ b/Tests/App/Notifications/TaskWaitingNotificationTests.swift
@@ -0,0 +1,222 @@
+import Foundation
+import Testing
+import UserNotifications
+
+struct TaskWaitingNotificationTests {
+ @Test(arguments: [false, true])
+ func resolvedBeforeSubmissionSkipsDeliveryAndClearsTracking(blockingInput: Bool) async throws {
+ let fixture = try Fixture()
+ defer { fixture.cleanUp() }
+ try await fixture.start()
+ let submission = try fixture.enterWaiting(blockingInput: blockingInput)
+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting == [fixture.identifier])
+
+ try fixture.resolveWaiting()
+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)
+ #expect(fixture.delivery.attempts.isEmpty)
+ #expect(await submission.value == false)
+ #expect(fixture.delivery.attempts.isEmpty)
+ #expect(fixture.delivery.delivered.isEmpty)
+ #expect(fixture.delivery.removals == [[fixture.identifier]])
+ }
+
+ @Test(arguments: [false, true])
+ func resolvedDuringSubmissionWithdrawsLateDelivery(blockingInput: Bool) async throws {
+ let fixture = try Fixture()
+ defer { fixture.cleanUp() }
+ try await fixture.start()
+ fixture.delivery.suspendsSubmissions = true
+ let submission = try fixture.enterWaiting(blockingInput: blockingInput)
+ try await waitUntil { fixture.delivery.hasPendingSubmission }
+
+ try fixture.resolveWaiting()
+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)
+ #expect(fixture.delivery.removals == [[fixture.identifier]])
+ fixture.delivery.resumeSubmission()
+ #expect(await submission.value == false)
+ #expect(fixture.delivery.attempts.count == 1)
+ #expect(fixture.delivery.delivered.isEmpty)
+ #expect(fixture.delivery.removals == [[fixture.identifier], [fixture.identifier]])
+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)
+ }
+
+ @Test(arguments: [false, true])
+ func resolvedAfterDeliveryUsesSnapshotToWithdrawAndClearTracking(blockingInput: Bool) async throws {
+ let fixture = try Fixture()
+ defer { fixture.cleanUp() }
+ try await fixture.start()
+ let submission = try fixture.enterWaiting(blockingInput: blockingInput)
+ #expect(await submission.value)
+ #expect(fixture.delivery.delivered == [fixture.identifier])
+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting == [fixture.identifier])
+
+ try fixture.resolveWaiting(keepsNonblockingQuestion: true)
+ #expect(fixture.monitor.snapshot.panelWaitingTasks.count == 1)
+ #expect(fixture.monitor.snapshot.blockingWaitingTaskIDs.isEmpty)
+ #expect(fixture.delivery.delivered.isEmpty)
+ #expect(fixture.delivery.removals == [[fixture.identifier]])
+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)
+ }
+
+ @Test(arguments: [false, true])
+ func exhaustedSubmissionRetriesClearTrackingWhileTaskStillWaits(blockingInput: Bool) async throws {
+ let fixture = try Fixture()
+ defer { fixture.cleanUp() }
+ try await fixture.start()
+ fixture.delivery.failuresRemaining = 2
+ let submission = try fixture.enterWaiting(blockingInput: blockingInput)
+ #expect(await submission.value == false)
+ #expect(fixture.delivery.attempts.count == 2)
+ #expect(fixture.monitor.snapshot.blockingWaitingTaskIDs == [fixture.taskID])
+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)
+ #expect(fixture.delivery.delivered.isEmpty)
+ #expect(fixture.delivery.removals.isEmpty)
+
+ try fixture.resolveWaiting()
+ #expect(fixture.delivery.removals.isEmpty)
+ let retried = try fixture.enterWaiting(blockingInput: blockingInput)
+ #expect(await retried.value)
+ #expect(fixture.delivery.delivered == [fixture.identifier])
+ try fixture.resolveWaiting()
+ #expect(fixture.delivery.removals == [[fixture.identifier]])
+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)
+ }
+}
+
+private func waitUntil(_ condition: () -> Bool) async throws {
+ let deadline = ContinuousClock.now.advanced(by: .seconds(2))
+ while !condition(), ContinuousClock.now < deadline {
+ try await Task.sleep(for: .milliseconds(5))
+ }
+ try #require(condition(), "Notification operation did not reach the expected state")
+}
+
+private final class Fixture {
+ let directory: TestDirectory
+ let preferences: TestPreferences
+ let settings: NotificationSettings
+ let monitor: ActivityMonitor
+ let service: NotificationService
+ let delivery = TestNotificationDelivery()
+ let taskID = UUID()
+ private let key = ActivityTaskKey(thread: "thread-a", turn: "turn-a")
+ private let owner = ActivityExecutionKey(agentThreadID: nil, turnID: "turn-a")
+ private var graph = ActivityTaskGraph()
+
+ var identifier: String {
+ "taskWaiting|\(taskID.uuidString)"
+ }
+
+ init() throws {
+ directory = try TestDirectory()
+ preferences = try TestPreferences()
+ preferences.defaults.set(true, forKey: "Notification.isEnabled")
+ settings = NotificationSettings(defaults: preferences.defaults, readAuthorizationStatus: { .authorized })
+ monitor = ActivityMonitor(
+ protectionSettings: ProtectionSettings(defaults: preferences.defaults),
+ protectionStore: ProtectionStore(directoryURL: directory.url), activityDataDirectoryURL: directory.url
+ )
+ let model = CodexStatusViewModel(
+ service: CodexStatusService(socketURL: directory.url.appendingPathComponent("unused.sock"), logStorage: nil),
+ defaults: preferences.defaults
+ )
+ service = NotificationService(
+ settings: settings, statusViewModel: model, activityMonitor: monitor,
+ defaults: preferences.defaults, delivery: delivery.client, openMenuSurface: {}
+ )
+ let now = Date()
+ graph.tasks[key] = ActivityTask(
+ displayID: taskID, key: key, event: TestFixtures.event(at: now),
+ state: .running, startedAt: now, progressGeneration: 0
+ )
+ monitor.isActivitySourceHealthy = true
+ monitor.turnTransitionNotBefore = now
+ }
+
+ func start() async throws {
+ service.start()
+ try await waitUntil { self.settings.canDeliver }
+ }
+
+ func enterWaiting(blockingInput: Bool) throws -> Task<Bool, Never> {
+ let now = Date()
+ if blockingInput {
+ graph.tasks[key]?.executions[owner]?.presentation = try question(blocking: true, at: now)
+ } else {
+ _ = graph.tasks[key]?.recordApprovalRequest(from: TestFixtures.event(.approvalRequested, at: now))
+ }
+ let snapshot = try #require(graph.tasks[key]?.snapshot)
+ monitor.acceptFixtureGraph(graph, transitions: [.waiting(snapshot, since: now)])
+ return try #require(service.lastSubmissionTaskForTesting)
+ }
+
+ func resolveWaiting(keepsNonblockingQuestion: Bool = false) throws {
+ graph.tasks[key]?.executions[owner]?.approval = nil
+ graph.tasks[key]?.executions[owner]?.presentation = try keepsNonblockingQuestion ? question(blocking: false, at: Date()) : nil
+ graph.tasks[key]?.state = .running
+ monitor.acceptFixtureGraph(graph)
+ }
+
+ func cleanUp() {
+ delivery.cancelPendingSubmissions()
+ preferences.remove()
+ try? directory.remove()
+ }
+
+ private func question(blocking: Bool, at date: Date) throws -> ActivityLivePresentation {
+ var presentation = ActivityLivePresentation()
+ let input = try TestFixtures.decode(ActivityInput.self, """
+ {"id":"input","method":"item/tool/requestUserInput","params":{"threadId":"thread-a","turnId":"turn-a","isBlocking":\(blocking)}}
+ """)
+ presentation.consume(input, at: date)
+ return presentation
+ }
+}
+
+private final class TestNotificationDelivery {
+ var suspendsSubmissions = false
+ var failuresRemaining = 0
+ private(set) var attempts: [String] = []
+ private(set) var delivered = Set<String>()
+ private(set) var removals: [Set<String>] = []
+ private var pending: CheckedContinuation<Void, any Error>?
+
+ var hasPendingSubmission: Bool {
+ pending != nil
+ }
+
+ var client: NotificationService.Delivery {
+ NotificationService.Delivery(
+ setDelegate: { _ in },
+ add: { [self] request in
+ attempts.append(request.identifier)
+ if suspendsSubmissions {
+ try await withCheckedThrowingContinuation { pending = $0 }
+ }
+ if failuresRemaining > 0 {
+ failuresRemaining -= 1
+ throw CocoaError(.fileWriteUnknown)
+ }
+ delivered.insert(request.identifier)
+ },
+ remove: { [self] identifiers in
+ removals.append(Set(identifiers))
+ delivered.subtract(identifiers)
+ }
+ )
+ }
+
+ func resumeSubmission() {
+ let continuation = pending
+ pending = nil
+ continuation?.resume()
+ }
+
+ func cancelPendingSubmissions() {
+ suspendsSubmissions = false
+ failuresRemaining = 2
+ let continuation = pending
+ pending = nil
+ continuation?.resume(throwing: CancellationError())
+ }
+}