[PM-33571] llm: Add requirements refinement and planning skills

.claude/CLAUDE.md

@@ -29,53 +29,13 @@ The app follows a layered architecture: Views send Actions/Effects to a Store, w
 
 ### Code Organization
 
-```
-├── Bitwarden/                          # Password Manager app target
-│   └── Application/
-├── Authenticator/                      # Authenticator app target
-│   └── Application/
-├── BitwardenShared/                    # Main PM shared framework
-│   ├── Core/                           # Data & business logic
-│   │   ├── Auth/                       # Authentication domain
-│   │   ├── Autofill/                   # AutoFill domain
-│   │   ├── Platform/                   # Cross-cutting (services, stores, utilities)
-│   │   ├── Tools/                      # Generator, Send, Import/Export
-│   │   └── Vault/                      # Vault items domain
-│   ├── Sourcery/                       # Mock generation config + output
-│   └── UI/                             # UI layer (same subdirectories)
-│       ├── Auth/
-│       ├── Autofill/
-│       ├── Platform/
-│       ├── Tools/
-│       └── Vault/
-├── AuthenticatorShared/                # Authenticator shared framework
-│   ├── Core/                           # Same structure as BitwardenShared
-│   ├── Sourcery/                       # Mock generation config + output
-│   └── UI/
-├── BitwardenKit/                       # Common functionality across both apps
-│   ├── Core/
-│   │   └── Platform/Services/          # Has* protocols, ServiceContainer base
-│   ├── Sourcery/                       # Mock generation config + output
-│   └── UI/
-│       └── Platform/Application/
-│           └── Utilities/              # Store, Processor, Coordinator, Alert
-├── BitwardenResources/                 # Shared assets, fonts, localizations
-├── AuthenticatorBridgeKit/             # PM ↔ Authenticator communication
-├── Networking/                         # URLSession-based networking (Swift package)
-├── BitwardenAutoFillExtension/         # AutoFill Credential Provider extension
-├── BitwardenActionExtension/           # Action extension (autofill via share sheet)
-├── BitwardenShareExtension/            # Share extension (create Sends)
-├── BitwardenWatchApp/                  # watchOS companion
-├── GlobalTestHelpers/                  # Shared test utilities
-├── Sourcery/Templates/                 # Shared Sourcery Stencil templates
-├── Configs/                            # xcconfig files (Debug/Release per target)
-├── Scripts/                            # Build, bootstrap, CI scripts
-├── TestPlans/                          # Xcode test plans
-├── Docs/                               # Architecture.md, Testing.md
-└── project-*.yml                       # XcodeGen project specs
-```
+`Bitwarden/`, `Authenticator/` — app targets
+`BitwardenShared/`, `AuthenticatorShared/`, `BitwardenKit/` — shared frameworks; each has `Core/` + `UI/` with fixed subdirs: `Auth/`, `Autofill/`, `Platform/`, `Tools/`, `Vault/`
+`AuthenticatorBridgeKit/`, `BitwardenResources/`, `Networking/` — support frameworks
+`BitwardenAutoFillExtension/`, `BitwardenActionExtension/`, `BitwardenShareExtension/`, `BitwardenWatchApp/` — extensions
+`Docs/`, `Scripts/`, `TestPlans/`, `Configs/`, `Sourcery/Templates/`, `project-*.yml` — configuration
 
-**CRITICAL**: Do NOT add new top-level subdirectories to `Core/` or `UI/`. The fixed subdirectories are: `Auth/`, `Autofill/`, `Platform/`, `Tools/`, `Vault/`.
+**CRITICAL**: Do NOT add new top-level subdirectories to `Core/` or `UI/`. Fixed: `Auth/`, `Autofill/`, `Platform/`, `Tools/`, `Vault/`.
 
 For key principles (unidirectional data flow, dependency injection, coordinator navigation, zero-knowledge), core patterns (Coordinator/Processor/State/View/Action/Effect files), adding new features, adding services/repositories, and common patterns, see `Docs/Architecture.md`.
 
@@ -103,32 +63,13 @@ Build configurations use xcconfig files in `Configs/` (Debug/Release per target)
 
 Xcode version requirement: see `.xcode-version` file
 
-### Authentication & Authorization
-
-- **Login flows**: Email+password, SSO, SSO+TDE, passwordless (device approval), biometric unlock, PIN unlock
-- **Key derivation**: PBKDF2 or Argon2id (configurable per account)
-- **Token lifecycle**: Access tokens refreshed preemptively 5 minutes before expiry (`tokenRefreshThreshold`)
-- **Biometric auth**: Touch ID / Face ID unlock via Keychain access control flags
-- **Multi-account**: Up to 5 accounts with per-user data isolation (CoreData `userId` scoping)
-
 ## Testing
 
 **You MUST follow testing guidelines in `Docs/Testing.md`** (authoritative source for test structure, naming, templates, decision matrix, running tests, and simulator configuration). Snapshot tests are currently disabled — prefix function names with `disable`.
 
 ## Code Style & Standards
 
-### Core Directives
-
-**You MUST follow these directives at all times:**
-
-1. **Adhere to Architecture**: All code modifications MUST follow patterns in `Docs/Architecture.md`
-2. **Follow Code Style**: ALWAYS follow https://contributing.bitwarden.com/contributing/code-style/swift
-3. **Follow Testing Guidelines**: Tests MUST follow guidelines in `Docs/Testing.md`
-4. **Best Practices**: Follow Swift / SwiftUI best practices (value over reference types, guard clauses, extensions, protocol-oriented programming)
-5. **Document Everything**: All code requires DocC documentation except protocol property/function implementations (docs live in the protocol) and mocks
-6. **Dependency Management**: Use `ServiceContainer` as established in the project
-7. **Use Established Patterns**: Leverage existing components before creating new ones
-8. **File References**: Use `file_path:line_number` format when referencing code
+Architecture and testing rules are in `Docs/Architecture.md` and `Docs/Testing.md` (authoritative). Key style rules are inline below.
 
 ### Formatting
 

.claude/commands/plan-ios-work.md

@@ -0,0 +1,38 @@
+---
+description: Plan implementation for a Bitwarden iOS Jira ticket or task description. Fetches requirements, performs gap analysis, designs the implementation approach, and saves a design doc to .claude/outputs/plans/.
+argument-hint: <PM-XXXXX ticket ID or task description>
+---
+
+# Plan iOS Work: $ARGUMENTS
+
+## Phase 1: Ingest Requirements
+
+If `$ARGUMENTS` looks like a Jira ticket ID (e.g., `PM-12345` or `BWA-456`):
+- Fetch the ticket: `mcp__plugin_bitwarden-atlassian-tools_bitwarden-atlassian__get_issue`
+- Fetch comments for context: `mcp__plugin_bitwarden-atlassian-tools_bitwarden-atlassian__get_issue_comments`
+
+If `$ARGUMENTS` is a description, use it directly as the requirements source.
+
+## Phase 2: Refine Requirements
+
+Invoke the `refining-ios-requirements` skill to:
+- Extract structured requirements and acceptance criteria
+- Perform gap analysis (error states, edge cases, extensions, accessibility)
+- Map to iOS domain (Auth/Autofill/Platform/Tools/Vault)
+
+**Pause here**: Present requirements to user and confirm accuracy before proceeding.
+
+## Phase 3: Plan Implementation
+
+Once requirements are confirmed, invoke the `planning-ios-implementation` skill to:
+- Classify the change type
+- Explore existing similar patterns in the codebase
+- List all files to create/modify with domain placement
+- Order implementation into dependency-ordered phases
+- Assess risks (security, extensions, multi-account, SDK)
+
+## Phase 4: Save Design Doc
+
+Save the complete plan to `.claude/outputs/plans/<ticket-id>.md`.
+
+**Final output**: "Plan saved to `.claude/outputs/plans/<ticket-id>.md`. Ready to implement with `/work-on-ios <ticket-id>`."

.claude/skills/planning-ios-implementation/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: planning-ios-implementation
+description: Plan implementation, design an approach, or create an architecture plan for a Bitwarden iOS feature. Use when asked to "plan implementation", "design approach", "architecture plan", "how should I implement", "what files do I need", or to create a design doc before writing code.
+---
+
+# Planning iOS Implementation
+
+Use this skill to design a complete implementation plan before writing code. Output is saved as a design document.
+
+## Prerequisites
+
+- Requirements must be clear. If not, invoke `refining-ios-requirements` first.
+- Read `Docs/Architecture.md` before proceeding — it is the authoritative source for all patterns.
+
+## Step 1: Classify the Change
+
+Determine what type of change this is:
+- **New feature** (new screen + full file-set): Coordinator, Processor, State, Action, Effect, View, Route
+- **Enhancement** (modify existing screen): Identify which existing files change
+- **New service/repository**: Protocol + Default implementation + Has* protocol + Mock
+- **Bug fix**: Identify root cause file(s)
+- **Data model change**: CoreData schema + migration if needed
+
+## Step 2: Explore Existing Patterns
+
+Search the codebase for similar existing implementations to follow:
+- Find a similar existing feature in the same domain
+- Identify which services/repositories it uses
+- Note how its Coordinator, Processor, and View are structured
+- Check if `BitwardenKit/UI/` has reusable components for the new UI
+
+## Step 3: List Files to Create/Modify
+
+For each file, specify path, action (create/modify), domain placement, and purpose. Group by layer:
+
+```
+### New Files (Create)
+
+#### Core Layer
+- `BitwardenShared/Core/<Domain>/<Feature>/Services/<Feature>Service.swift`
+  - Protocol + Default<Feature>Service + Has<Feature>Service
+
+#### UI Layer
+- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>Coordinator.swift`
+- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>Processor.swift`
+- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>State.swift`
+- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>Action.swift`
+- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>Effect.swift`
+- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>View.swift`
+
+#### Tests (co-located with implementation)
+- `BitwardenShared/UI/<Domain>/<Feature>/<Feature>ProcessorTests.swift`
+- `BitwardenShared/Core/<Domain>/<Feature>/Services/<Feature>ServiceTests.swift`
+
+### Modified Files
+- `BitwardenShared/Core/Platform/Services/ServiceContainer.swift` — Add new service
+- `<Existing>Coordinator.swift` — Add new route
+```
+
+## Step 4: Dependency-Ordered Implementation Phases
+
+Order phases so each builds on the previous:
+
+```
+### Phase 1: Data / Core Layer
+Models, CoreData entities (if needed), service protocols, repository protocols
+
+### Phase 2: Service/Repository Implementations
+Default<Name>Service/Repository — business logic, SDK calls, network
+
+### Phase 3: Processor + State
+StateProcessor subclass, State struct, Action enum, Effect enum
+
+### Phase 4: View + Coordinator
+SwiftUI View with store.binding, Coordinator with routes, navigation wiring
+
+### Phase 5: DI Wiring
+ServiceContainer extensions, Has* protocol additions
+
+### Phase 6: Tests
+ProcessorTests (action/effect paths), ServiceTests (business logic), ViewTests (snapshots if UI)
+```
+
+## Step 5: Risk Assessment
+
+Identify risks and mitigations:
+- **Security**: Does this touch vault data, auth tokens, or Keychain? → Security review required
+- **Extensions**: Does this affect AutoFill/Action extensions? → Memory limit check needed
+- **Multi-account**: Does this need per-account isolation? → CoreData userId scoping
+- **SDK dependency**: Does this require BitwardenSdk changes? → Coordinate with SDK team
+
+## Step 6: Save Design Document
+
+Save the plan to `.claude/outputs/plans/<ticket-id>.md`.
+
+## Confirm Before Proceeding
+
+Present the plan to the user and ask: "Here is the implementation plan. Should I proceed with implementation?"

.claude/skills/refining-ios-requirements/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: refining-ios-requirements
+description: Refine requirements, analyze a ticket, perform gap analysis, or clarify what a Jira/Confluence ticket is asking before coding in Bitwarden iOS. Use when asked to "refine requirements", "analyze ticket", "gap analysis", "clarify ticket", "what does this ticket mean", or to understand scope before implementation begins.
+---
+
+# Refining iOS Requirements
+
+Use this skill to analyze a Jira or Confluence ticket and produce structured, implementation-ready requirements before writing any code.
+
+## Step 1: Ingest the Ticket
+
+If a ticket ID or URL is provided, fetch it via MCP:
+- Use `mcp__plugin_bitwarden-atlassian-tools_bitwarden-atlassian__get_issue` for Jira tickets
+- Use `mcp__plugin_bitwarden-atlassian-tools_bitwarden-atlassian__get_issue_comments` for additional context
+- Use `mcp__plugin_bitwarden-atlassian-tools_bitwarden-atlassian__get_confluence_page` for Confluence specs
+
+If no ticket is provided, ask for a description of the requirements.
+
+## Step 2: Extract Requirements
+
+Identify and list:
+1. **Core functionality**: What must this feature/fix do?
+2. **Acceptance criteria**: What defines "done"?
+3. **Out of scope**: What is explicitly excluded?
+4. **Dependencies**: Other tickets, SDK changes, API endpoints needed?
+
+## Step 3: Gap Analysis
+
+Identify unstated requirements the ticket may have missed:
+
+**Error states**
+- Network errors, timeout, server errors
+- Validation failures, empty states
+- SDK errors (encryption/decryption failures)
+
+**Edge cases**
+- Multi-account scenarios (up to 5 accounts)
+- Account switching during the operation
+- Locked vs unlocked vault state
+- Empty vault / first-time user
+
+**Platform concerns**
+- App extension impact (AutoFill, Action, Share — memory limits apply)
+- watchOS companion impact (if vault data is involved)
+- Offline mode behavior
+
+**Accessibility**
+- VoiceOver labels for new UI elements
+- Dynamic Type support
+- Keyboard navigation
+
+## Step 4: Map to iOS Domain
+
+Determine which Bitwarden iOS domain(s) are involved:
+- **Auth/**: Authentication, login, unlock, key derivation
+- **Autofill/**: Credential provider, autofill flows
+- **Platform/**: Cross-cutting concerns, services, utilities
+- **Tools/**: Generator, Send, Import/Export
+- **Vault/**: Cipher management, folders, collections
+
+Determine which app(s) are affected:
+- **BitwardenShared**: Password Manager
+- **AuthenticatorShared**: Authenticator
+- **Both**: If the feature touches shared components
+
+## Step 5: Output Structured Requirements
+
+```markdown
+## Ticket: [PM-XXXXX] — [Title]
+
+### What
+[1-2 sentence summary of what needs to be built]
+
+### Why
+[Business/user reason for the change]
+
+### Acceptance Criteria
+1. [Criterion 1]
+2. [Criterion 2]
+
+### Gap Analysis
+**Unstated requirements identified:**
+- [ ] Error state: [description]
+- [ ] Edge case: [description]
+- [ ] Platform concern: [description]
+
+**Clarifying questions (if any):**
+1. [Question for product/design]
+
+### Scope
+- **Domain**: [Auth / Autofill / Platform / Tools / Vault]
+- **App(s)**: [Password Manager / Authenticator / Both]
+- **Extensions affected**: [AutoFill / Action / Share / Watch / None]
+- **Out of scope**: [explicit exclusions]
+```
+
+## Confirm Before Proceeding
+
+Present the structured requirements to the user and ask: "Are these requirements accurate? Should I proceed with planning the implementation?"