feat: consolidate iOS with API and web preserving history

ios/Sources/Features/Tasks/TaskPanelView.swift

@@ -0,0 +1,265 @@
+import SwiftUI
+
+/// Nearlight Activity: a working log. Plain rows on Ground, no cards;
+/// live updates land in place without reordering while reading.
+struct TaskPanelView: View {
+    @ObservedObject var taskStore: TaskStore
+    @Environment(\.dynamicTypeSize) private var typeSize
+
+    var body: some View {
+        Group {
+            if taskStore.sortedTasks.isEmpty {
+                emptyState
+            } else {
+                taskList
+            }
+        }
+        .navigationTitle("Activity")
+        .background(Nearlight.ground)
+    }
+
+    private var taskList: some View {
+        ScrollView {
+            LazyVStack(alignment: .leading, spacing: 0) {
+                ForEach(taskStore.sortedTasks) { task in
+                    NavigationLink {
+                        TaskDetailView(taskStore: taskStore, taskID: task.id)
+                    } label: {
+                        TaskRowView(task: task)
+                    }
+                    .buttonStyle(.plain)
+                    Divider()
+                        .overlay(Nearlight.separator)
+                }
+            }
+            .padding(.horizontal, Nearlight.s20)
+        }
+    }
+
+    private var emptyState: some View {
+        VStack(alignment: .leading, spacing: Nearlight.s8) {
+            Image(systemName: "checklist")
+                .font(.system(size: 28))
+                .foregroundStyle(Nearlight.quiet)
+            Text("No tasks yet")
+                .font(NearlightFont.heading(typeSize))
+            Text("Tasks from your conversations will appear here.")
+                .font(.body)
+                .foregroundStyle(Nearlight.quiet)
+        }
+        .padding(.top, Nearlight.s32)
+        .padding(.horizontal, Nearlight.s20)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .accessibilityIdentifier("activity.empty")
+    }
+}
+
+/// One activity row: status symbol, title, current step/status, chevron.
+private struct TaskRowView: View {
+    let task: TaskItem
+    @Environment(\.dynamicTypeSize) private var typeSize
+
+    var body: some View {
+        HStack(spacing: Nearlight.s12) {
+            Image(systemName: statusSymbol)
+                .font(.system(size: 20))
+                .foregroundStyle(statusColor)
+                .accessibilityHidden(true)
+            VStack(alignment: .leading, spacing: Nearlight.s4) {
+                Text(statusTitle)
+                    .font(NearlightFont.support(typeSize))
+                    .foregroundStyle(statusColor)
+                    .fixedSize(horizontal: false, vertical: true)
+                Text(task.description)
+                    .font(NearlightFont.control(typeSize))
+                    .foregroundStyle(Nearlight.ink)
+                    .fixedSize(horizontal: false, vertical: true)
+                if let latest = latestStep {
+                    Text(latest)
+                        .font(NearlightFont.support(typeSize))
+                        .foregroundStyle(Nearlight.quiet)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+                Text(task.createdAt, style: .time)
+                    .font(NearlightFont.metadata(typeSize))
+                    .foregroundStyle(Nearlight.quiet)
+                    .monospacedDigit()
+            }
+            Spacer(minLength: 0)
+            Image(systemName: "chevron.right")
+                .font(.system(size: 13, weight: .medium))
+                .foregroundStyle(Nearlight.quiet)
+                .accessibilityHidden(true)
+        }
+        .padding(.vertical, Nearlight.s16)
+        .contentShape(Rectangle())
+    }
+
+    private var statusTitle: String {
+        switch task.status {
+        case .pending: return "Queued"
+        case .running: return "In progress"
+        case .completed: return "Complete"
+        case .failed: return "Needs attention"
+        }
+    }
+
+    private var latestStep: String? {
+        if let error = task.error { return error }
+        if let result = task.result { return result }
+        return task.steps.last?.content
+    }
+
+    private var statusSymbol: String {
+        switch task.status {
+        case .pending: return "circle.dotted"
+        case .running: return "arrow.triangle.2.circlepath"
+        case .completed: return "checkmark.circle"
+        case .failed: return "exclamationmark.circle"
+        }
+    }
+
+    private var statusColor: Color {
+        switch task.status {
+        case .pending: return Nearlight.quiet
+        case .running: return Nearlight.rosewood
+        case .completed: return Nearlight.quiet
+        case .failed: return Nearlight.alert
+        }
+    }
+}
+
+/// Native push detail for one task: title, status, steps, result/error.
+/// Looks the task up live in the store so removal shows the missing state.
+struct TaskDetailView: View {
+    @ObservedObject var taskStore: TaskStore
+    let taskID: String
+    @Environment(\.dynamicTypeSize) private var typeSize
+
+    private var task: TaskItem? {
+        taskStore.tasks[taskID]
+    }
+
+    var body: some View {
+        Group {
+            if let task {
+                TaskDetailContent(task: task)
+            } else {
+                Text("This task is no longer available.")
+                    .font(.body)
+                    .foregroundStyle(Nearlight.quiet)
+                    .padding(Nearlight.s20)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+            }
+        }
+        .background(Nearlight.ground)
+        .navigationTitle("Task")
+        .navigationBarTitleDisplayMode(.inline)
+    }
+}
+
+private struct TaskDetailContent: View {
+    let task: TaskItem
+    @Environment(\.dynamicTypeSize) private var typeSize
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: Nearlight.s24) {
+                VStack(alignment: .leading, spacing: Nearlight.s12) {
+                    Text(task.description)
+                        .font(NearlightFont.heading(typeSize))
+                        .fixedSize(horizontal: false, vertical: true)
+                    Label(statusTitle, systemImage: statusSymbol)
+                        .font(NearlightFont.support(typeSize))
+                        .foregroundStyle(statusColor)
+                    Text(task.createdAt, style: .time)
+                        .font(NearlightFont.metadata(typeSize))
+                        .foregroundStyle(Nearlight.quiet)
+                        .monospacedDigit()
+                }
+                VStack(alignment: .leading, spacing: 0) {
+                    Text("Steps")
+                        .font(NearlightFont.heading(typeSize))
+                        .padding(.bottom, Nearlight.s8)
+                    if task.steps.isEmpty {
+                        Text("No steps reported yet.")
+                            .font(.body)
+                            .foregroundStyle(Nearlight.quiet)
+                    } else {
+                        ForEach(task.steps) { step in
+                            VStack(alignment: .leading, spacing: Nearlight.s4) {
+                                if let role = step.role {
+                                    Text(roleLabel(role))
+                                        .font(NearlightFont.support(typeSize).weight(.semibold))
+                                        .foregroundStyle(Nearlight.quiet)
+                                }
+                                Text(step.content ?? "")
+                                    .font(.body)
+                                    .foregroundStyle(Nearlight.ink)
+                                    .textSelection(.enabled)
+                                    .fixedSize(horizontal: false, vertical: true)
+                            }
+                            .padding(.vertical, Nearlight.s16)
+                        }
+                    }
+                }
+                if let result = task.result {
+                    Text(result)
+                        .font(.body)
+                        .foregroundStyle(Nearlight.ink)
+                        .textSelection(.enabled)
+                }
+                if let error = task.error {
+                    Text(error)
+                        .font(.body)
+                        .foregroundStyle(Nearlight.alert)
+                        .textSelection(.enabled)
+                }
+            }
+            .padding(.horizontal, Nearlight.s20)
+            .padding(.top, Nearlight.s24)
+            .padding(.bottom, Nearlight.s24)
+        }
+    }
+
+    private var statusTitle: String {
+        switch task.status {
+        case .pending: return "Queued"
+        case .running: return "In progress"
+        case .completed: return "Complete"
+        case .failed: return "Needs attention"
+        }
+    }
+
+    private var statusSymbol: String {
+        switch task.status {
+        case .pending: return "circle.dotted"
+        case .running: return "arrow.triangle.2.circlepath"
+        case .completed: return "checkmark.circle"
+        case .failed: return "exclamationmark.circle"
+        }
+    }
+
+    private var statusColor: Color {
+        switch task.status {
+        case .pending: return Nearlight.quiet
+        case .running: return Nearlight.rosewood
+        case .completed: return Nearlight.quiet
+        case .failed: return Nearlight.alert
+        }
+    }
+
+    private func roleLabel(_ role: String) -> String {
+        switch role {
+        case "thinking": return "Thinking"
+        case "tool_call": return "Tool"
+        default: return role
+        }
+    }
+}
+
+#Preview {
+    NavigationStack {
+        TaskPanelView(taskStore: TaskStore())
+    }
+}