Team Structure:
  Coordinator Agent:
    - macOS workflow management
    - Quality gate enforcement
    - Session continuity
    - Tools: planner, consensus, challenge

  Architecture Agent:
    - SwiftUI for macOS architecture design
    - SwiftData model design
    - Navigation patterns (split view vs stack)
    - Window and scene management
    - Tools: analyze, thinkdeep, apilookup

  UI Feature Agents (2):
    - Parallel SwiftUI view implementation
    - macOS-specific UI (toolbars, sidebars, menus)
    - @Observable state management
    - NavigationSplitView / NavigationStack flows
    - Tools: codereview, debug, refactor

  Testing Agent:
    - Unit tests (XCTest)
    - UI tests (XCUITest for macOS)
    - SwiftData testing
    - Tools: precommit, debug

struct ContentView: View {
    @State private var selectedItem: SidebarItem?

    var body: some View {
        NavigationSplitView {
            // Sidebar
            List(SidebarItem.allCases, selection: $selectedItem) { item in
                Label(item.title, systemImage: item.icon)
                    .tag(item)
            }
            .navigationTitle("My App")
        } detail: {
            // Detail view
            if let selectedItem {
                DetailView(for: selectedItem)
            } else {
                Text("Select an item")
                    .foregroundStyle(.secondary)
            }
        }
    }
}

enum SidebarItem: String, CaseIterable, Identifiable {
    case users, projects, settings

    var id: String { rawValue }

    var title: String {
        switch self {
        case .users: "Users"
        case .projects: "Projects"
        case .settings: "Settings"
        }
    }

    var icon: String {
        switch self {
        case .users: "person.2"
        case .projects: "folder"
        case .settings: "gear"
        }
    }
}

struct AdvancedContentView: View {
    @State private var selectedCategory: Category?
    @State private var selectedItem: Item?

    var body: some View {
        NavigationSplitView {
            // Sidebar (column 1)
            List(Category.allCases, selection: $selectedCategory) { category in
                Label(category.title, systemImage: category.icon)
            }
        } content: {
            // Content list (column 2)
            if let selectedCategory {
                List(selectedCategory.items, selection: $selectedItem) { item in
                    ItemRow(item: item)
                }
            }
        } detail: {
            // Detail (column 3)
            if let selectedItem {
                ItemDetailView(item: selectedItem)
            } else {
                Text("Select an item")
            }
        }
    }
}

struct DocumentView: View {
    @State private var store = DocumentStore()

    var body: some View {
        VStack {
            DocumentEditor(store: store)
        }
        .toolbar {
            ToolbarItemGroup(placement: .primaryAction) {
                Button {
                    Task {
                        await store.save()
                    }
                } label: {
                    Label("Save", systemImage: "square.and.arrow.down")
                }

                Button {
                    store.export()
                } label: {
                    Label("Export", systemImage: "square.and.arrow.up")
                }
            }

            ToolbarItem(placement: .navigation) {
                Button {
                    store.toggleSidebar()
                } label: {
                    Label("Toggle Sidebar", systemImage: "sidebar.left")
                }
            }
        }
    }
}

@main
struct MyMacApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .commands {
            // Custom menu commands
            CommandGroup(after: .newItem) {
                Button("New Project") {
                    // Action
                }
                .keyboardShortcut("n", modifiers: [.command, .shift])
            }
        }
        .defaultSize(width: 1200, height: 800)

        // Settings window
        Settings {
            SettingsView()
        }
    }
}

@main
struct MyMacApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .commands {
            // File menu
            CommandMenu("File") {
                Button("Open...") {
                    // Action
                }
                .keyboardShortcut("o")

                Divider()

                Button("Save") {
                    // Action
                }
                .keyboardShortcut("s")
            }

            // Edit menu additions
            CommandGroup(after: .pasteboard) {
                Button("Transform Text") {
                    // Action
                }
            }
        }

        // Menu bar extra (optional)
        MenuBarExtra("My App", systemImage: "star") {
            Button("Show Window") {
                // Action
            }
            Divider()
            Button("Quit") {
                NSApplication.shared.terminate(nil)
            }
        }
    }
}

1. zen analyze (quality focus)
   Focus Areas:
   - SwiftUI for macOS architecture
   - NavigationSplitView usage
   - @Observable state management
   - SwiftData model design
   - Toolbar and menu patterns
   - Window management

2. zen refactor (codesmells)
   Check For:
   - Legacy patterns (Combine, AppKit, Core Data)
   - Complex view hierarchies
   - State management issues
   - Navigation complexity
   - Inefficient toolbar/menu code

3. zen analyze (performance focus)
   macOS Metrics:
   - Build time (Xcode compilation)
   - Cold start time (app launch)
   - Memory usage (Activity Monitor)
   - App size (.app bundle size)
   - SwiftUI view rendering performance
   - Window resize performance

MyMacApp/
├── MyMacApp.xcodeproj
└── MyMacApp/
    ├── App/
    │   └── MyMacApp.swift              # @main entry point with WindowGroup
    ├── Models/
    │   ├── Document.swift              # SwiftData @Model
    │   └── Project.swift               # SwiftData @Model
    ├── Stores/
    │   ├── AppState.swift              # @Observable app state
    │   └── DocumentStore.swift         # @Observable store
    ├── Views/
    │   ├── ContentView.swift           # NavigationSplitView root
    │   ├── Sidebar/
    │   │   └── SidebarView.swift
    │   ├── Detail/
    │   │   ├── ProjectDetailView.swift
    │   │   └── DocumentDetailView.swift
    │   └── Settings/
    │       └── SettingsView.swift       # Settings window
    ├── Navigation/
    │   └── SidebarItem.swift           # Navigation model
    ├── Menus/
    │   └── Commands.swift              # Menu commands
    ├── Networking/
    │   └── APIClient.swift             # async/await API
    ├── Resources/
    │   └── Assets.xcassets
    └── Tests/
        ├── MyMacAppTests/              # XCTest unit tests
        └── MyMacAppUITests/            # XCUITest UI tests

1. Create new Xcode project (macOS App)
   - Interface: SwiftUI
   - Life Cycle: SwiftUI App
   - Language: Swift
   - Minimum Deployment: macOS 14.0

2. Enable SwiftData
   - Add @main with .modelContainer

3. Review macOS Development Guidelines (references)

4. Create PRD for macOS app

5. Use zen planner with PRD

6. Deploy 5-agent macOS team

1. Implement P1 features with:
   - SwiftUI views
   - NavigationSplitView for multi-pane layout
   - @Observable stores
   - SwiftData models
   - Toolbar and menu commands

2. Quality gates for each feature:
   - ✅ Builds in Xcode
   - ✅ Runs on macOS
   - ✅ Screenshot evidence
   - ✅ zen precommit passed

3. Phase gates at phase end:
   - ✅ analyze (quality)
   - ✅ refactor (debt)
   - ✅ analyze (performance)

zen planner:
  - Input: macOS app PRD
  - Output: Phase-based macOS implementation plan

zen analyze:
  - Focus: SwiftUI for macOS, NavigationSplitView patterns
  - Check: Compliance with mandatory standards
  - Validate: Window management, toolbar/menu design

zen codereview:
  - Verify: SwiftUI/SwiftData/Observable compliance
  - Check: No AppKit/CoreData/Combine
  - Validate: macOS 14.0+ patterns, navigation, menus

zen debug:
  - macOS-specific crashes
  - NavigationSplitView issues
  - SwiftData query problems
  - Window management bugs
  - @Observable state issues

zen refactor:
  - Migrate AppKit → SwiftUI
  - Migrate Core Data → SwiftData
  - Migrate Combine → @Observable
  - Optimize NavigationSplitView
  - Improve toolbar/menu structure