enigma-memory 0.1.18 → 0.1.22

package/apps/ios/EnigmaIOS/Enigma/AppModel.swift

@@ -0,0 +1,346 @@
+import EnigmaCore
+import Foundation
+import SwiftUI
+
+struct CouncilOpinion: Identifiable, Sendable {
+    let id = UUID()
+    let model: String
+    let answer: String
+    let error: String?
+}
+
+@MainActor
+final class AppModel: ObservableObject {
+    @Published var serverAddress: String
+    @Published var oauthIssuer: String
+    @Published var oauthClientID: String
+    @Published var oauthResource: String
+    @Published var isConnected = false
+    @Published var isBusy = false
+    @Published var errorMessage: String?
+    @Published var platform: PlatformResponse?
+    @Published var models: [PlatformModel] = []
+    @Published var selectedModel = "enigma-auto"
+    @Published var privacyMode: PrivacyMode = .smart
+    @Published var messages: [EnigmaMessage] = []
+    @Published var lastPrivacyReceipt: PrivacyReceipt?
+    @Published var imageModels: [PlatformModel] = []
+    @Published var videoModels: [PlatformModel] = []
+    @Published var councilOpinions: [CouncilOpinion] = []
+    @Published var generatedImages: [GeneratedImageAsset] = []
+    @Published var creditsVault: CreditsVault?
+    @Published var recoveryCodeShownOnce: String?
+    @Published var videoJob: VideoJob?
+    @Published var videoAsset: VideoAsset?
+    @Published var codeOutput = ""
+    @Published var codeSession: CodeSession?
+    @Published var browserSession: BrowserSession?
+    @Published var browserViewerOrigin: String
+    @Published var creditPackages: [CreditPackage] = []
+    @Published var usage: UsageAggregate?
+
+    private let broker = CredentialBroker()
+    private let privacy = PrivacyMinimizer(semanticTagger: NaturalLanguagePrivacyTagger())
+    private let secureStore = SecureStore()
+    private var client: EnigmaAPIClient?
+
+    init(defaults: UserDefaults = .standard) {
+        serverAddress = defaults.string(forKey: "enigma.server") ?? ""
+        oauthIssuer = defaults.string(forKey: "enigma.oauth.issuer") ?? ""
+        oauthClientID = defaults.string(forKey: "enigma.oauth.client") ?? ""
+        oauthResource = defaults.string(forKey: "enigma.oauth.resource") ?? ""
+        browserViewerOrigin = defaults.string(forKey: "enigma.browser.viewerOrigin") ?? ""
+        configureClient()
+        Task { await restoreConnection() }
+    }
+
+    var hasServer: Bool { client != nil }
+    var displayModel: String { selectedModel == "enigma-auto" ? "Auto" : selectedModel }
+
+    func configure(server: String, issuer: String, clientID: String, resource: String) {
+        serverAddress = server.trimmingCharacters(in: .whitespacesAndNewlines)
+        oauthIssuer = issuer.trimmingCharacters(in: .whitespacesAndNewlines)
+        oauthClientID = clientID.trimmingCharacters(in: .whitespacesAndNewlines)
+        oauthResource = resource.trimmingCharacters(in: .whitespacesAndNewlines)
+        let defaults = UserDefaults.standard
+        defaults.set(serverAddress, forKey: "enigma.server")
+        defaults.set(oauthIssuer, forKey: "enigma.oauth.issuer")
+        defaults.set(oauthClientID, forKey: "enigma.oauth.client")
+        defaults.set(oauthResource, forKey: "enigma.oauth.resource")
+        configureClient()
+    }
+
+    func connectWithOAuth() async {
+        guard let issuer = URL(string: oauthIssuer), let resource = URL(string: oauthResource) else {
+            errorMessage = "Enter the OAuth issuer and protected resource URL."
+            return
+        }
+        await perform {
+            let credential = try await OAuthClient().authorize(
+                issuer: issuer,
+                clientID: self.oauthClientID.isEmpty ? nil : self.oauthClientID,
+                resource: resource
+            )
+            self.oauthClientID = credential.clientID
+            UserDefaults.standard.set(credential.clientID, forKey: "enigma.oauth.client")
+            try await self.broker.save(credential)
+            self.isConnected = true
+            try await self.loadInitialData()
+        }
+    }
+    func setBrowserViewerOrigin(_ value: String) {
+        browserViewerOrigin = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        UserDefaults.standard.set(browserViewerOrigin, forKey: "enigma.browser.viewerOrigin")
+    }
+
+    func connectWithToken(_ token: String) async {
+        let value = token.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !value.isEmpty else { errorMessage = "Paste a direct Enigma token."; return }
+        await perform {
+            try await self.broker.saveDirectToken(value)
+            self.isConnected = true
+            try await self.loadInitialData()
+        }
+    }
+
+    func disconnect() async {
+        do { try await broker.clear() } catch { errorMessage = error.localizedDescription }
+        isConnected = false
+        platform = nil
+        models = []
+        clearConversation()
+    }
+
+    func send(_ prompt: String) async {
+        let value = prompt.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !value.isEmpty, let client else { return }
+        let user = EnigmaMessage(role: .user, content: value)
+        messages.append(user)
+        isBusy = true
+        errorMessage = nil
+        let protected = privacy.minimize(messages, mode: privacyMode)
+        defer {
+            protected.dispose()
+            isBusy = false
+        }
+        do {
+            let response = try await client.complete(.init(messages: protected.messages, model: selectedModel, privacyMode: "off"))
+            messages.append(.init(role: .assistant, content: protected.restore(response.answer)))
+            lastPrivacyReceipt = protected.receipt
+        } catch {
+            errorMessage = error.localizedDescription
+        }
+    }
+
+    func runCouncil(prompt: String, modelIDs: [String]) async {
+        let value = prompt.trimmingCharacters(in: .whitespacesAndNewlines)
+        let selected = Array(Set(modelIDs.filter { !$0.isEmpty })).prefix(3)
+        guard !value.isEmpty, selected.count >= 2, let client else {
+            errorMessage = "Choose at least two distinct models."
+            return
+        }
+        isBusy = true
+        errorMessage = nil
+        councilOpinions = []
+        let privacy = self.privacy
+        let mode = privacyMode
+        councilOpinions = await withTaskGroup(of: CouncilOpinion.self, returning: [CouncilOpinion].self) { group in
+            for model in selected {
+                group.addTask {
+                    let session = privacy.minimize([EnigmaMessage(role: .user, content: value)], mode: mode)
+                    defer { session.dispose() }
+                    do {
+                        let response = try await client.complete(.init(messages: session.messages, model: model, privacyMode: "off"))
+                        return CouncilOpinion(model: model, answer: session.restore(response.answer), error: nil)
+                    } catch {
+                        return CouncilOpinion(model: model, answer: "", error: error.localizedDescription)
+                    }
+                }
+            }
+            var results: [CouncilOpinion] = []
+            for await result in group { results.append(result) }
+            return results.sorted { $0.model < $1.model }
+        }
+        isBusy = false
+    }
+
+    func generateImage(prompt: String, model: String) async {
+        guard let client else { return }
+        let value = prompt.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !value.isEmpty, !model.isEmpty else { errorMessage = "Choose an image model and enter a prompt."; return }
+        await perform {
+            let session = self.privacy.minimize([EnigmaMessage(role: .user, content: value)], mode: self.privacyMode)
+            defer { session.dispose() }
+            let response = try await client.generateImage(.init(prompt: session.messages[0].content, model: model))
+            self.generatedImages = response.assets
+            self.lastPrivacyReceipt = session.receipt
+        }
+    }
+
+    func createCreditsVault() async {
+        guard let client else { return }
+        await perform {
+            let session = try await client.createCreditsVault()
+            try self.secureStore.setString(session.accessToken, account: "credits-access")
+            self.creditsVault = session.vault
+            self.recoveryCodeShownOnce = session.recoveryCode
+        }
+    }
+
+    func queueVideo(prompt: String, model: String) async {
+        guard let client else { return }
+        let value = prompt.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !value.isEmpty, !model.isEmpty else { errorMessage = "Choose a video model and enter a prompt."; return }
+        await perform {
+            let session = self.privacy.minimize([EnigmaMessage(role: .user, content: value)], mode: self.privacyMode)
+            defer { session.dispose() }
+            self.videoJob = try await client.queueVideo(.init(prompt: session.messages[0].content, model: model))
+            self.videoAsset = nil
+            self.lastPrivacyReceipt = session.receipt
+            for _ in 0..<120 {
+                try await Task.sleep(for: .seconds(2))
+                guard let id = self.videoJob?.id else { return }
+                let result = try await client.retrieveVideo(id: id)
+                self.videoJob = result.job
+                if result.job.status == "succeeded" {
+                    self.videoAsset = result.asset
+                    return
+                }
+                if ["failed", "cancelled", "expired"].contains(result.job.status) { return }
+            }
+            throw EnigmaAPIError.server(status: 408, code: "video_poll_timeout", message: "Video generation is still running. Reopen this screen to poll again.")
+        }
+    }
+
+    func executeCode(_ source: String) async {
+        guard let client else { return }
+        await perform {
+            let session = try await client.createCodeSession()
+            self.codeSession = session
+            do {
+                try await client.uploadCode(sessionID: session.id, source: source)
+                let execution = try await client.executeCode(sessionID: session.id)
+                let events = try await client.codeEvents(sessionID: session.id)
+                self.codeOutput = events.compactMap { event in
+                    guard event.type == "command.output", let data = event.data?.data else { return nil }
+                    return data
+                }.joined()
+                if self.codeOutput.isEmpty { self.codeOutput = execution.ok ? "Completed without output." : "Execution failed." }
+                _ = try await client.burnCodeSession(id: session.id)
+                self.codeSession = nil
+            } catch {
+                do {
+                    _ = try await client.burnCodeSession(id: session.id)
+                    self.codeSession = nil
+                } catch let cleanupError {
+                    self.codeOutput = "Cleanup failed. Retry is required before trusting disposal: \(cleanupError.localizedDescription)"
+                }
+                throw error
+            }
+        }
+    }
+
+    func startPrivateBrowser() async {
+        guard let client else { return }
+        await perform {
+            let created = try await client.createBrowserSession()
+            let connected = try await client.connectBrowserSession(id: created.id)
+            guard connected.privacy.privateNetworkBlocked, connected.streamUrl != nil else {
+                _ = try? await client.burnBrowserSession(id: created.id)
+                throw EnigmaAPIError.server(status: 503, code: "browser_proof_missing", message: "The browser broker did not prove network-level private-address blocking.")
+            }
+            self.browserSession = connected
+        }
+    }
+
+    func navigatePrivateBrowser(_ value: String) async {
+        guard let client, let id = browserSession?.id else { return }
+        await perform { self.browserSession = try await client.navigateBrowserSession(id: id, url: value) }
+    }
+
+    func burnPrivateBrowser() async {
+        guard let client, let id = browserSession?.id else { return }
+        await perform {
+            _ = try await client.burnBrowserSession(id: id)
+            self.browserSession = nil
+        }
+    }
+
+    func recoverCreditsVault(_ code: String) async {
+        guard let client else { return }
+        let value = code.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !value.isEmpty else { errorMessage = "Enter a recovery code."; return }
+        await perform {
+            let session = try await client.recoverCreditsVault(code: value)
+            try self.secureStore.setString(session.accessToken, account: "credits-access")
+            self.creditsVault = session.vault
+            self.recoveryCodeShownOnce = session.recoveryCode
+        }
+    }
+
+    func refreshCredits() async {
+        guard let client, let token = try? secureStore.string(account: "credits-access") else { return }
+        do { creditsVault = try await client.creditsStatus(accessToken: token) }
+        catch {
+            try? secureStore.remove(account: "credits-access")
+            creditsVault = nil
+        }
+    }
+
+    func forgetCreditsSession() {
+        try? secureStore.remove(account: "credits-access")
+        creditsVault = nil
+        recoveryCodeShownOnce = nil
+    }
+
+    func dismissRecoveryCode() { recoveryCodeShownOnce = nil }
+
+    func refreshUsage() async {
+        guard let client else { return }
+        do { usage = try await client.usage() }
+        catch { errorMessage = error.localizedDescription }
+    }
+
+    func clearConversation() {
+        messages.removeAll(keepingCapacity: false)
+        lastPrivacyReceipt = nil
+    }
+
+    private func configureClient() {
+        guard let url = URL(string: serverAddress) else { client = nil; return }
+        let broker = self.broker
+        client = try? EnigmaAPIClient(baseURL: url) { try await broker.accessToken() }
+    }
+
+    private func restoreConnection() async {
+        guard client != nil else { return }
+        do {
+            isConnected = try await broker.accessToken() != nil
+            if isConnected { try await loadInitialData() }
+        } catch {
+            errorMessage = error.localizedDescription
+        }
+    }
+
+    private func loadInitialData() async throws {
+        guard let client else { throw EnigmaAPIError.invalidBaseURL }
+        async let platform = client.platform()
+        async let models = client.models()
+        self.platform = try await platform
+        self.models = try await models
+        if self.platform?.capabilities.images == true { imageModels = (try? await client.imageModels()) ?? [] }
+        if self.platform?.capabilities.videos == true { videoModels = (try? await client.videoModels()) ?? [] }
+        if selectedModel != "enigma-auto" && !self.models.contains(where: { $0.id == selectedModel }) { selectedModel = "enigma-auto" }
+        creditPackages = (try? await client.creditPackages()) ?? []
+        await refreshCredits()
+        await refreshUsage()
+    }
+
+    private func perform(_ operation: () async throws -> Void) async {
+        isBusy = true
+        errorMessage = nil
+        defer { isBusy = false }
+        do { try await operation() }
+        catch { errorMessage = error.localizedDescription }
+    }
+}

package/apps/ios/EnigmaIOS/Enigma/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "colors" : [
+    {
+      "color" : {
+        "color-space" : "srgb",
+        "components" : { "alpha" : "1.000", "blue" : "0.110", "green" : "0.300", "red" : "0.940" }
+      },
+      "idiom" : "universal"
+    }
+  ],
+  "info" : { "author" : "xcode", "version" : 1 }
+}

package/apps/ios/EnigmaIOS/Enigma/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,11 @@
+{
+  "images" : [
+    {
+      "filename" : "EnigmaAppIcon.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : { "author" : "xcode", "version" : 1 }
+}

package/apps/ios/EnigmaIOS/Enigma/Assets.xcassets/Contents.json

@@ -0,0 +1,3 @@
+{
+  "info" : { "author" : "xcode", "version" : 1 }
+}

package/apps/ios/EnigmaIOS/Enigma/Assets.xcassets/LaunchBackground.colorset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "colors" : [
+    {
+      "color" : {
+        "color-space" : "srgb",
+        "components" : { "alpha" : "1.000", "blue" : "0.949", "green" : "0.969", "red" : "0.976" }
+      },
+      "idiom" : "universal"
+    }
+  ],
+  "info" : { "author" : "xcode", "version" : 1 }
+}

package/apps/ios/EnigmaIOS/Enigma/ChatView.swift

@@ -0,0 +1,181 @@
+import EnigmaCore
+import SwiftUI
+
+struct ChatView: View {
+    @EnvironmentObject private var model: AppModel
+    @State private var prompt = ""
+    @State private var showPrivacyReceipt = false
+
+    var body: some View {
+        ScrollViewReader { proxy in
+            ScrollView {
+                LazyVStack(spacing: 0) {
+                    if model.messages.isEmpty { emptyState }
+                    else {
+                        ForEach(model.messages) { message in
+                            MessageRow(message: message)
+                                .id(message.id)
+                        }
+                    }
+                }
+                .padding(.horizontal, 20)
+                .padding(.bottom, 130)
+            }
+            .scrollDismissesKeyboard(.interactively)
+            .onChange(of: model.messages.count) {
+                if let last = model.messages.last { withAnimation { proxy.scrollTo(last.id, anchor: .bottom) } }
+            }
+        }
+        .navigationTitle("new chat")
+        .navigationBarTitleDisplayMode(.inline)
+        .toolbar {
+            ToolbarItem(placement: .topBarLeading) {
+                HStack(spacing: 7) { EnigmaMark(size: 17); Text("Enigma.").font(.system(.headline, design: .serif)) }
+            }
+            ToolbarItemGroup(placement: .topBarTrailing) {
+                Button { showPrivacyReceipt = true } label: { Image(systemName: "checkmark.shield") }
+                    .disabled(model.lastPrivacyReceipt == nil)
+                Menu {
+                    Button("Clear local conversation", role: .destructive) { model.clearConversation() }
+                } label: { Image(systemName: "ellipsis") }
+            }
+        }
+        .safeAreaInset(edge: .bottom) { composer }
+        .sheet(isPresented: $showPrivacyReceipt) { PrivacyReceiptView(receipt: model.lastPrivacyReceipt) }
+        .enigmaCanvas()
+    }
+
+    private var emptyState: some View {
+        VStack(spacing: 0) {
+            Spacer(minLength: 74)
+            EnigmaMark(size: 28).padding(.bottom, 18)
+            SectionEyebrow(text: "PRIVATE AI WORKSPACE").padding(.bottom, 7)
+            Text("What would you like\nto work on?")
+                .font(.system(size: 34, weight: .medium, design: .serif))
+                .multilineTextAlignment(.center)
+                .tracking(-0.8)
+            Text("Enigma Auto chooses an explicit route. No training. No silent chat retention.")
+                .font(.footnote)
+                .foregroundStyle(EnigmaTheme.secondary)
+                .multilineTextAlignment(.center)
+                .padding(.top, 10)
+                .padding(.horizontal, 24)
+            VStack(spacing: 8) {
+                suggestion("explain e2e encryption →", prompt: "Explain end-to-end encryption and where metadata can still leak.")
+                suggestion("tor / i2p / mixnets →", prompt: "Compare Tor, I2P, and mixnets for private agent traffic.")
+                suggestion("plan from verified context →", prompt: "Draft an implementation plan grounded only in retrieved Enigma context.")
+            }
+            .padding(.top, 26)
+            VStack(spacing: 3) {
+                Text("· Conversation memory stays in this app process.")
+                Text("· Context leaves only when you send.")
+                Text("· Smart Privacy minimizes identity anchors first.")
+            }
+            .font(.caption2)
+            .foregroundStyle(EnigmaTheme.muted)
+            .padding(.top, 18)
+            Spacer(minLength: 70)
+        }
+        .frame(maxWidth: .infinity, minHeight: 520)
+    }
+
+    private func suggestion(_ label: String, prompt value: String) -> some View {
+        Button { prompt = value } label: {
+            Text(label).font(.footnote).foregroundStyle(EnigmaTheme.secondary)
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .padding(.horizontal, 14).padding(.vertical, 12)
+                .background(.white.opacity(0.74))
+                .overlay(RoundedRectangle(cornerRadius: 9).stroke(EnigmaTheme.line))
+        }
+        .buttonStyle(.plain)
+    }
+
+    private var composer: some View {
+        VStack(spacing: 9) {
+            HStack(alignment: .bottom, spacing: 10) {
+                TextField("Ask anything privately…", text: $prompt, axis: .vertical)
+                    .lineLimit(1...5)
+                    .font(EnigmaTheme.body)
+                    .padding(.horizontal, 12)
+                    .padding(.vertical, 10)
+                Button {
+                    let outgoing = prompt
+                    prompt = ""
+                    Task { await model.send(outgoing) }
+                } label: {
+                    Image(systemName: "arrow.up").font(.headline.weight(.bold)).foregroundStyle(.white)
+                        .frame(width: 38, height: 38).background(EnigmaTheme.ember).clipShape(Circle())
+                }
+                .disabled(prompt.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || model.isBusy)
+                .padding(5)
+            }
+            .background(.white)
+            .overlay(RoundedRectangle(cornerRadius: 15).stroke(EnigmaTheme.line))
+            .clipShape(RoundedRectangle(cornerRadius: 15))
+            HStack {
+                Menu(model.displayModel) {
+                    Button("Auto") { model.selectedModel = "enigma-auto" }
+                    ForEach(model.models) { route in Button(route.id) { model.selectedModel = route.id } }
+                }
+                Menu("Privacy: \(model.privacyMode.rawValue.capitalized)") {
+                    ForEach(PrivacyMode.allCases, id: \.self) { mode in Button(mode.rawValue.capitalized) { model.privacyMode = mode } }
+                }
+                Spacer()
+                Text("Local conversation").font(.caption2).foregroundStyle(EnigmaTheme.muted)
+            }
+            .font(.caption)
+        }
+        .padding(.horizontal, 14)
+        .padding(.top, 8)
+        .padding(.bottom, 5)
+        .background(.ultraThinMaterial)
+    }
+}
+
+private struct MessageRow: View {
+    let message: EnigmaMessage
+
+    var body: some View {
+        HStack(alignment: .top, spacing: 12) {
+            Text(message.role == .user ? "YOU" : "ENIGMA")
+                .font(EnigmaTheme.label)
+                .foregroundStyle(message.role == .assistant ? EnigmaTheme.ember : EnigmaTheme.muted)
+                .frame(width: 54, alignment: .leading)
+            Text(message.content)
+                .font(EnigmaTheme.body)
+                .foregroundStyle(EnigmaTheme.ink)
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .textSelection(.enabled)
+        }
+        .padding(.vertical, 18)
+        .overlay(alignment: .bottom) { Rectangle().fill(EnigmaTheme.line).frame(height: 0.6) }
+    }
+}
+
+private struct PrivacyReceiptView: View {
+    let receipt: PrivacyReceipt?
+    @Environment(\.dismiss) private var dismiss
+
+    var body: some View {
+        NavigationStack {
+            List {
+                if let receipt {
+                    Section("Boundary") {
+                        LabeledContent("Mode", value: receipt.mode.rawValue.capitalized)
+                        LabeledContent("Input", value: "\(receipt.inputCharacters) characters")
+                        LabeledContent("Output", value: "\(receipt.outputCharacters) characters")
+                        LabeledContent("Reference", value: String(receipt.receiptReference.uuidString.prefix(12)) + "…")
+                    }
+                    Section("Actions") {
+                        ForEach(receipt.summary, id: \.self) { item in
+                            LabeledContent(item.category.rawValue, value: "\(item.action) × \(item.count)")
+                        }
+                    }
+                    Section { Text("Receipt metadata contains no prompt, output, or deterministic prompt hash.") }
+                } else { Text("No protected turn yet.") }
+            }
+            .navigationTitle("Smart Privacy")
+            .toolbar { Button("Done") { dismiss() } }
+        }
+    }
+}

package/apps/ios/EnigmaIOS/Enigma/CouncilView.swift

@@ -0,0 +1,78 @@
+import SwiftUI
+
+struct CouncilView: View {
+    @EnvironmentObject private var model: AppModel
+    @State private var prompt = ""
+    @State private var seats = ["", "", ""]
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 22) {
+                VStack(alignment: .leading, spacing: 8) {
+                    SectionEyebrow(text: "MULTI-MODEL COUNCIL")
+                    Text("Independent answers.\nOne shared brief.")
+                        .font(EnigmaTheme.display)
+                        .tracking(-0.8)
+                    Text("Each seat receives the same locally minimized question. Answers remain separate; Enigma does not hide a synthesizer behind the panel.")
+                        .font(.subheadline)
+                        .foregroundStyle(EnigmaTheme.secondary)
+                }
+                VStack(spacing: 0) {
+                    ForEach(0..<3, id: \.self) { index in
+                        HStack {
+                            Text("SEAT 0\(index + 1)").font(EnigmaTheme.label).foregroundStyle(EnigmaTheme.muted)
+                            Spacer()
+                            Picker("Seat \(index + 1)", selection: $seats[index]) {
+                                Text("Choose route").tag("")
+                                ForEach(model.models) { route in Text(route.id).tag(route.id) }
+                            }
+                            .labelsHidden()
+                        }
+                        .padding(.vertical, 14)
+                        if index < 2 { Divider().overlay(EnigmaTheme.line) }
+                    }
+                }
+                .enigmaSurface(padding: 16)
+
+                VStack(alignment: .leading, spacing: 10) {
+                    Text("BRIEF").font(EnigmaTheme.label).foregroundStyle(EnigmaTheme.muted)
+                    TextField("Place one question before the council…", text: $prompt, axis: .vertical)
+                        .lineLimit(4...9)
+                        .padding(12)
+                        .background(.white)
+                        .overlay(RoundedRectangle(cornerRadius: 9).stroke(EnigmaTheme.line))
+                    Button("Convene council") {
+                        Task { await model.runCouncil(prompt: prompt, modelIDs: seats) }
+                    }
+                    .buttonStyle(PrimaryButtonStyle())
+                    .disabled(model.isBusy || prompt.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+                }
+
+                ForEach(model.councilOpinions) { opinion in
+                    VStack(alignment: .leading, spacing: 10) {
+                        HStack {
+                            Text(opinion.model).font(.subheadline.weight(.semibold))
+                            Spacer()
+                            Circle().fill(opinion.error == nil ? EnigmaTheme.success : .red).frame(width: 7, height: 7)
+                        }
+                        Text(opinion.error ?? opinion.answer)
+                            .font(EnigmaTheme.body)
+                            .foregroundStyle(opinion.error == nil ? EnigmaTheme.ink : .red)
+                            .textSelection(.enabled)
+                    }
+                    .enigmaSurface(padding: 16)
+                }
+            }
+            .padding(20)
+            .padding(.bottom, 34)
+        }
+        .navigationTitle("Council")
+        .navigationBarTitleDisplayMode(.inline)
+        .enigmaCanvas()
+        .onAppear {
+            if seats.allSatisfy(\.isEmpty) {
+                for (index, route) in model.models.prefix(3).enumerated() { seats[index] = route.id }
+            }
+        }
+    }
+}