Fix chat message race condition on notification tap

Remove partner text from shareable card
Fix premium access check and tab bar styling
2026-11-02 10:19:43 +00:00 · 2026-01-25 20:29:11 +00:00 · 2026-01-25 19:57:34 +00:00 · 2026-01-25 19:56:47 +00:00 · 2026-01-25 19:36:48 +00:00 · 2026-01-25 19:35:25 +00:00
343 changed files with 44465 additions and 8987 deletions
@@ -0,0 +1,227 @@
+---
+name: ios-simulator-skill
+version: 1.3.0
+description: 21 production-ready scripts for iOS app testing, building, and automation. Provides semantic UI navigation, build automation, accessibility testing, and simulator lifecycle management. Optimized for AI agents with minimal token output.
+---
+
+# iOS Simulator Skill
+
+Build, test, and automate iOS applications using accessibility-driven navigation and structured data instead of pixel coordinates.
+
+## Quick Start
+
+```bash
+# 1. Check environment
+bash scripts/sim_health_check.sh
+
+# 2. Launch app
+python scripts/app_launcher.py --launch com.example.app
+
+# 3. Map screen to see elements
+python scripts/screen_mapper.py
+
+# 4. Tap button
+python scripts/navigator.py --find-text "Login" --tap
+
+# 5. Enter text
+python scripts/navigator.py --find-type TextField --enter-text "user@example.com"
+```
+
+All scripts support `--help` for detailed options and `--json` for machine-readable output.
+
+## 21 Production Scripts
+
+### Build & Development (2 scripts)
+
+1. **build_and_test.py** - Build Xcode projects, run tests, parse results with progressive disclosure
+   - Build with live result streaming
+   - Parse errors and warnings from xcresult bundles
+   - Retrieve detailed build logs on demand
+   - Options: `--project`, `--scheme`, `--clean`, `--test`, `--verbose`, `--json`
+
+2. **log_monitor.py** - Real-time log monitoring with intelligent filtering
+   - Stream logs or capture by duration
+   - Filter by severity (error/warning/info/debug)
+   - Deduplicate repeated messages
+   - Options: `--app`, `--severity`, `--follow`, `--duration`, `--output`, `--json`
+
+### Navigation & Interaction (5 scripts)
+
+3. **screen_mapper.py** - Analyze current screen and list interactive elements
+   - Element type breakdown
+   - Interactive button list
+   - Text field status
+   - Options: `--verbose`, `--hints`, `--json`
+
+4. **navigator.py** - Find and interact with elements semantically
+   - Find by text (fuzzy matching)
+   - Find by element type
+   - Find by accessibility ID
+   - Enter text or tap elements
+   - Options: `--find-text`, `--find-type`, `--find-id`, `--tap`, `--enter-text`, `--json`
+
+5. **gesture.py** - Perform swipes, scrolls, pinches, and complex gestures
+   - Directional swipes (up/down/left/right)
+   - Multi-swipe scrolling
+   - Pinch zoom
+   - Long press
+   - Pull to refresh
+   - Options: `--swipe`, `--scroll`, `--pinch`, `--long-press`, `--refresh`, `--json`
+
+6. **keyboard.py** - Text input and hardware button control
+   - Type text (fast or slow)
+   - Special keys (return, delete, tab, space, arrows)
+   - Hardware buttons (home, lock, volume, screenshot)
+   - Key combinations
+   - Options: `--type`, `--key`, `--button`, `--slow`, `--clear`, `--dismiss`, `--json`
+
+7. **app_launcher.py** - App lifecycle management
+   - Launch apps by bundle ID
+   - Terminate apps
+   - Install/uninstall from .app bundles
+   - Deep link navigation
+   - List installed apps
+   - Check app state
+   - Options: `--launch`, `--terminate`, `--install`, `--uninstall`, `--open-url`, `--list`, `--state`, `--json`
+
+### Testing & Analysis (5 scripts)
+
+8. **accessibility_audit.py** - Check WCAG compliance on current screen
+   - Critical issues (missing labels, empty buttons, no alt text)
+   - Warnings (missing hints, small touch targets)
+   - Info (missing IDs, deep nesting)
+   - Options: `--verbose`, `--output`, `--json`
+
+9. **visual_diff.py** - Compare two screenshots for visual changes
+   - Pixel-by-pixel comparison
+   - Threshold-based pass/fail
+   - Generate diff images
+   - Options: `--threshold`, `--output`, `--details`, `--json`
+
+10. **test_recorder.py** - Automatically document test execution
+    - Capture screenshots and accessibility trees per step
+    - Generate markdown reports with timing data
+    - Options: `--test-name`, `--output`, `--verbose`, `--json`
+
+11. **app_state_capture.py** - Create comprehensive debugging snapshots
+    - Screenshot, UI hierarchy, app logs, device info
+    - Markdown summary for bug reports
+    - Options: `--app-bundle-id`, `--output`, `--log-lines`, `--json`
+
+12. **sim_health_check.sh** - Verify environment is properly configured
+    - Check macOS, Xcode, simctl, IDB, Python
+    - List available and booted simulators
+    - Verify Python packages (Pillow)
+
+### Advanced Testing & Permissions (4 scripts)
+
+13. **clipboard.py** - Manage simulator clipboard for paste testing
+    - Copy text to clipboard
+    - Test paste flows without manual entry
+    - Options: `--copy`, `--test-name`, `--expected`, `--json`
+
+14. **status_bar.py** - Override simulator status bar appearance
+    - Presets: clean (9:41, 100% battery), testing (11:11, 50%), low-battery (20%), airplane (offline)
+    - Custom time, network, battery, WiFi settings
+    - Options: `--preset`, `--time`, `--data-network`, `--battery-level`, `--clear`, `--json`
+
+15. **push_notification.py** - Send simulated push notifications
+    - Simple mode (title + body + badge)
+    - Custom JSON payloads
+    - Test notification handling and deep links
+    - Options: `--bundle-id`, `--title`, `--body`, `--badge`, `--payload`, `--json`
+
+16. **privacy_manager.py** - Grant, revoke, and reset app permissions
+    - 13 supported services (camera, microphone, location, contacts, photos, calendar, health, etc.)
+    - Batch operations (comma-separated services)
+    - Audit trail with test scenario tracking
+    - Options: `--bundle-id`, `--grant`, `--revoke`, `--reset`, `--list`, `--json`
+
+### Device Lifecycle Management (5 scripts)
+
+17. **simctl_boot.py** - Boot simulators with optional readiness verification
+    - Boot by UDID or device name
+    - Wait for device ready with timeout
+    - Batch boot operations (--all, --type)
+    - Performance timing
+    - Options: `--udid`, `--name`, `--wait-ready`, `--timeout`, `--all`, `--type`, `--json`
+
+18. **simctl_shutdown.py** - Gracefully shutdown simulators
+    - Shutdown by UDID or device name
+    - Optional verification of shutdown completion
+    - Batch shutdown operations
+    - Options: `--udid`, `--name`, `--verify`, `--timeout`, `--all`, `--type`, `--json`
+
+19. **simctl_create.py** - Create simulators dynamically
+    - Create by device type and iOS version
+    - List available device types and runtimes
+    - Custom device naming
+    - Returns UDID for CI/CD integration
+    - Options: `--device`, `--runtime`, `--name`, `--list-devices`, `--list-runtimes`, `--json`
+
+20. **simctl_delete.py** - Permanently delete simulators
+    - Delete by UDID or device name
+    - Safety confirmation by default (skip with --yes)
+    - Batch delete operations
+    - Smart deletion (--old N to keep N per device type)
+    - Options: `--udid`, `--name`, `--yes`, `--all`, `--type`, `--old`, `--json`
+
+21. **simctl_erase.py** - Factory reset simulators without deletion
+    - Preserve device UUID (faster than delete+create)
+    - Erase all, by type, or booted simulators
+    - Optional verification
+    - Options: `--udid`, `--name`, `--verify`, `--timeout`, `--all`, `--type`, `--booted`, `--json`
+
+## Common Patterns
+
+**Auto-UDID Detection**: Most scripts auto-detect the booted simulator if --udid is not provided.
+
+**Device Name Resolution**: Use device names (e.g., "iPhone 16 Pro") instead of UDIDs - scripts resolve automatically.
+
+**Batch Operations**: Many scripts support `--all` for all simulators or `--type iPhone` for device type filtering.
+
+**Output Formats**: Default is concise human-readable output. Use `--json` for machine-readable output in CI/CD.
+
+**Help**: All scripts support `--help` for detailed options and examples.
+
+## Typical Workflow
+
+1. Verify environment: `bash scripts/sim_health_check.sh`
+2. Launch app: `python scripts/app_launcher.py --launch com.example.app`
+3. Analyze screen: `python scripts/screen_mapper.py`
+4. Interact: `python scripts/navigator.py --find-text "Button" --tap`
+5. Verify: `python scripts/accessibility_audit.py`
+6. Debug if needed: `python scripts/app_state_capture.py --app-bundle-id com.example.app`
+
+## Requirements
+
+- macOS 12+
+- Xcode Command Line Tools
+- Python 3
+- IDB (optional, for interactive features)
+
+## Documentation
+
+- **SKILL.md** (this file) - Script reference and quick start
+- **README.md** - Installation and examples
+- **CLAUDE.md** - Architecture and implementation details
+- **references/** - Deep documentation on specific topics
+- **examples/** - Complete automation workflows
+
+## Key Design Principles
+
+**Semantic Navigation**: Find elements by meaning (text, type, ID) not pixel coordinates. Survives UI changes.
+
+**Token Efficiency**: Concise default output (3-5 lines) with optional verbose and JSON modes for detailed results.
+
+**Accessibility-First**: Built on standard accessibility APIs for reliability and compatibility.
+
+**Zero Configuration**: Works immediately on any macOS with Xcode. No setup required.
+
+**Structured Data**: Scripts output JSON or formatted text, not raw logs. Easy to parse and integrate.
+
+**Auto-Learning**: Build system remembers your device preference. Configuration stored per-project.
+
+---
+
+Use these scripts directly or let Claude Code invoke them automatically when your request matches the skill description.
@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""
+iOS Simulator Accessibility Audit
+
+Scans the current simulator screen for accessibility compliance issues.
+Optimized for minimal token output while maintaining functionality.
+
+Usage: python scripts/accessibility_audit.py [options]
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from dataclasses import asdict, dataclass
+from typing import Any
+
+from common import flatten_tree, get_accessibility_tree, resolve_udid
+
+
+@dataclass
+class Issue:
+    """Represents an accessibility issue."""
+
+    severity: str  # critical, warning, info
+    rule: str
+    element_type: str
+    issue: str
+    fix: str
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return asdict(self)
+
+
+class AccessibilityAuditor:
+    """Performs accessibility audits on iOS simulator screens."""
+
+    # Critical rules that block users
+    CRITICAL_RULES = {
+        "missing_label": lambda e: e.get("type") in ["Button", "Link"] and not e.get("AXLabel"),
+        "empty_button": lambda e: e.get("type") == "Button"
+        and not (e.get("AXLabel") or e.get("AXValue")),
+        "image_no_alt": lambda e: e.get("type") == "Image" and not e.get("AXLabel"),
+    }
+
+    # Warnings that degrade UX
+    WARNING_RULES = {
+        "missing_hint": lambda e: e.get("type") in ["Slider", "TextField"] and not e.get("help"),
+        "missing_traits": lambda e: e.get("type") and not e.get("traits"),
+    }
+
+    # Info level suggestions
+    INFO_RULES = {
+        "no_identifier": lambda e: not e.get("AXUniqueId"),
+        "deep_nesting": lambda e: e.get("depth", 0) > 5,
+    }
+
+    def __init__(self, udid: str | None = None):
+        """Initialize auditor with optional device UDID."""
+        self.udid = udid
+
+    def get_accessibility_tree(self) -> dict:
+        """Fetch accessibility tree from simulator using shared utility."""
+        return get_accessibility_tree(self.udid, nested=True)
+
+    @staticmethod
+    def _is_small_target(element: dict) -> bool:
+        """Check if touch target is too small (< 44x44 points)."""
+        frame = element.get("frame", {})
+        width = frame.get("width", 0)
+        height = frame.get("height", 0)
+        return width < 44 or height < 44
+
+    def _flatten_tree(self, node: dict, depth: int = 0) -> list[dict]:
+        """Flatten nested accessibility tree for easier processing using shared utility."""
+        return flatten_tree(node, depth)
+
+    def audit_element(self, element: dict) -> list[Issue]:
+        """Audit a single element for accessibility issues."""
+        issues = []
+
+        # Check critical rules
+        for rule_name, rule_func in self.CRITICAL_RULES.items():
+            if rule_func(element):
+                issues.append(
+                    Issue(
+                        severity="critical",
+                        rule=rule_name,
+                        element_type=element.get("type", "Unknown"),
+                        issue=self._get_issue_description(rule_name),
+                        fix=self._get_fix_suggestion(rule_name),
+                    )
+                )
+
+        # Check warnings (skip if critical issues found)
+        if not issues:
+            for rule_name, rule_func in self.WARNING_RULES.items():
+                if rule_func(element):
+                    issues.append(
+                        Issue(
+                            severity="warning",
+                            rule=rule_name,
+                            element_type=element.get("type", "Unknown"),
+                            issue=self._get_issue_description(rule_name),
+                            fix=self._get_fix_suggestion(rule_name),
+                        )
+                    )
+
+        # Check info level (only if verbose or no other issues)
+        if not issues:
+            for rule_name, rule_func in self.INFO_RULES.items():
+                if rule_func(element):
+                    issues.append(
+                        Issue(
+                            severity="info",
+                            rule=rule_name,
+                            element_type=element.get("type", "Unknown"),
+                            issue=self._get_issue_description(rule_name),
+                            fix=self._get_fix_suggestion(rule_name),
+                        )
+                    )
+
+        return issues
+
+    def _get_issue_description(self, rule: str) -> str:
+        """Get human-readable issue description."""
+        descriptions = {
+            "missing_label": "Interactive element missing accessibility label",
+            "empty_button": "Button has no text or label",
+            "image_no_alt": "Image missing alternative text",
+            "missing_hint": "Complex control missing hint",
+            "small_touch_target": "Touch target smaller than 44x44pt",
+            "missing_traits": "Element missing accessibility traits",
+            "no_identifier": "Missing accessibility identifier",
+            "deep_nesting": "Deeply nested (>5 levels)",
+        }
+        return descriptions.get(rule, "Accessibility issue")
+
+    def _get_fix_suggestion(self, rule: str) -> str:
+        """Get fix suggestion for issue."""
+        fixes = {
+            "missing_label": "Add accessibilityLabel",
+            "empty_button": "Set button title or accessibilityLabel",
+            "image_no_alt": "Add accessibilityLabel with description",
+            "missing_hint": "Add accessibilityHint",
+            "small_touch_target": "Increase to minimum 44x44pt",
+            "missing_traits": "Set appropriate accessibilityTraits",
+            "no_identifier": "Add accessibilityIdentifier for testing",
+            "deep_nesting": "Simplify view hierarchy",
+        }
+        return fixes.get(rule, "Review accessibility")
+
+    def audit(self, verbose: bool = False) -> dict[str, Any]:
+        """Perform full accessibility audit."""
+        # Get accessibility tree
+        tree = self.get_accessibility_tree()
+
+        # Flatten for processing
+        elements = self._flatten_tree(tree)
+
+        # Audit each element
+        all_issues = []
+        for element in elements:
+            issues = self.audit_element(element)
+            for issue in issues:
+                issue_dict = issue.to_dict()
+                # Add minimal element info for context
+                issue_dict["element"] = {
+                    "type": element.get("type", "Unknown"),
+                    "label": element.get("AXLabel", "")[:30] if element.get("AXLabel") else None,
+                }
+                all_issues.append(issue_dict)
+
+        # Count by severity
+        critical = len([i for i in all_issues if i["severity"] == "critical"])
+        warning = len([i for i in all_issues if i["severity"] == "warning"])
+        info = len([i for i in all_issues if i["severity"] == "info"])
+
+        # Build result (token-optimized)
+        result = {
+            "summary": {
+                "total": len(elements),
+                "issues": len(all_issues),
+                "critical": critical,
+                "warning": warning,
+                "info": info,
+            }
+        }
+
+        if verbose:
+            # Full details only if requested
+            result["issues"] = all_issues
+        else:
+            # Default: top issues only (token-efficient)
+            result["top_issues"] = self._get_top_issues(all_issues)
+
+        return result
+
+    def _get_top_issues(self, issues: list[dict]) -> list[dict]:
+        """Get top 3 issues grouped by type (token-efficient)."""
+        if not issues:
+            return []
+
+        # Group by rule
+        grouped = {}
+        for issue in issues:
+            rule = issue["rule"]
+            if rule not in grouped:
+                grouped[rule] = {
+                    "severity": issue["severity"],
+                    "rule": rule,
+                    "count": 0,
+                    "fix": issue["fix"],
+                }
+            grouped[rule]["count"] += 1
+
+        # Sort by severity and count
+        severity_order = {"critical": 0, "warning": 1, "info": 2}
+        sorted_issues = sorted(
+            grouped.values(), key=lambda x: (severity_order[x["severity"]], -x["count"])
+        )
+
+        return sorted_issues[:3]
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Audit iOS simulator screen for accessibility issues"
+    )
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+    parser.add_argument("--output", help="Save JSON report to file")
+    parser.add_argument(
+        "--verbose", action="store_true", help="Include all issue details (increases output)"
+    )
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    # Perform audit
+    auditor = AccessibilityAuditor(udid=udid)
+
+    try:
+        result = auditor.audit(verbose=args.verbose)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    # Output results
+    if args.output:
+        # Save to file
+        with open(args.output, "w") as f:
+            json.dump(result, f, indent=2)
+        # Print minimal summary
+        summary = result["summary"]
+        print(f"Audit complete: {summary['issues']} issues ({summary['critical']} critical)")
+        print(f"Report saved to: {args.output}")
+    # Print to stdout (token-optimized by default)
+    elif args.verbose:
+        print(json.dumps(result, indent=2))
+    else:
+        # Ultra-compact output
+        summary = result["summary"]
+        print(f"Elements: {summary['total']}, Issues: {summary['issues']}")
+        print(
+            f"Critical: {summary['critical']}, Warning: {summary['warning']}, Info: {summary['info']}"
+        )
+
+        if result.get("top_issues"):
+            print("\nTop issues:")
+            for issue in result["top_issues"]:
+                print(
+                    f"  [{issue['severity']}] {issue['rule']} ({issue['count']}x) - {issue['fix']}"
+                )
+
+    # Exit with error if critical issues found
+    if result["summary"]["critical"] > 0:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+iOS App Launcher - App Lifecycle Control
+
+Launches, terminates, and manages iOS apps in the simulator.
+Handles deep links and app switching.
+
+Usage: python scripts/app_launcher.py --launch com.example.app
+"""
+
+import argparse
+import contextlib
+import subprocess
+import sys
+import time
+
+from common import build_simctl_command, resolve_udid
+
+
+class AppLauncher:
+    """Controls app lifecycle on iOS simulator."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize app launcher."""
+        self.udid = udid
+
+    def launch(self, bundle_id: str, wait_for_debugger: bool = False) -> tuple[bool, int | None]:
+        """
+        Launch an app.
+
+        Args:
+            bundle_id: App bundle identifier
+            wait_for_debugger: Wait for debugger attachment
+
+        Returns:
+            (success, pid) tuple
+        """
+        cmd = build_simctl_command("launch", self.udid, bundle_id)
+
+        if wait_for_debugger:
+            cmd.insert(3, "--wait-for-debugger")  # Insert after "launch" operation
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            # Parse PID from output if available
+            pid = None
+            if result.stdout:
+                # Output format: "com.example.app: <PID>"
+                parts = result.stdout.strip().split(":")
+                if len(parts) > 1:
+                    with contextlib.suppress(ValueError):
+                        pid = int(parts[1].strip())
+            return (True, pid)
+        except subprocess.CalledProcessError:
+            return (False, None)
+
+    def terminate(self, bundle_id: str) -> bool:
+        """
+        Terminate an app.
+
+        Args:
+            bundle_id: App bundle identifier
+
+        Returns:
+            Success status
+        """
+        cmd = build_simctl_command("terminate", self.udid, bundle_id)
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def install(self, app_path: str) -> bool:
+        """
+        Install an app.
+
+        Args:
+            app_path: Path to .app bundle
+
+        Returns:
+            Success status
+        """
+        cmd = build_simctl_command("install", self.udid, app_path)
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def uninstall(self, bundle_id: str) -> bool:
+        """
+        Uninstall an app.
+
+        Args:
+            bundle_id: App bundle identifier
+
+        Returns:
+            Success status
+        """
+        cmd = build_simctl_command("uninstall", self.udid, bundle_id)
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def open_url(self, url: str) -> bool:
+        """
+        Open URL (for deep linking).
+
+        Args:
+            url: URL to open (http://, myapp://, etc.)
+
+        Returns:
+            Success status
+        """
+        cmd = build_simctl_command("openurl", self.udid, url)
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def list_apps(self) -> list[dict[str, str]]:
+        """
+        List installed apps.
+
+        Returns:
+            List of app info dictionaries
+        """
+        cmd = build_simctl_command("listapps", self.udid)
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            # Parse plist output using plutil to convert to JSON
+            plist_data = result.stdout
+
+            # Use plutil to convert plist to JSON
+            convert_cmd = ["plutil", "-convert", "json", "-o", "-", "-"]
+            convert_result = subprocess.run(
+                convert_cmd, check=False, input=plist_data, capture_output=True, text=True
+            )
+
+            apps = []
+            if convert_result.returncode == 0:
+                import json
+
+                try:
+                    data = json.loads(convert_result.stdout)
+                    for bundle_id, app_info in data.items():
+                        # Skip system internal apps that are hidden
+                        if app_info.get("ApplicationType") == "Hidden":
+                            continue
+
+                        apps.append(
+                            {
+                                "bundle_id": bundle_id,
+                                "name": app_info.get(
+                                    "CFBundleDisplayName", app_info.get("CFBundleName", bundle_id)
+                                ),
+                                "path": app_info.get("Path", ""),
+                                "version": app_info.get("CFBundleVersion", "Unknown"),
+                                "type": app_info.get("ApplicationType", "User"),
+                            }
+                        )
+                except json.JSONDecodeError:
+                    pass
+
+            return apps
+        except subprocess.CalledProcessError:
+            return []
+
+    def get_app_state(self, bundle_id: str) -> str:
+        """
+        Get app state (running, suspended, etc.).
+
+        Args:
+            bundle_id: App bundle identifier
+
+        Returns:
+            State string or 'unknown'
+        """
+        # Check if app is running by trying to get its PID
+        cmd = build_simctl_command("spawn", self.udid, "launchctl", "list")
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            if bundle_id in result.stdout:
+                return "running"
+            return "not running"
+        except subprocess.CalledProcessError:
+            return "unknown"
+
+    def restart_app(self, bundle_id: str, delay: float = 1.0) -> bool:
+        """
+        Restart an app (terminate then launch).
+
+        Args:
+            bundle_id: App bundle identifier
+            delay: Delay between terminate and launch
+
+        Returns:
+            Success status
+        """
+        # Terminate
+        self.terminate(bundle_id)
+        time.sleep(delay)
+
+        # Launch
+        success, _ = self.launch(bundle_id)
+        return success
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Control iOS app lifecycle")
+
+    # Actions
+    parser.add_argument("--launch", help="Launch app by bundle ID")
+    parser.add_argument("--terminate", help="Terminate app by bundle ID")
+    parser.add_argument("--restart", help="Restart app by bundle ID")
+    parser.add_argument("--install", help="Install app from .app path")
+    parser.add_argument("--uninstall", help="Uninstall app by bundle ID")
+    parser.add_argument("--open-url", help="Open URL (deep link)")
+    parser.add_argument("--list", action="store_true", help="List installed apps")
+    parser.add_argument("--state", help="Get app state by bundle ID")
+
+    # Options
+    parser.add_argument(
+        "--wait-for-debugger", action="store_true", help="Wait for debugger when launching"
+    )
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    launcher = AppLauncher(udid=udid)
+
+    # Execute requested action
+    if args.launch:
+        success, pid = launcher.launch(args.launch, args.wait_for_debugger)
+        if success:
+            if pid:
+                print(f"Launched {args.launch} (PID: {pid})")
+            else:
+                print(f"Launched {args.launch}")
+        else:
+            print(f"Failed to launch {args.launch}")
+            sys.exit(1)
+
+    elif args.terminate:
+        if launcher.terminate(args.terminate):
+            print(f"Terminated {args.terminate}")
+        else:
+            print(f"Failed to terminate {args.terminate}")
+            sys.exit(1)
+
+    elif args.restart:
+        if launcher.restart_app(args.restart):
+            print(f"Restarted {args.restart}")
+        else:
+            print(f"Failed to restart {args.restart}")
+            sys.exit(1)
+
+    elif args.install:
+        if launcher.install(args.install):
+            print(f"Installed {args.install}")
+        else:
+            print(f"Failed to install {args.install}")
+            sys.exit(1)
+
+    elif args.uninstall:
+        if launcher.uninstall(args.uninstall):
+            print(f"Uninstalled {args.uninstall}")
+        else:
+            print(f"Failed to uninstall {args.uninstall}")
+            sys.exit(1)
+
+    elif args.open_url:
+        if launcher.open_url(args.open_url):
+            print(f"Opened URL: {args.open_url}")
+        else:
+            print(f"Failed to open URL: {args.open_url}")
+            sys.exit(1)
+
+    elif args.list:
+        apps = launcher.list_apps()
+        if apps:
+            print(f"Installed apps ({len(apps)}):")
+            for app in apps[:10]:  # Limit for token efficiency
+                print(f"  {app['bundle_id']}: {app['name']} (v{app['version']})")
+            if len(apps) > 10:
+                print(f"  ... and {len(apps) - 10} more")
+        else:
+            print("No apps found or failed to list")
+
+    elif args.state:
+        state = launcher.get_app_state(args.state)
+        print(f"{args.state}: {state}")
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+"""
+App State Capture for iOS Simulator
+
+Captures complete app state including screenshot, accessibility tree, and logs.
+Optimized for minimal token output.
+
+Usage: python scripts/app_state_capture.py [options]
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from common import (
+    capture_screenshot,
+    count_elements,
+    get_accessibility_tree,
+    resolve_udid,
+)
+
+
+class AppStateCapture:
+    """Captures comprehensive app state for debugging."""
+
+    def __init__(
+        self,
+        app_bundle_id: str | None = None,
+        udid: str | None = None,
+        inline: bool = False,
+        screenshot_size: str = "half",
+    ):
+        """
+        Initialize state capture.
+
+        Args:
+            app_bundle_id: Optional app bundle ID for log filtering
+            udid: Optional device UDID (uses booted if not specified)
+            inline: If True, return screenshots as base64 (for vision-based automation)
+            screenshot_size: 'full', 'half', 'quarter', 'thumb' (default: 'half')
+        """
+        self.app_bundle_id = app_bundle_id
+        self.udid = udid
+        self.inline = inline
+        self.screenshot_size = screenshot_size
+
+    def capture_screenshot(self, output_path: Path) -> bool:
+        """Capture screenshot of current screen."""
+        cmd = ["xcrun", "simctl", "io"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.extend(["screenshot", str(output_path)])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def capture_accessibility_tree(self, output_path: Path) -> dict:
+        """Capture accessibility tree using shared utility."""
+        try:
+            # Use shared utility to fetch tree
+            tree = get_accessibility_tree(self.udid, nested=True)
+
+            # Save tree
+            with open(output_path, "w") as f:
+                json.dump(tree, f, indent=2)
+
+            # Return summary using shared utility
+            return {"captured": True, "element_count": count_elements(tree)}
+        except Exception as e:
+            return {"captured": False, "error": str(e)}
+
+    def capture_logs(self, output_path: Path, line_limit: int = 100) -> dict:
+        """Capture recent app logs."""
+        if not self.app_bundle_id:
+            # Can't capture logs without app ID
+            return {"captured": False, "reason": "No app bundle ID specified"}
+
+        # Get app name from bundle ID (simplified)
+        app_name = self.app_bundle_id.split(".")[-1]
+
+        cmd = ["xcrun", "simctl", "spawn"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.extend(
+            [
+                "log",
+                "show",
+                "--predicate",
+                f'process == "{app_name}"',
+                "--last",
+                "1m",  # Last 1 minute
+                "--style",
+                "compact",
+            ]
+        )
+
+        try:
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, timeout=5)
+            logs = result.stdout
+
+            # Limit lines for token efficiency
+            lines = logs.split("\n")
+            if len(lines) > line_limit:
+                lines = lines[-line_limit:]
+
+            # Save logs
+            with open(output_path, "w") as f:
+                f.write("\n".join(lines))
+
+            # Analyze for issues
+            warning_count = sum(1 for line in lines if "warning" in line.lower())
+            error_count = sum(1 for line in lines if "error" in line.lower())
+
+            return {
+                "captured": True,
+                "lines": len(lines),
+                "warnings": warning_count,
+                "errors": error_count,
+            }
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
+            return {"captured": False, "error": str(e)}
+
+    def capture_device_info(self) -> dict:
+        """Get device information."""
+        cmd = ["xcrun", "simctl", "list", "devices", "booted"]
+
+        if self.udid:
+            # Specific device info
+            cmd = ["xcrun", "simctl", "list", "devices"]
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            # Parse output for device info (simplified)
+            lines = result.stdout.split("\n")
+            device_info = {}
+
+            for line in lines:
+                if "iPhone" in line or "iPad" in line:
+                    # Extract device name and state
+                    parts = line.strip().split("(")
+                    if parts:
+                        device_info["name"] = parts[0].strip()
+                        if len(parts) > 2:
+                            device_info["udid"] = parts[1].replace(")", "").strip()
+                            device_info["state"] = parts[2].replace(")", "").strip()
+                    break
+
+            return device_info
+        except subprocess.CalledProcessError:
+            return {}
+
+    def capture_all(
+        self, output_dir: str, log_lines: int = 100, app_name: str | None = None
+    ) -> dict:
+        """
+        Capture complete app state.
+
+        Args:
+            output_dir: Directory to save artifacts
+            log_lines: Number of log lines to capture
+            app_name: App name for semantic naming (for inline mode)
+
+        Returns:
+            Summary of captured state
+        """
+        # Create output directory (only if not in inline mode)
+        output_path = Path(output_dir)
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        if not self.inline:
+            capture_dir = output_path / f"app-state-{timestamp}"
+            capture_dir.mkdir(parents=True, exist_ok=True)
+        else:
+            capture_dir = None
+
+        summary = {
+            "timestamp": datetime.now().isoformat(),
+            "screenshot_mode": "inline" if self.inline else "file",
+        }
+
+        if capture_dir:
+            summary["output_dir"] = str(capture_dir)
+
+        # Capture screenshot using new unified utility
+        screenshot_result = capture_screenshot(
+            self.udid,
+            size=self.screenshot_size,
+            inline=self.inline,
+            app_name=app_name,
+        )
+
+        if self.inline:
+            # Inline mode: store base64
+            summary["screenshot"] = {
+                "mode": "inline",
+                "base64": screenshot_result["base64_data"],
+                "width": screenshot_result["width"],
+                "height": screenshot_result["height"],
+                "size_preset": self.screenshot_size,
+            }
+        else:
+            # File mode: save to disk
+            screenshot_path = capture_dir / "screenshot.png"
+            # Move temp file to target location
+            import shutil
+
+            shutil.move(screenshot_result["file_path"], screenshot_path)
+            summary["screenshot"] = {
+                "mode": "file",
+                "file": "screenshot.png",
+                "size_bytes": screenshot_result["size_bytes"],
+            }
+
+        # Capture accessibility tree
+        if not self.inline or capture_dir:
+            accessibility_path = (capture_dir or output_path) / "accessibility-tree.json"
+        else:
+            accessibility_path = None
+
+        if accessibility_path:
+            tree_info = self.capture_accessibility_tree(accessibility_path)
+            summary["accessibility"] = tree_info
+
+        # Capture logs (if app ID provided)
+        if self.app_bundle_id:
+            if not self.inline or capture_dir:
+                logs_path = (capture_dir or output_path) / "app-logs.txt"
+            else:
+                logs_path = None
+
+            if logs_path:
+                log_info = self.capture_logs(logs_path, log_lines)
+                summary["logs"] = log_info
+
+        # Get device info
+        device_info = self.capture_device_info()
+        if device_info:
+            summary["device"] = device_info
+            # Save device info (file mode only)
+            if capture_dir:
+                with open(capture_dir / "device-info.json", "w") as f:
+                    json.dump(device_info, f, indent=2)
+
+        # Save summary (file mode only)
+        if capture_dir:
+            with open(capture_dir / "summary.json", "w") as f:
+                json.dump(summary, f, indent=2)
+
+            # Create markdown summary
+            self._create_summary_md(capture_dir, summary)
+
+        return summary
+
+    def _create_summary_md(self, capture_dir: Path, summary: dict) -> None:
+        """Create markdown summary file."""
+        md_path = capture_dir / "summary.md"
+
+        with open(md_path, "w") as f:
+            f.write("# App State Capture\n\n")
+            f.write(f"**Timestamp:** {summary['timestamp']}\n\n")
+
+            if "device" in summary:
+                f.write("## Device\n")
+                device = summary["device"]
+                f.write(f"- Name: {device.get('name', 'Unknown')}\n")
+                f.write(f"- UDID: {device.get('udid', 'N/A')}\n")
+                f.write(f"- State: {device.get('state', 'Unknown')}\n\n")
+
+            f.write("## Screenshot\n")
+            f.write("![Current Screen](screenshot.png)\n\n")
+
+            if "accessibility" in summary:
+                acc = summary["accessibility"]
+                f.write("## Accessibility\n")
+                if acc.get("captured"):
+                    f.write(f"- Elements: {acc.get('element_count', 0)}\n")
+                else:
+                    f.write(f"- Error: {acc.get('error', 'Unknown')}\n")
+                f.write("\n")
+
+            if "logs" in summary:
+                logs = summary["logs"]
+                f.write("## Logs\n")
+                if logs.get("captured"):
+                    f.write(f"- Lines: {logs.get('lines', 0)}\n")
+                    f.write(f"- Warnings: {logs.get('warnings', 0)}\n")
+                    f.write(f"- Errors: {logs.get('errors', 0)}\n")
+                else:
+                    f.write(f"- {logs.get('reason', logs.get('error', 'Not captured'))}\n")
+                f.write("\n")
+
+            f.write("## Files\n")
+            f.write("- `screenshot.png` - Current screen\n")
+            f.write("- `accessibility-tree.json` - Full UI hierarchy\n")
+            if self.app_bundle_id:
+                f.write("- `app-logs.txt` - Recent app logs\n")
+            f.write("- `device-info.json` - Device details\n")
+            f.write("- `summary.json` - Complete capture metadata\n")
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Capture complete app state for debugging")
+    parser.add_argument(
+        "--app-bundle-id", help="App bundle ID for log filtering (e.g., com.example.app)"
+    )
+    parser.add_argument(
+        "--output", default=".", help="Output directory (default: current directory)"
+    )
+    parser.add_argument(
+        "--log-lines", type=int, default=100, help="Number of log lines to capture (default: 100)"
+    )
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+    parser.add_argument(
+        "--inline",
+        action="store_true",
+        help="Return screenshots as base64 (inline mode for vision-based automation)",
+    )
+    parser.add_argument(
+        "--size",
+        choices=["full", "half", "quarter", "thumb"],
+        default="half",
+        help="Screenshot size for token optimization (default: half)",
+    )
+    parser.add_argument("--app-name", help="App name for semantic screenshot naming")
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    # Create capturer
+    capturer = AppStateCapture(
+        app_bundle_id=args.app_bundle_id,
+        udid=udid,
+        inline=args.inline,
+        screenshot_size=args.size,
+    )
+
+    # Capture state
+    try:
+        summary = capturer.capture_all(
+            output_dir=args.output, log_lines=args.log_lines, app_name=args.app_name
+        )
+
+        # Token-efficient output
+        if "output_dir" in summary:
+            print(f"State captured: {summary['output_dir']}/")
+        else:
+            # Inline mode
+            print(
+                f"State captured (inline mode): {summary['screenshot']['width']}x{summary['screenshot']['height']}"
+            )
+
+        # Report any issues found
+        if "logs" in summary and summary["logs"].get("captured"):
+            logs = summary["logs"]
+            if logs["errors"] > 0 or logs["warnings"] > 0:
+                print(f"Issues found: {logs['errors']} errors, {logs['warnings']} warnings")
+
+        if "accessibility" in summary and summary["accessibility"].get("captured"):
+            print(f"Elements: {summary['accessibility']['element_count']}")
+
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+Build and Test Automation for Xcode Projects
+
+Ultra token-efficient build automation with progressive disclosure via xcresult bundles.
+
+Features:
+- Minimal default output (5-10 tokens)
+- Progressive disclosure for error/warning/log details
+- Native xcresult bundle support
+- Clean modular architecture
+
+Usage Examples:
+    # Build (minimal output)
+    python scripts/build_and_test.py --project MyApp.xcodeproj
+    # Output: Build: SUCCESS (0 errors, 3 warnings) [xcresult-20251018-143052]
+
+    # Get error details
+    python scripts/build_and_test.py --get-errors xcresult-20251018-143052
+
+    # Get warnings
+    python scripts/build_and_test.py --get-warnings xcresult-20251018-143052
+
+    # Get build log
+    python scripts/build_and_test.py --get-log xcresult-20251018-143052
+
+    # Get everything as JSON
+    python scripts/build_and_test.py --get-all xcresult-20251018-143052 --json
+
+    # List recent builds
+    python scripts/build_and_test.py --list-xcresults
+
+    # Verbose mode (for debugging)
+    python scripts/build_and_test.py --project MyApp.xcodeproj --verbose
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+# Import our modular components
+from xcode import BuildRunner, OutputFormatter, XCResultCache, XCResultParser
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Build and test Xcode projects with progressive disclosure",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Build project (minimal output)
+  python scripts/build_and_test.py --project MyApp.xcodeproj
+
+  # Run tests
+  python scripts/build_and_test.py --project MyApp.xcodeproj --test
+
+  # Get error details from previous build
+  python scripts/build_and_test.py --get-errors xcresult-20251018-143052
+
+  # Get all details as JSON
+  python scripts/build_and_test.py --get-all xcresult-20251018-143052 --json
+
+  # List recent builds
+  python scripts/build_and_test.py --list-xcresults
+        """,
+    )
+
+    # Build/test mode arguments
+    build_group = parser.add_argument_group("Build/Test Options")
+    project_group = build_group.add_mutually_exclusive_group()
+    project_group.add_argument("--project", help="Path to .xcodeproj file")
+    project_group.add_argument("--workspace", help="Path to .xcworkspace file")
+
+    build_group.add_argument("--scheme", help="Build scheme (auto-detected if not specified)")
+    build_group.add_argument(
+        "--configuration",
+        default="Debug",
+        choices=["Debug", "Release"],
+        help="Build configuration (default: Debug)",
+    )
+    build_group.add_argument("--simulator", help="Simulator name (default: iPhone 15)")
+    build_group.add_argument("--clean", action="store_true", help="Clean before building")
+    build_group.add_argument("--test", action="store_true", help="Run tests")
+    build_group.add_argument("--suite", help="Specific test suite to run")
+
+    # Progressive disclosure arguments
+    disclosure_group = parser.add_argument_group("Progressive Disclosure Options")
+    disclosure_group.add_argument(
+        "--get-errors", metavar="XCRESULT_ID", help="Get error details from xcresult"
+    )
+    disclosure_group.add_argument(
+        "--get-warnings", metavar="XCRESULT_ID", help="Get warning details from xcresult"
+    )
+    disclosure_group.add_argument(
+        "--get-log", metavar="XCRESULT_ID", help="Get build log from xcresult"
+    )
+    disclosure_group.add_argument(
+        "--get-all", metavar="XCRESULT_ID", help="Get all details from xcresult"
+    )
+    disclosure_group.add_argument(
+        "--list-xcresults", action="store_true", help="List recent xcresult bundles"
+    )
+
+    # Output options
+    output_group = parser.add_argument_group("Output Options")
+    output_group.add_argument("--verbose", action="store_true", help="Show detailed output")
+    output_group.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    # Initialize cache
+    cache = XCResultCache()
+
+    # Handle list mode
+    if args.list_xcresults:
+        xcresults = cache.list()
+        if args.json:
+            import json
+
+            print(json.dumps(xcresults, indent=2))
+        elif not xcresults:
+            print("No xcresult bundles found")
+        else:
+            print(f"Recent XCResult bundles ({len(xcresults)}):")
+            print()
+            for xc in xcresults:
+                print(f"  {xc['id']}")
+                print(f"    Created: {xc['created']}")
+                print(f"    Size: {xc['size_mb']} MB")
+                print()
+        return 0
+
+    # Handle retrieval modes
+    xcresult_id = args.get_errors or args.get_warnings or args.get_log or args.get_all
+
+    if xcresult_id:
+        xcresult_path = cache.get_path(xcresult_id)
+
+        if not xcresult_path or not xcresult_path.exists():
+            print(f"Error: XCResult bundle not found: {xcresult_id}", file=sys.stderr)
+            print("Use --list-xcresults to see available bundles", file=sys.stderr)
+            return 1
+
+        # Load cached stderr for progressive disclosure
+        cached_stderr = cache.get_stderr(xcresult_id)
+        parser = XCResultParser(xcresult_path, stderr=cached_stderr)
+
+        # Get errors
+        if args.get_errors:
+            errors = parser.get_errors()
+            if args.json:
+                import json
+
+                print(json.dumps(errors, indent=2))
+            else:
+                print(OutputFormatter.format_errors(errors))
+            return 0
+
+        # Get warnings
+        if args.get_warnings:
+            warnings = parser.get_warnings()
+            if args.json:
+                import json
+
+                print(json.dumps(warnings, indent=2))
+            else:
+                print(OutputFormatter.format_warnings(warnings))
+            return 0
+
+        # Get log
+        if args.get_log:
+            log = parser.get_build_log()
+            if log:
+                print(OutputFormatter.format_log(log))
+            else:
+                print("No build log available", file=sys.stderr)
+                return 1
+            return 0
+
+        # Get all
+        if args.get_all:
+            error_count, warning_count = parser.count_issues()
+            errors = parser.get_errors()
+            warnings = parser.get_warnings()
+            build_log = parser.get_build_log()
+
+            if args.json:
+                import json
+
+                data = {
+                    "xcresult_id": xcresult_id,
+                    "error_count": error_count,
+                    "warning_count": warning_count,
+                    "errors": errors,
+                    "warnings": warnings,
+                    "log_preview": build_log[:1000] if build_log else None,
+                }
+                print(json.dumps(data, indent=2))
+            else:
+                print(f"XCResult: {xcresult_id}")
+                print(f"Errors: {error_count}, Warnings: {warning_count}")
+                print()
+                if errors:
+                    print(OutputFormatter.format_errors(errors, limit=10))
+                    print()
+                if warnings:
+                    print(OutputFormatter.format_warnings(warnings, limit=10))
+                    print()
+                if build_log:
+                    print("Build Log (last 30 lines):")
+                    print(OutputFormatter.format_log(build_log, lines=30))
+            return 0
+
+    # Build/test mode
+    if not args.project and not args.workspace:
+        # Try to auto-detect in current directory
+        cwd = Path.cwd()
+        projects = list(cwd.glob("*.xcodeproj"))
+        workspaces = list(cwd.glob("*.xcworkspace"))
+
+        if workspaces:
+            args.workspace = str(workspaces[0])
+        elif projects:
+            args.project = str(projects[0])
+        else:
+            parser.error("No project or workspace specified and none found in current directory")
+
+    # Initialize builder
+    builder = BuildRunner(
+        project_path=args.project,
+        workspace_path=args.workspace,
+        scheme=args.scheme,
+        configuration=args.configuration,
+        simulator=args.simulator,
+        cache=cache,
+    )
+
+    # Execute build or test
+    if args.test:
+        success, xcresult_id, stderr = builder.test(test_suite=args.suite)
+    else:
+        success, xcresult_id, stderr = builder.build(clean=args.clean)
+
+    if not xcresult_id and not stderr:
+        print("Error: Build/test failed without creating xcresult or error output", file=sys.stderr)
+        return 1
+
+    # Save stderr to cache for progressive disclosure
+    if xcresult_id and stderr:
+        cache.save_stderr(xcresult_id, stderr)
+
+    # Parse results
+    xcresult_path = cache.get_path(xcresult_id) if xcresult_id else None
+    parser = XCResultParser(xcresult_path, stderr=stderr)
+    error_count, warning_count = parser.count_issues()
+
+    # Format output
+    status = "SUCCESS" if success else "FAILED"
+
+    # Generate hints for failed builds
+    hints = None
+    if not success:
+        errors = parser.get_errors()
+        hints = OutputFormatter.generate_hints(errors)
+
+    if args.verbose:
+        # Verbose mode with error/warning details
+        errors = parser.get_errors() if error_count > 0 else None
+        warnings = parser.get_warnings() if warning_count > 0 else None
+
+        output = OutputFormatter.format_verbose(
+            status=status,
+            error_count=error_count,
+            warning_count=warning_count,
+            xcresult_id=xcresult_id or "N/A",
+            errors=errors,
+            warnings=warnings,
+        )
+        print(output)
+    elif args.json:
+        # JSON mode
+        data = {
+            "success": success,
+            "xcresult_id": xcresult_id or None,
+            "error_count": error_count,
+            "warning_count": warning_count,
+        }
+        if hints:
+            data["hints"] = hints
+        import json
+
+        print(json.dumps(data, indent=2))
+    else:
+        # Minimal mode (default)
+        output = OutputFormatter.format_minimal(
+            status=status,
+            error_count=error_count,
+            warning_count=warning_count,
+            xcresult_id=xcresult_id or "N/A",
+            hints=hints,
+        )
+        print(output)
+
+    # Exit with appropriate code
+    return 0 if success else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+iOS Simulator Clipboard Manager
+
+Copy text to simulator clipboard for testing paste flows.
+Optimized for minimal token output.
+
+Usage: python scripts/clipboard.py --copy "text to copy"
+"""
+
+import argparse
+import subprocess
+import sys
+
+from common import resolve_udid
+
+
+class ClipboardManager:
+    """Manages clipboard operations on iOS simulator."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize clipboard manager.
+
+        Args:
+            udid: Optional device UDID (auto-detects booted simulator if None)
+        """
+        self.udid = udid
+
+    def copy(self, text: str) -> bool:
+        """
+        Copy text to simulator clipboard.
+
+        Args:
+            text: Text to copy to clipboard
+
+        Returns:
+            Success status
+        """
+        cmd = ["xcrun", "simctl", "pbcopy"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.append(text)
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Copy text to iOS simulator clipboard")
+    parser.add_argument("--copy", required=True, help="Text to copy to clipboard")
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+    parser.add_argument("--test-name", help="Test scenario name for tracking")
+    parser.add_argument("--expected", help="Expected behavior after paste")
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    # Create manager and copy text
+    manager = ClipboardManager(udid=udid)
+
+    if manager.copy(args.copy):
+        # Token-efficient output
+        output = f'Copied: "{args.copy}"'
+
+        if args.test_name:
+            output += f" (test: {args.test_name})"
+
+        print(output)
+
+        # Provide usage guidance
+        if args.expected:
+            print(f"Expected: {args.expected}")
+
+        print()
+        print("Next steps:")
+        print("1. Tap text field with: python scripts/navigator.py --find-type TextField --tap")
+        print("2. Paste with: python scripts/keyboard.py --key return")
+        print("   Or use Cmd+V gesture with: python scripts/keyboard.py --key cmd+v")
+
+    else:
+        print("Failed to copy text to clipboard")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,59 @@
+"""
+Common utilities shared across iOS simulator scripts.
+
+This module centralizes genuinely reused code patterns to eliminate duplication
+while respecting Jackson's Law - no over-abstraction, only truly shared logic.
+
+Organization:
+- device_utils: Device detection, command building, coordinate transformation
+- idb_utils: IDB-specific operations (accessibility tree, element manipulation)
+- cache_utils: Progressive disclosure caching for large outputs
+- screenshot_utils: Screenshot capture with file and inline modes
+"""
+
+from .cache_utils import ProgressiveCache, get_cache
+from .device_utils import (
+    build_idb_command,
+    build_simctl_command,
+    get_booted_device_udid,
+    get_device_screen_size,
+    resolve_udid,
+    transform_screenshot_coords,
+)
+from .idb_utils import (
+    count_elements,
+    flatten_tree,
+    get_accessibility_tree,
+    get_screen_size,
+)
+from .screenshot_utils import (
+    capture_screenshot,
+    format_screenshot_result,
+    generate_screenshot_name,
+    get_size_preset,
+    resize_screenshot,
+)
+
+__all__ = [
+    # cache_utils
+    "ProgressiveCache",
+    # device_utils
+    "build_idb_command",
+    "build_simctl_command",
+    # screenshot_utils
+    "capture_screenshot",
+    # idb_utils
+    "count_elements",
+    "flatten_tree",
+    "format_screenshot_result",
+    "generate_screenshot_name",
+    "get_accessibility_tree",
+    "get_booted_device_udid",
+    "get_cache",
+    "get_device_screen_size",
+    "get_screen_size",
+    "get_size_preset",
+    "resize_screenshot",
+    "resolve_udid",
+    "transform_screenshot_coords",
+]
@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+Progressive disclosure cache for large outputs.
+
+Implements cache system to support progressive disclosure pattern:
+- Return concise summary with cache_id for large outputs
+- User retrieves full details on demand via cache_id
+- Reduces token usage by 96% for common queries
+
+Cache directory: ~/.ios-simulator-skill/cache/
+Cache expiration: Configurable per cache type (default 1 hour)
+
+Used by:
+- sim_list.py - Simulator listing progressive disclosure
+- Future: build logs, UI trees, etc.
+"""
+
+import json
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+
+class ProgressiveCache:
+    """Cache for progressive disclosure pattern.
+
+    Stores large outputs with timestamped IDs for on-demand retrieval.
+    Automatically cleans up expired entries.
+    """
+
+    def __init__(self, cache_dir: str | None = None, max_age_hours: int = 1):
+        """Initialize cache system.
+
+        Args:
+            cache_dir: Cache directory path (default: ~/.ios-simulator-skill/cache/)
+            max_age_hours: Max age for cache entries before expiration (default: 1 hour)
+        """
+        if cache_dir is None:
+            cache_dir = str(Path("~/.ios-simulator-skill/cache").expanduser())
+
+        self.cache_dir = Path(cache_dir)
+        self.max_age_hours = max_age_hours
+
+        # Create cache directory if needed
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def save(self, data: dict[str, Any], cache_type: str) -> str:
+        """Save data to cache and return cache_id.
+
+        Args:
+            data: Dictionary data to cache
+            cache_type: Type of cache ('simulator-list', 'build-log', 'ui-tree', etc.)
+
+        Returns:
+            Cache ID like 'sim-20251028-143052' for use in progressive disclosure
+
+        Example:
+            cache_id = cache.save({'devices': [...]}, 'simulator-list')
+            # Returns: 'sim-20251028-143052'
+        """
+        # Generate cache_id with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        cache_prefix = cache_type.split("-")[0]  # e.g., 'sim' from 'simulator-list'
+        cache_id = f"{cache_prefix}-{timestamp}"
+
+        # Save to file
+        cache_file = self.cache_dir / f"{cache_id}.json"
+        with open(cache_file, "w") as f:
+            json.dump(
+                {
+                    "cache_id": cache_id,
+                    "cache_type": cache_type,
+                    "created_at": datetime.now().isoformat(),
+                    "data": data,
+                },
+                f,
+                indent=2,
+            )
+
+        return cache_id
+
+    def get(self, cache_id: str) -> dict[str, Any] | None:
+        """Retrieve data from cache by cache_id.
+
+        Args:
+            cache_id: Cache ID from save() or list_entries()
+
+        Returns:
+            Cached data dictionary, or None if not found/expired
+
+        Example:
+            data = cache.get('sim-20251028-143052')
+            if data:
+                print(f"Found {len(data)} devices")
+        """
+        cache_file = self.cache_dir / f"{cache_id}.json"
+
+        if not cache_file.exists():
+            return None
+
+        # Check if expired
+        if self._is_expired(cache_file):
+            cache_file.unlink()  # Delete expired file
+            return None
+
+        try:
+            with open(cache_file) as f:
+                entry = json.load(f)
+                return entry.get("data")
+        except (OSError, json.JSONDecodeError):
+            return None
+
+    def list_entries(self, cache_type: str | None = None) -> list[dict[str, Any]]:
+        """List available cache entries with metadata.
+
+        Args:
+            cache_type: Filter by type (e.g., 'simulator-list'), or None for all
+
+        Returns:
+            List of cache entries with id, type, created_at, age_seconds
+
+        Example:
+            entries = cache.list_entries('simulator-list')
+            for entry in entries:
+                print(f"{entry['id']} - {entry['age_seconds']}s old")
+        """
+        entries = []
+
+        for cache_file in sorted(self.cache_dir.glob("*.json"), reverse=True):
+            # Check if expired
+            if self._is_expired(cache_file):
+                cache_file.unlink()
+                continue
+
+            try:
+                with open(cache_file) as f:
+                    entry = json.load(f)
+
+                    # Filter by type if specified
+                    if cache_type and entry.get("cache_type") != cache_type:
+                        continue
+
+                    created_at = datetime.fromisoformat(entry.get("created_at", ""))
+                    age_seconds = (datetime.now() - created_at).total_seconds()
+
+                    entries.append(
+                        {
+                            "id": entry.get("cache_id"),
+                            "type": entry.get("cache_type"),
+                            "created_at": entry.get("created_at"),
+                            "age_seconds": int(age_seconds),
+                        }
+                    )
+            except (OSError, json.JSONDecodeError, ValueError):
+                continue
+
+        return entries
+
+    def cleanup(self, max_age_hours: int | None = None) -> int:
+        """Remove expired cache entries.
+
+        Args:
+            max_age_hours: Age threshold (default: uses instance max_age_hours)
+
+        Returns:
+            Number of entries deleted
+
+        Example:
+            deleted = cache.cleanup()
+            print(f"Deleted {deleted} expired cache entries")
+        """
+        if max_age_hours is None:
+            max_age_hours = self.max_age_hours
+
+        deleted = 0
+
+        for cache_file in self.cache_dir.glob("*.json"):
+            if self._is_expired(cache_file, max_age_hours):
+                cache_file.unlink()
+                deleted += 1
+
+        return deleted
+
+    def clear(self, cache_type: str | None = None) -> int:
+        """Clear all cache entries of a type.
+
+        Args:
+            cache_type: Type to clear (e.g., 'simulator-list'), or None to clear all
+
+        Returns:
+            Number of entries deleted
+
+        Example:
+            cleared = cache.clear('simulator-list')
+            print(f"Cleared {cleared} simulator list entries")
+        """
+        deleted = 0
+
+        for cache_file in self.cache_dir.glob("*.json"):
+            if cache_type is None:
+                # Clear all
+                cache_file.unlink()
+                deleted += 1
+            else:
+                # Clear by type
+                try:
+                    with open(cache_file) as f:
+                        entry = json.load(f)
+                        if entry.get("cache_type") == cache_type:
+                            cache_file.unlink()
+                            deleted += 1
+                except (OSError, json.JSONDecodeError):
+                    pass
+
+        return deleted
+
+    def _is_expired(self, cache_file: Path, max_age_hours: int | None = None) -> bool:
+        """Check if cache file is expired.
+
+        Args:
+            cache_file: Path to cache file
+            max_age_hours: Age threshold (default: uses instance max_age_hours)
+
+        Returns:
+            True if file is older than max_age_hours
+        """
+        if max_age_hours is None:
+            max_age_hours = self.max_age_hours
+
+        try:
+            with open(cache_file) as f:
+                entry = json.load(f)
+                created_at = datetime.fromisoformat(entry.get("created_at", ""))
+                age = datetime.now() - created_at
+                return age > timedelta(hours=max_age_hours)
+        except (OSError, json.JSONDecodeError, ValueError):
+            return True
+
+
+# Module-level cache instances (lazy-loaded)
+_cache_instances: dict[str, ProgressiveCache] = {}
+
+
+def get_cache(cache_dir: str | None = None) -> ProgressiveCache:
+    """Get or create global cache instance.
+
+    Args:
+        cache_dir: Custom cache directory (uses default if None)
+
+    Returns:
+        ProgressiveCache instance
+    """
+    # Use cache_dir as key, or 'default' if None
+    key = cache_dir or "default"
+
+    if key not in _cache_instances:
+        _cache_instances[key] = ProgressiveCache(cache_dir)
+
+    return _cache_instances[key]
@@ -0,0 +1,432 @@
+#!/usr/bin/env python3
+"""
+Shared device and simulator utilities.
+
+Common patterns for interacting with simulators via xcrun simctl and IDB.
+Standardizes command building and device targeting to prevent errors.
+
+Follows Jackson's Law - only extracts genuinely reused patterns.
+
+Used by:
+- app_launcher.py (8 call sites) - App lifecycle commands
+- Multiple scripts (15+ locations) - IDB command building
+- navigator.py, gesture.py - Coordinate transformation
+- test_recorder.py, app_state_capture.py - Auto-UDID detection
+"""
+
+import json
+import re
+import subprocess
+
+
+def build_simctl_command(
+    operation: str,
+    udid: str | None = None,
+    *args,
+) -> list[str]:
+    """
+    Build xcrun simctl command with proper device handling.
+
+    Standardizes command building to prevent device targeting bugs.
+    Automatically uses "booted" if no UDID provided.
+
+    Used by:
+    - app_launcher.py: launch, terminate, install, uninstall, openurl, listapps, spawn
+    - Multiple scripts: generic simctl operations
+
+    Args:
+        operation: simctl operation (launch, terminate, install, etc.)
+        udid: Device UDID (uses 'booted' if None)
+        *args: Additional command arguments
+
+    Returns:
+        Complete command list ready for subprocess.run()
+
+    Examples:
+        # Launch app on booted simulator
+        cmd = build_simctl_command("launch", None, "com.app.bundle")
+        # Returns: ["xcrun", "simctl", "launch", "booted", "com.app.bundle"]
+
+        # Launch on specific device
+        cmd = build_simctl_command("launch", "ABC123", "com.app.bundle")
+        # Returns: ["xcrun", "simctl", "launch", "ABC123", "com.app.bundle"]
+
+        # Install app on specific device
+        cmd = build_simctl_command("install", "ABC123", "/path/to/app.app")
+        # Returns: ["xcrun", "simctl", "install", "ABC123", "/path/to/app.app"]
+    """
+    cmd = ["xcrun", "simctl", operation]
+
+    # Add device (booted or specific UDID)
+    cmd.append(udid if udid else "booted")
+
+    # Add remaining arguments
+    cmd.extend(str(arg) for arg in args)
+
+    return cmd
+
+
+def build_idb_command(
+    operation: str,
+    udid: str | None = None,
+    *args,
+) -> list[str]:
+    """
+    Build IDB command with proper device targeting.
+
+    Standardizes IDB command building across all scripts using IDB.
+    Handles device UDID consistently.
+
+    Used by:
+    - navigator.py: ui tap, ui text, ui describe-all
+    - gesture.py: ui swipe, ui tap
+    - keyboard.py: ui key, ui text, ui tap
+    - And more: 15+ locations
+
+    Args:
+        operation: IDB operation path (e.g., "ui tap", "ui text", "ui describe-all")
+        udid: Device UDID (omits --udid flag if None, IDB uses booted by default)
+        *args: Additional command arguments
+
+    Returns:
+        Complete command list ready for subprocess.run()
+
+    Examples:
+        # Tap on booted simulator
+        cmd = build_idb_command("ui tap", None, "200", "400")
+        # Returns: ["idb", "ui", "tap", "200", "400"]
+
+        # Tap on specific device
+        cmd = build_idb_command("ui tap", "ABC123", "200", "400")
+        # Returns: ["idb", "ui", "tap", "200", "400", "--udid", "ABC123"]
+
+        # Get accessibility tree
+        cmd = build_idb_command("ui describe-all", "ABC123", "--json", "--nested")
+        # Returns: ["idb", "ui", "describe-all", "--json", "--nested", "--udid", "ABC123"]
+
+        # Enter text
+        cmd = build_idb_command("ui text", None, "hello world")
+        # Returns: ["idb", "ui", "text", "hello world"]
+    """
+    # Split operation into parts (e.g., "ui tap" -> ["ui", "tap"])
+    cmd = ["idb"] + operation.split()
+
+    # Add arguments
+    cmd.extend(str(arg) for arg in args)
+
+    # Add device targeting if specified (optional for IDB, uses booted by default)
+    if udid:
+        cmd.extend(["--udid", udid])
+
+    return cmd
+
+
+def get_booted_device_udid() -> str | None:
+    """
+    Auto-detect currently booted simulator UDID.
+
+    Queries xcrun simctl for booted devices and returns first match.
+
+    Returns:
+        UDID of booted simulator, or None if no simulator is booted.
+
+    Example:
+        udid = get_booted_device_udid()
+        if udid:
+            print(f"Booted simulator: {udid}")
+        else:
+            print("No simulator is currently booted")
+    """
+    try:
+        result = subprocess.run(
+            ["xcrun", "simctl", "list", "devices", "booted"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        # Parse output to find UDID
+        # Format: "  iPhone 16 Pro (ABC123-DEF456) (Booted)"
+        for line in result.stdout.split("\n"):
+            # Look for UUID pattern in parentheses
+            match = re.search(r"\(([A-F0-9\-]{36})\)", line)
+            if match:
+                return match.group(1)
+
+        return None
+    except subprocess.CalledProcessError:
+        return None
+
+
+def resolve_udid(udid_arg: str | None) -> str:
+    """
+    Resolve device UDID with auto-detection fallback.
+
+    If udid_arg is provided, returns it immediately.
+    If None, attempts to auto-detect booted simulator.
+    Raises error if neither is available.
+
+    Args:
+        udid_arg: Explicit UDID from command line, or None
+
+    Returns:
+        Valid UDID string
+
+    Raises:
+        RuntimeError: If no UDID provided and no booted simulator found
+
+    Example:
+        try:
+            udid = resolve_udid(args.udid)  # args.udid might be None
+            print(f"Using device: {udid}")
+        except RuntimeError as e:
+            print(f"Error: {e}")
+            sys.exit(1)
+    """
+    if udid_arg:
+        return udid_arg
+
+    booted_udid = get_booted_device_udid()
+    if booted_udid:
+        return booted_udid
+
+    raise RuntimeError(
+        "No device UDID provided and no simulator is currently booted.\n"
+        "Boot a simulator or provide --udid explicitly:\n"
+        "  xcrun simctl boot <device-name>\n"
+        "  python scripts/script_name.py --udid <device-udid>"
+    )
+
+
+def get_device_screen_size(udid: str) -> tuple[int, int]:
+    """
+    Get actual screen dimensions for device via accessibility tree.
+
+    Queries IDB accessibility tree to determine actual device resolution.
+    Falls back to iPhone 14 defaults (390x844) if detection fails.
+
+    Args:
+        udid: Device UDID
+
+    Returns:
+        Tuple of (width, height) in pixels
+
+    Example:
+        width, height = get_device_screen_size("ABC123")
+        print(f"Device screen: {width}x{height}")
+    """
+    try:
+        cmd = build_idb_command("ui describe-all", udid, "--json")
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+        # Parse JSON response
+        data = json.loads(result.stdout)
+        tree = data[0] if isinstance(data, list) and len(data) > 0 else data
+
+        # Get frame size from root element
+        if tree and "frame" in tree:
+            frame = tree["frame"]
+            width = int(frame.get("width", 390))
+            height = int(frame.get("height", 844))
+            return (width, height)
+
+        # Fallback
+        return (390, 844)
+    except Exception:
+        # Graceful fallback to iPhone 14 Pro defaults
+        return (390, 844)
+
+
+def resolve_device_identifier(identifier: str) -> str:
+    """
+    Resolve device name or partial UDID to full UDID.
+
+    Supports multiple identifier formats:
+    - Full UDID: "ABC-123-DEF456..." (36 character UUID)
+    - Device name: "iPhone 16 Pro" (matches full name)
+    - Partial match: "iPhone 16" (matches first device containing this string)
+    - Special: "booted" (resolves to currently booted device)
+
+    Args:
+        identifier: Device UDID, name, or special value "booted"
+
+    Returns:
+        Full device UDID
+
+    Raises:
+        RuntimeError: If identifier cannot be resolved
+
+    Example:
+        udid = resolve_device_identifier("iPhone 16 Pro")
+        # Returns: "ABC123DEF456..."
+
+        udid = resolve_device_identifier("booted")
+        # Returns UDID of booted simulator
+    """
+    # Handle "booted" special case
+    if identifier.lower() == "booted":
+        booted = get_booted_device_udid()
+        if booted:
+            return booted
+        raise RuntimeError(
+            "No simulator is currently booted. "
+            "Boot a simulator first: xcrun simctl boot <device-udid>"
+        )
+
+    # Check if already a full UDID (36 character UUID format)
+    if re.match(r"^[A-F0-9\-]{36}$", identifier, re.IGNORECASE):
+        return identifier.upper()
+
+    # Try to match by device name
+    simulators = list_simulators(state=None)
+    exact_matches = [s for s in simulators if s["name"].lower() == identifier.lower()]
+    if exact_matches:
+        return exact_matches[0]["udid"]
+
+    # Try partial match
+    partial_matches = [s for s in simulators if identifier.lower() in s["name"].lower()]
+    if partial_matches:
+        return partial_matches[0]["udid"]
+
+    # No match found
+    raise RuntimeError(
+        f"Device '{identifier}' not found. "
+        f"Use 'xcrun simctl list devices' to see available simulators."
+    )
+
+
+def list_simulators(state: str | None = None) -> list[dict]:
+    """
+    List iOS simulators with optional state filtering.
+
+    Queries xcrun simctl and returns structured list of simulators.
+    Optionally filters by state (available, booted, all).
+
+    Args:
+        state: Optional filter - "available", "booted", or None for all
+
+    Returns:
+        List of simulator dicts with keys:
+        - "name": Device name (e.g., "iPhone 16 Pro")
+        - "udid": Device UDID (36 char UUID)
+        - "state": Device state ("Booted", "Shutdown", "Unavailable")
+        - "runtime": iOS version (e.g., "iOS 18.0", "unavailable")
+        - "type": Device type ("iPhone", "iPad", "Apple Watch", etc.)
+
+    Example:
+        # List all simulators
+        all_sims = list_simulators()
+        print(f"Total simulators: {len(all_sims)}")
+
+        # List only available simulators
+        available = list_simulators(state="available")
+        for sim in available:
+            print(f"{sim['name']} ({sim['state']}) - {sim['udid']}")
+
+        # List only booted simulators
+        booted = list_simulators(state="booted")
+        for sim in booted:
+            print(f"Booted: {sim['name']}")
+    """
+    try:
+        # Query simctl for device list
+        cmd = ["xcrun", "simctl", "list", "devices", "-j"]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+        data = json.loads(result.stdout)
+        simulators = []
+
+        # Parse JSON response
+        # Format: {"devices": {"iOS 18.0": [{...}, {...}], "iOS 17.0": [...], ...}}
+        for ios_version, devices in data.get("devices", {}).items():
+            for device in devices:
+                sim = {
+                    "name": device.get("name", "Unknown"),
+                    "udid": device.get("udid", ""),
+                    "state": device.get("state", "Unknown"),
+                    "runtime": ios_version,
+                    "type": _extract_device_type(device.get("name", "")),
+                }
+                simulators.append(sim)
+
+        # Apply state filtering
+        if state == "booted":
+            return [s for s in simulators if s["state"] == "Booted"]
+        if state == "available":
+            return [s for s in simulators if s["state"] == "Shutdown"]  # Available to boot
+        if state is None:
+            return simulators
+        return [s for s in simulators if s["state"].lower() == state.lower()]
+
+    except (subprocess.CalledProcessError, json.JSONDecodeError, KeyError) as e:
+        raise RuntimeError(f"Failed to list simulators: {e}") from e
+
+
+def _extract_device_type(device_name: str) -> str:
+    """
+    Extract device type from device name.
+
+    Parses device name to determine type (iPhone, iPad, Watch, etc.).
+
+    Args:
+        device_name: Full device name (e.g., "iPhone 16 Pro")
+
+    Returns:
+        Device type string
+
+    Example:
+        _extract_device_type("iPhone 16 Pro")  # Returns "iPhone"
+        _extract_device_type("iPad Air")        # Returns "iPad"
+        _extract_device_type("Apple Watch Series 9") # Returns "Watch"
+    """
+    if "iPhone" in device_name:
+        return "iPhone"
+    if "iPad" in device_name:
+        return "iPad"
+    if "Watch" in device_name or "Apple Watch" in device_name:
+        return "Watch"
+    if "TV" in device_name or "Apple TV" in device_name:
+        return "TV"
+    return "Unknown"
+
+
+def transform_screenshot_coords(
+    x: float,
+    y: float,
+    screenshot_width: int,
+    screenshot_height: int,
+    device_width: int,
+    device_height: int,
+) -> tuple[int, int]:
+    """
+    Transform screenshot coordinates to device coordinates.
+
+    Handles the case where a screenshot was downscaled (e.g., to 'half' size)
+    and needs to be transformed back to actual device pixel coordinates
+    for accurate tapping.
+
+    The transformation is linear:
+    device_x = (screenshot_x / screenshot_width) * device_width
+    device_y = (screenshot_y / screenshot_height) * device_height
+
+    Args:
+        x, y: Coordinates in the screenshot
+        screenshot_width, screenshot_height: Screenshot dimensions (e.g., 195, 422)
+        device_width, device_height: Actual device dimensions (e.g., 390, 844)
+
+    Returns:
+        Tuple of (device_x, device_y) in device pixels
+
+    Example:
+        # Screenshot taken at 'half' size: 195x422 (from 390x844 device)
+        device_x, device_y = transform_screenshot_coords(
+            100, 200,  # Tap point in screenshot
+            195, 422,  # Screenshot dimensions
+            390, 844   # Device dimensions
+        )
+        print(f"Tap at device coords: ({device_x}, {device_y})")
+        # Output: Tap at device coords: (200, 400)
+    """
+    device_x = int((x / screenshot_width) * device_width)
+    device_y = int((y / screenshot_height) * device_height)
+    return (device_x, device_y)
@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+Shared IDB utility functions.
+
+This module provides common IDB operations used across multiple scripts.
+Follows Jackson's Law - only shared code that's truly reused, not speculative.
+
+Used by:
+- navigator.py - Accessibility tree navigation
+- screen_mapper.py - UI element analysis
+- accessibility_audit.py - WCAG compliance checking
+- test_recorder.py - Test documentation
+- app_state_capture.py - State snapshots
+- gesture.py - Touch gesture operations
+"""
+
+import json
+import subprocess
+import sys
+
+
+def get_accessibility_tree(udid: str | None = None, nested: bool = True) -> dict:
+    """
+    Fetch accessibility tree from IDB.
+
+    The accessibility tree represents the complete UI hierarchy of the current
+    screen, with all element properties needed for semantic navigation.
+
+    Args:
+        udid: Device UDID (uses booted simulator if None)
+        nested: Include nested structure (default True). If False, returns flat array.
+
+    Returns:
+        Root element of accessibility tree as dict.
+        Structure: {
+            "type": "Window",
+            "AXLabel": "App Name",
+            "frame": {"x": 0, "y": 0, "width": 390, "height": 844},
+            "children": [...]
+        }
+
+    Raises:
+        SystemExit: If IDB command fails or returns invalid JSON
+
+    Example:
+        tree = get_accessibility_tree("UDID123")
+        # Root is Window element with all children nested
+    """
+    cmd = ["idb", "ui", "describe-all", "--json"]
+    if nested:
+        cmd.append("--nested")
+    if udid:
+        cmd.extend(["--udid", udid])
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        tree_data = json.loads(result.stdout)
+
+        # IDB returns array format, extract first element (root)
+        if isinstance(tree_data, list) and len(tree_data) > 0:
+            return tree_data[0]
+        return tree_data
+    except subprocess.CalledProcessError as e:
+        print(f"Error: Failed to get accessibility tree: {e.stderr}", file=sys.stderr)
+        sys.exit(1)
+    except json.JSONDecodeError:
+        print("Error: Invalid JSON from idb", file=sys.stderr)
+        sys.exit(1)
+
+
+def flatten_tree(node: dict, depth: int = 0, elements: list[dict] | None = None) -> list[dict]:
+    """
+    Flatten nested accessibility tree into list of elements.
+
+    Converts the hierarchical accessibility tree into a flat list where each
+    element includes its depth for context.
+
+    Used by:
+    - navigator.py - Element finding
+    - screen_mapper.py - Element analysis
+    - accessibility_audit.py - Audit scanning
+
+    Args:
+        node: Root node of tree (typically from get_accessibility_tree)
+        depth: Current depth (used internally, start at 0)
+        elements: Accumulator list (used internally, start as None)
+
+    Returns:
+        Flat list of elements, each with "depth" key indicating nesting level.
+        Structure of each element: {
+            "type": "Button",
+            "AXLabel": "Login",
+            "frame": {...},
+            "depth": 2,
+            ...
+        }
+
+    Example:
+        tree = get_accessibility_tree()
+        flat = flatten_tree(tree)
+        for elem in flat:
+            print(f"{'  ' * elem['depth']}{elem.get('type')}: {elem.get('AXLabel')}")
+    """
+    if elements is None:
+        elements = []
+
+    # Add current node with depth tracking
+    node_copy = node.copy()
+    node_copy["depth"] = depth
+    elements.append(node_copy)
+
+    # Process children recursively
+    for child in node.get("children", []):
+        flatten_tree(child, depth + 1, elements)
+
+    return elements
+
+
+def count_elements(node: dict) -> int:
+    """
+    Count total elements in tree (recursive).
+
+    Traverses entire tree counting all elements for reporting purposes.
+
+    Used by:
+    - test_recorder.py - Element counting per step
+    - screen_mapper.py - Summary statistics
+
+    Args:
+        node: Root node of tree
+
+    Returns:
+        Total element count including root and all descendants
+
+    Example:
+        tree = get_accessibility_tree()
+        total = count_elements(tree)
+        print(f"Screen has {total} elements")
+    """
+    count = 1
+    for child in node.get("children", []):
+        count += count_elements(child)
+    return count
+
+
+def get_screen_size(udid: str | None = None) -> tuple[int, int]:
+    """
+    Get screen dimensions from accessibility tree.
+
+    Extracts the screen size from the root element's frame. Useful for
+    gesture calculations and coordinate normalization.
+
+    Used by:
+    - gesture.py - Gesture positioning
+    - Potentially: screenshot positioning, screen-aware scaling
+
+    Args:
+        udid: Device UDID (uses booted if None)
+
+    Returns:
+        (width, height) tuple. Defaults to (390, 844) if detection fails
+        or tree cannot be accessed.
+
+    Example:
+        width, height = get_screen_size()
+        center_x = width // 2
+        center_y = height // 2
+    """
+    DEFAULT_WIDTH = 390  # iPhone 14
+    DEFAULT_HEIGHT = 844
+
+    try:
+        tree = get_accessibility_tree(udid, nested=False)
+        frame = tree.get("frame", {})
+        width = int(frame.get("width", DEFAULT_WIDTH))
+        height = int(frame.get("height", DEFAULT_HEIGHT))
+        return (width, height)
+    except Exception:
+        # Silently fall back to defaults if tree access fails
+        return (DEFAULT_WIDTH, DEFAULT_HEIGHT)
@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+"""
+Screenshot utilities with dual-mode support.
+
+Provides unified screenshot handling with:
+- File-based mode: Persistent artifacts for test documentation
+- Inline base64 mode: Vision-based automation for agent analysis
+- Size presets: Token optimization (full/half/quarter/thumb)
+- Semantic naming: {appName}_{screenName}_{state}_{timestamp}.png
+
+Supports resize operations via PIL (optional dependency).
+
+Used by:
+- test_recorder.py - Step-based screenshot recording
+- app_state_capture.py - State snapshot captures
+"""
+
+import base64
+import os
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+# Try to import PIL for resizing, but make it optional
+try:
+    from PIL import Image
+
+    HAS_PIL = True
+except ImportError:
+    HAS_PIL = False
+
+
+def generate_screenshot_name(
+    app_name: str | None = None,
+    screen_name: str | None = None,
+    state: str | None = None,
+    timestamp: str | None = None,
+    extension: str = "png",
+) -> str:
+    """Generate semantic screenshot filename.
+
+    Format: {appName}_{screenName}_{state}_{timestamp}.{ext}
+    Falls back to: screenshot_{timestamp}.{ext}
+
+    Args:
+        app_name: Application name (e.g., 'MyApp')
+        screen_name: Screen name (e.g., 'Login')
+        state: State description (e.g., 'Empty', 'Filled', 'Error')
+        timestamp: ISO timestamp (uses current time if None)
+        extension: File extension (default: 'png')
+
+    Returns:
+        Semantic filename ready for safe file creation
+
+    Example:
+        name = generate_screenshot_name('MyApp', 'Login', 'Empty')
+        # Returns: 'MyApp_Login_Empty_20251028-143052.png'
+
+        name = generate_screenshot_name()
+        # Returns: 'screenshot_20251028-143052.png'
+    """
+    if timestamp is None:
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+
+    # Build semantic name
+    if app_name or screen_name or state:
+        parts = [app_name, screen_name, state]
+        parts = [p for p in parts if p]  # Filter None/empty
+        name = "_".join(parts) + f"_{timestamp}"
+    else:
+        name = f"screenshot_{timestamp}"
+
+    return f"{name}.{extension}"
+
+
+def get_size_preset(size: str = "half") -> tuple[float, float]:
+    """Get scale factors for size preset.
+
+    Args:
+        size: 'full', 'half', 'quarter', 'thumb'
+
+    Returns:
+        Tuple of (scale_x, scale_y) for resizing
+
+    Example:
+        scale_x, scale_y = get_size_preset('half')
+        # Returns: (0.5, 0.5)
+    """
+    presets = {
+        "full": (1.0, 1.0),
+        "half": (0.5, 0.5),
+        "quarter": (0.25, 0.25),
+        "thumb": (0.1, 0.1),
+    }
+    return presets.get(size, (0.5, 0.5))
+
+
+def resize_screenshot(
+    input_path: str,
+    output_path: str | None = None,
+    size: str = "half",
+    quality: int = 85,
+) -> tuple[str, int, int]:
+    """Resize screenshot for token optimization.
+
+    Requires PIL (Pillow). Falls back gracefully without it.
+
+    Args:
+        input_path: Path to original screenshot
+        output_path: Output path (uses input_path if None)
+        size: 'full', 'half', 'quarter', 'thumb'
+        quality: JPEG quality (1-100, default: 85)
+
+    Returns:
+        Tuple of (output_path, width, height) of resized image
+
+    Raises:
+        FileNotFoundError: If input file doesn't exist
+        ValueError: If PIL not installed and size != 'full'
+
+    Example:
+        output, w, h = resize_screenshot(
+            'screenshot.png',
+            'screenshot_half.png',
+            'half'
+        )
+        print(f"Resized to {w}x{h}")
+    """
+    input_file = Path(input_path)
+    if not input_file.exists():
+        raise FileNotFoundError(f"Screenshot not found: {input_path}")
+
+    # If full size, just copy
+    if size == "full":
+        if output_path:
+            import shutil
+
+            shutil.copy(input_path, output_path)
+            output_file = Path(output_path)
+        else:
+            output_file = input_file
+
+        # Get original dimensions
+        if HAS_PIL:
+            img = Image.open(str(output_file))
+            return (str(output_file), img.width, img.height)
+        return (str(output_file), 0, 0)  # Dimensions unknown without PIL
+
+    # Need PIL to resize
+    if not HAS_PIL:
+        raise ValueError(
+            f"Size preset '{size}' requires PIL (Pillow). " "Install with: pip3 install pillow"
+        )
+
+    # Open original image
+    img = Image.open(str(input_file))
+    orig_w, orig_h = img.size
+
+    # Calculate new size
+    scale_x, scale_y = get_size_preset(size)
+    new_w = int(orig_w * scale_x)
+    new_h = int(orig_h * scale_y)
+
+    # Resize with high-quality resampling
+    resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+
+    # Determine output path
+    if output_path is None:
+        # Insert size marker before extension
+        stem = input_file.stem
+        suffix = input_file.suffix
+        output_path = str(input_file.parent / f"{stem}_{size}{suffix}")
+
+    # Save resized image
+    resized.save(output_path, quality=quality, optimize=True)
+
+    return (output_path, new_w, new_h)
+
+
+def capture_screenshot(
+    udid: str,
+    output_path: str | None = None,
+    size: str = "half",
+    inline: bool = False,
+    app_name: str | None = None,
+    screen_name: str | None = None,
+    state: str | None = None,
+) -> dict[str, Any]:
+    """Capture screenshot with flexible output modes.
+
+    Supports both file-based (persistent artifacts) and inline base64 modes
+    (for vision-based automation).
+
+    Args:
+        udid: Device UDID
+        output_path: File path for file mode (generates semantic name if None)
+        size: 'full', 'half', 'quarter', 'thumb' (default: 'half')
+        inline: If True, returns base64 data instead of saving to file
+        app_name: App name for semantic naming
+        screen_name: Screen name for semantic naming
+        state: State description for semantic naming
+
+    Returns:
+        Dict with mode-specific fields:
+
+        File mode:
+        {
+            'mode': 'file',
+            'file_path': str,
+            'size_bytes': int,
+            'width': int,
+            'height': int,
+            'size_preset': str
+        }
+
+        Inline mode:
+        {
+            'mode': 'inline',
+            'base64_data': str,
+            'mime_type': 'image/png',
+            'width': int,
+            'height': int,
+            'size_preset': str
+        }
+
+    Example:
+        # File mode
+        result = capture_screenshot('ABC123', app_name='MyApp')
+        print(f"Saved to: {result['file_path']}")
+
+        # Inline mode
+        result = capture_screenshot('ABC123', inline=True, size='half')
+        print(f"Screenshot: {result['width']}x{result['height']}")
+        print(f"Base64: {result['base64_data'][:50]}...")
+    """
+    try:
+        # Capture raw screenshot to temp file
+        temp_path = "/tmp/ios_simulator_screenshot.png"
+        cmd = ["xcrun", "simctl", "io", udid, "screenshot", temp_path]
+
+        subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+        if inline:
+            # Inline mode: resize and convert to base64
+            # Resize if needed
+            if size != "full" and HAS_PIL:
+                resized_path, width, height = resize_screenshot(temp_path, size=size)
+            else:
+                resized_path = temp_path
+                # Get dimensions via PIL if available
+                if HAS_PIL:
+                    img = Image.open(resized_path)
+                    width, height = img.size
+                else:
+                    width, height = 390, 844  # Fallback to common device size
+
+            # Read and encode as base64
+            with open(resized_path, "rb") as f:
+                base64_data = base64.b64encode(f.read()).decode("utf-8")
+
+            # Clean up temp files
+            Path(temp_path).unlink(missing_ok=True)
+            if resized_path != temp_path:
+                Path(resized_path).unlink(missing_ok=True)
+
+            return {
+                "mode": "inline",
+                "base64_data": base64_data,
+                "mime_type": "image/png",
+                "width": width,
+                "height": height,
+                "size_preset": size,
+            }
+
+        # File mode: save to output path with semantic naming
+        if output_path is None:
+            output_path = generate_screenshot_name(app_name, screen_name, state)
+
+        # Resize if needed
+        if size != "full" and HAS_PIL:
+            final_path, width, height = resize_screenshot(temp_path, output_path, size)
+        else:
+            # Just move temp to output
+            import shutil
+
+            shutil.move(temp_path, output_path)
+            final_path = output_path
+
+            # Get dimensions via PIL if available
+            if HAS_PIL:
+                img = Image.open(final_path)
+                width, height = img.size
+            else:
+                width, height = 390, 844  # Fallback
+
+        # Get file size
+        size_bytes = Path(final_path).stat().st_size
+
+        return {
+            "mode": "file",
+            "file_path": final_path,
+            "size_bytes": size_bytes,
+            "width": width,
+            "height": height,
+            "size_preset": size,
+        }
+
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to capture screenshot: {e.stderr}") from e
+    except Exception as e:
+        raise RuntimeError(f"Screenshot capture error: {e!s}") from e
+
+
+def format_screenshot_result(result: dict[str, Any]) -> str:
+    """Format screenshot result for human-readable output.
+
+    Args:
+        result: Result dictionary from capture_screenshot()
+
+    Returns:
+        Formatted string for printing
+
+    Example:
+        result = capture_screenshot('ABC123', inline=True)
+        print(format_screenshot_result(result))
+    """
+    if result["mode"] == "file":
+        return (
+            f"Screenshot: {result['file_path']}\n"
+            f"Dimensions: {result['width']}x{result['height']}\n"
+            f"Size: {result['size_bytes']} bytes"
+        )
+    return (
+        f"Screenshot (inline): {result['width']}x{result['height']}\n"
+        f"Base64 length: {len(result['base64_data'])} chars"
+    )
@@ -0,0 +1,394 @@
+#!/usr/bin/env python3
+"""
+iOS Gesture Controller - Swipes and Complex Gestures
+
+Performs navigation gestures like swipes, scrolls, and pinches.
+Token-efficient output for common navigation patterns.
+
+This script handles touch gestures for iOS simulator automation. It provides
+directional swipes, multi-swipe scrolling, pull-to-refresh, and pinch gestures.
+Automatically detects screen size from the device for accurate gesture positioning.
+
+Key Features:
+- Directional swipes (up, down, left, right)
+- Multi-swipe scrolling with customizable amount
+- Pull-to-refresh gesture
+- Pinch to zoom (in/out)
+- Custom swipe between any two points
+- Drag and drop simulation
+- Auto-detects screen dimensions from device
+
+Usage Examples:
+    # Simple directional swipe
+    python scripts/gesture.py --swipe up --udid <device-id>
+
+    # Scroll down multiple times
+    python scripts/gesture.py --scroll down --scroll-amount 3 --udid <device-id>
+
+    # Pull to refresh
+    python scripts/gesture.py --refresh --udid <device-id>
+
+    # Custom swipe coordinates
+    python scripts/gesture.py --swipe-from 100,500 --swipe-to 100,100 --udid <device-id>
+
+    # Pinch to zoom
+    python scripts/gesture.py --pinch out --udid <device-id>
+
+    # Long press at coordinates
+    python scripts/gesture.py --long-press 200,300 --duration 2.0 --udid <device-id>
+
+Output Format:
+    Swiped up
+    Scrolled down (3x)
+    Performed pull to refresh
+
+Gesture Details:
+- Swipes use 70% of screen by default (configurable)
+- Scrolls are multiple small 30% swipes with delays
+- Start points are offset from edges for reliability
+- Screen size auto-detected from accessibility tree root element
+- Falls back to iPhone 14 dimensions (390x844) if detection fails
+
+Technical Details:
+- Uses `idb ui swipe x1 y1 x2 y2` for gesture execution
+- Duration parameter converts to milliseconds for IDB
+- Automatically fetches screen size on initialization
+- Parses IDB accessibility tree to get root frame dimensions
+- All coordinates calculated as fractions of screen size for device independence
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+
+from common import (
+    get_device_screen_size,
+    get_screen_size,
+    resolve_udid,
+    transform_screenshot_coords,
+)
+
+
+class GestureController:
+    """Performs gestures on iOS simulator."""
+
+    # Standard screen dimensions (will be detected if possible)
+    DEFAULT_WIDTH = 390  # iPhone 14
+    DEFAULT_HEIGHT = 844
+
+    def __init__(self, udid: str | None = None):
+        """Initialize gesture controller."""
+        self.udid = udid
+        self.screen_size = self._get_screen_size()
+
+    def _get_screen_size(self) -> tuple[int, int]:
+        """Try to detect screen size from device using shared utility."""
+        return get_screen_size(self.udid)
+
+    def swipe(self, direction: str, distance_ratio: float = 0.7) -> bool:
+        """
+        Perform directional swipe.
+
+        Args:
+            direction: up, down, left, right
+            distance_ratio: How far to swipe (0.0-1.0 of screen)
+
+        Returns:
+            Success status
+        """
+        width, height = self.screen_size
+        center_x = width // 2
+        center_y = height // 2
+
+        # Calculate swipe coordinates based on direction
+        if direction == "up":
+            start = (center_x, int(height * 0.7))
+            end = (center_x, int(height * (1 - distance_ratio + 0.3)))
+        elif direction == "down":
+            start = (center_x, int(height * 0.3))
+            end = (center_x, int(height * (distance_ratio - 0.3 + 0.3)))
+        elif direction == "left":
+            start = (int(width * 0.8), center_y)
+            end = (int(width * (1 - distance_ratio + 0.2)), center_y)
+        elif direction == "right":
+            start = (int(width * 0.2), center_y)
+            end = (int(width * (distance_ratio - 0.2 + 0.2)), center_y)
+        else:
+            return False
+
+        return self.swipe_between(start, end)
+
+    def swipe_between(
+        self, start: tuple[int, int], end: tuple[int, int], duration: float = 0.3
+    ) -> bool:
+        """
+        Swipe between two points.
+
+        Args:
+            start: Starting coordinates (x, y)
+            end: Ending coordinates (x, y)
+            duration: Swipe duration in seconds
+
+        Returns:
+            Success status
+        """
+        cmd = ["idb", "ui", "swipe"]
+        cmd.extend([str(start[0]), str(start[1]), str(end[0]), str(end[1])])
+
+        # IDB doesn't support duration directly, but we can add delay
+        if duration != 0.3:
+            cmd.extend(["--duration", str(int(duration * 1000))])
+
+        if self.udid:
+            cmd.extend(["--udid", self.udid])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def scroll(self, direction: str, amount: int = 3) -> bool:
+        """
+        Perform multiple small swipes to scroll.
+
+        Args:
+            direction: up, down
+            amount: Number of small swipes
+
+        Returns:
+            Success status
+        """
+        for _ in range(amount):
+            if not self.swipe(direction, distance_ratio=0.3):
+                return False
+            time.sleep(0.2)  # Small delay between swipes
+        return True
+
+    def tap_and_hold(self, x: int, y: int, duration: float = 2.0) -> bool:
+        """
+        Long press at coordinates.
+
+        Args:
+            x, y: Coordinates
+            duration: Hold duration in seconds
+
+        Returns:
+            Success status
+        """
+        # IDB doesn't have native long press, simulate with tap
+        # In real implementation, might need to use different approach
+        cmd = ["idb", "ui", "tap", str(x), str(y)]
+
+        if self.udid:
+            cmd.extend(["--udid", self.udid])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            # Simulate hold with delay
+            time.sleep(duration)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def pinch(self, direction: str = "out", center: tuple[int, int] | None = None) -> bool:
+        """
+        Perform pinch gesture (zoom in/out).
+
+        Args:
+            direction: 'in' (zoom out) or 'out' (zoom in)
+            center: Center point for pinch
+
+        Returns:
+            Success status
+        """
+        if not center:
+            width, height = self.screen_size
+            center = (width // 2, height // 2)
+
+        # Calculate pinch points
+        offset = 100 if direction == "out" else 50
+
+        if direction == "out":
+            # Zoom in - fingers move apart
+            start1 = (center[0] - 20, center[1] - 20)
+            end1 = (center[0] - offset, center[1] - offset)
+            start2 = (center[0] + 20, center[1] + 20)
+            end2 = (center[0] + offset, center[1] + offset)
+        else:
+            # Zoom out - fingers move together
+            start1 = (center[0] - offset, center[1] - offset)
+            end1 = (center[0] - 20, center[1] - 20)
+            start2 = (center[0] + offset, center[1] + offset)
+            end2 = (center[0] + 20, center[1] + 20)
+
+        # Perform two swipes simultaneously (simulated)
+        success1 = self.swipe_between(start1, end1)
+        success2 = self.swipe_between(start2, end2)
+
+        return success1 and success2
+
+    def drag_and_drop(self, start: tuple[int, int], end: tuple[int, int]) -> bool:
+        """
+        Drag element from one position to another.
+
+        Args:
+            start: Starting coordinates
+            end: Ending coordinates
+
+        Returns:
+            Success status
+        """
+        # Use slow swipe to simulate drag
+        return self.swipe_between(start, end, duration=1.0)
+
+    def refresh(self) -> bool:
+        """Pull to refresh gesture."""
+        width, _ = self.screen_size
+        start = (width // 2, 100)
+        end = (width // 2, 400)
+        return self.swipe_between(start, end)
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Perform gestures on iOS simulator")
+
+    # Gesture options
+    parser.add_argument(
+        "--swipe", choices=["up", "down", "left", "right"], help="Perform directional swipe"
+    )
+    parser.add_argument("--swipe-from", help="Custom swipe start coordinates (x,y)")
+    parser.add_argument("--swipe-to", help="Custom swipe end coordinates (x,y)")
+    parser.add_argument(
+        "--scroll", choices=["up", "down"], help="Scroll in direction (multiple small swipes)"
+    )
+    parser.add_argument(
+        "--scroll-amount", type=int, default=3, help="Number of scroll swipes (default: 3)"
+    )
+    parser.add_argument("--long-press", help="Long press at coordinates (x,y)")
+    parser.add_argument(
+        "--duration", type=float, default=2.0, help="Duration for long press in seconds"
+    )
+    parser.add_argument(
+        "--pinch", choices=["in", "out"], help="Pinch gesture (in=zoom out, out=zoom in)"
+    )
+    parser.add_argument("--refresh", action="store_true", help="Pull to refresh gesture")
+
+    # Coordinate transformation
+    parser.add_argument(
+        "--screenshot-coords",
+        action="store_true",
+        help="Interpret swipe coordinates as from a screenshot (requires --screenshot-width/height)",
+    )
+    parser.add_argument(
+        "--screenshot-width",
+        type=int,
+        help="Screenshot width for coordinate transformation",
+    )
+    parser.add_argument(
+        "--screenshot-height",
+        type=int,
+        help="Screenshot height for coordinate transformation",
+    )
+
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    controller = GestureController(udid=udid)
+
+    # Execute requested gesture
+    if args.swipe:
+        if controller.swipe(args.swipe):
+            print(f"Swiped {args.swipe}")
+        else:
+            print(f"Failed to swipe {args.swipe}")
+            sys.exit(1)
+
+    elif args.swipe_from and args.swipe_to:
+        # Custom swipe
+        start = tuple(map(int, args.swipe_from.split(",")))
+        end = tuple(map(int, args.swipe_to.split(",")))
+
+        # Handle coordinate transformation if requested
+        if args.screenshot_coords:
+            if not args.screenshot_width or not args.screenshot_height:
+                print(
+                    "Error: --screenshot-coords requires --screenshot-width and --screenshot-height"
+                )
+                sys.exit(1)
+
+            device_w, device_h = get_device_screen_size(udid)
+            start = transform_screenshot_coords(
+                start[0],
+                start[1],
+                args.screenshot_width,
+                args.screenshot_height,
+                device_w,
+                device_h,
+            )
+            end = transform_screenshot_coords(
+                end[0],
+                end[1],
+                args.screenshot_width,
+                args.screenshot_height,
+                device_w,
+                device_h,
+            )
+            print("Transformed screenshot coords to device coords")
+
+        if controller.swipe_between(start, end):
+            print(f"Swiped from {start} to {end}")
+        else:
+            print("Failed to swipe")
+            sys.exit(1)
+
+    elif args.scroll:
+        if controller.scroll(args.scroll, args.scroll_amount):
+            print(f"Scrolled {args.scroll} ({args.scroll_amount}x)")
+        else:
+            print(f"Failed to scroll {args.scroll}")
+            sys.exit(1)
+
+    elif args.long_press:
+        coords = tuple(map(int, args.long_press.split(",")))
+        if controller.tap_and_hold(coords[0], coords[1], args.duration):
+            print(f"Long pressed at {coords} for {args.duration}s")
+        else:
+            print("Failed to long press")
+            sys.exit(1)
+
+    elif args.pinch:
+        if controller.pinch(args.pinch):
+            action = "Zoomed in" if args.pinch == "out" else "Zoomed out"
+            print(action)
+        else:
+            print(f"Failed to pinch {args.pinch}")
+            sys.exit(1)
+
+    elif args.refresh:
+        if controller.refresh():
+            print("Performed pull to refresh")
+        else:
+            print("Failed to refresh")
+            sys.exit(1)
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+"""
+iOS Keyboard Controller - Text Entry and Hardware Buttons
+
+Handles keyboard input, special keys, and hardware button simulation.
+Token-efficient text entry and navigation control.
+
+This script provides text input and hardware button control for iOS simulator
+automation. It handles both typing text strings and pressing special keys like
+return, delete, tab, etc. Also controls hardware buttons like home and lock.
+
+Key Features:
+- Type text strings into focused elements
+- Press special keys (return, delete, tab, space, arrows)
+- Hardware button simulation (home, lock, volume, screenshot)
+- Character-by-character typing with delays (for animations)
+- Multiple key press support
+- iOS HID key code mapping for reliability
+
+Usage Examples:
+    # Type text into focused field
+    python scripts/keyboard.py --type "hello@example.com" --udid <device-id>
+
+    # Press return key to submit
+    python scripts/keyboard.py --key return --udid <device-id>
+
+    # Press delete 3 times
+    python scripts/keyboard.py --key delete --key delete --key delete --udid <device-id>
+
+    # Press home button
+    python scripts/keyboard.py --button home --udid <device-id>
+
+    # Press lock button
+    python scripts/keyboard.py --button lock --udid <device-id>
+
+    # Type with delay between characters (for animations)
+    python scripts/keyboard.py --type "slow typing" --delay 0.1 --udid <device-id>
+
+Output Format:
+    Typed: "hello@example.com"
+    Pressed return
+    Pressed home button
+
+Special Keys Supported:
+- return/enter: Submit forms, new lines (HID code 40)
+- delete/backspace: Remove characters (HID code 42)
+- tab: Navigate between fields (HID code 43)
+- space: Space character (HID code 44)
+- escape: Cancel/dismiss (HID code 41)
+- up/down/left/right: Arrow keys (HID codes 82/81/80/79)
+
+Hardware Buttons Supported:
+- home: Return to home screen
+- lock/power: Lock device
+- volume-up/volume-down: Volume control
+- ringer: Toggle mute
+- screenshot: Capture screen
+
+Technical Details:
+- Uses `idb ui text` for typing text strings
+- Uses `idb ui key <code>` for special keys with iOS HID codes
+- HID codes from Apple's UIKeyboardHIDUsage specification
+- Hardware buttons use `xcrun simctl` button actions
+- Text entry works on currently focused element
+- Special keys are integers (40=Return, 42=Delete, etc.)
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+
+from common import resolve_udid
+
+
+class KeyboardController:
+    """Controls keyboard and hardware buttons on iOS simulator."""
+
+    # Special key mappings to iOS HID key codes
+    # See: https://developer.apple.com/documentation/uikit/uikeyboardhidusage
+    SPECIAL_KEYS = {
+        "return": 40,
+        "enter": 40,
+        "delete": 42,
+        "backspace": 42,
+        "tab": 43,
+        "space": 44,
+        "escape": 41,
+        "up": 82,
+        "down": 81,
+        "left": 80,
+        "right": 79,
+    }
+
+    # Hardware button mappings
+    HARDWARE_BUTTONS = {
+        "home": "HOME",
+        "lock": "LOCK",
+        "volume-up": "VOLUME_UP",
+        "volume-down": "VOLUME_DOWN",
+        "ringer": "RINGER",
+        "power": "LOCK",  # Alias
+        "screenshot": "SCREENSHOT",
+    }
+
+    def __init__(self, udid: str | None = None):
+        """Initialize keyboard controller."""
+        self.udid = udid
+
+    def type_text(self, text: str, delay: float = 0.0) -> bool:
+        """
+        Type text into current focus.
+
+        Args:
+            text: Text to type
+            delay: Delay between characters (for slow typing effect)
+
+        Returns:
+            Success status
+        """
+        if delay > 0:
+            # Type character by character with delay
+            for char in text:
+                if not self._type_single(char):
+                    return False
+                time.sleep(delay)
+            return True
+        # Type all at once (efficient)
+        return self._type_single(text)
+
+    def _type_single(self, text: str) -> bool:
+        """Type text using IDB."""
+        cmd = ["idb", "ui", "text", text]
+        if self.udid:
+            cmd.extend(["--udid", self.udid])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def press_key(self, key: str, count: int = 1) -> bool:
+        """
+        Press a special key.
+
+        Args:
+            key: Key name (return, delete, tab, etc.)
+            count: Number of times to press
+
+        Returns:
+            Success status
+        """
+        # Map key name to IDB key code
+        key_code = self.SPECIAL_KEYS.get(key.lower())
+        if not key_code:
+            # Try as literal integer key code
+            try:
+                key_code = int(key)
+            except ValueError:
+                return False
+
+        cmd = ["idb", "ui", "key", str(key_code)]
+        if self.udid:
+            cmd.extend(["--udid", self.udid])
+
+        try:
+            for _ in range(count):
+                subprocess.run(cmd, capture_output=True, check=True)
+                if count > 1:
+                    time.sleep(0.1)  # Small delay for multiple presses
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def press_key_sequence(self, keys: list[str]) -> bool:
+        """
+        Press a sequence of keys.
+
+        Args:
+            keys: List of key names
+
+        Returns:
+            Success status
+        """
+        cmd_base = ["idb", "ui", "key-sequence"]
+
+        # Map keys to codes
+        mapped_keys = []
+        for key in keys:
+            mapped = self.SPECIAL_KEYS.get(key.lower())
+            if mapped is None:
+                # Try as integer
+                try:
+                    mapped = int(key)
+                except ValueError:
+                    return False
+            mapped_keys.append(str(mapped))
+
+        cmd = cmd_base + mapped_keys
+
+        if self.udid:
+            cmd.extend(["--udid", self.udid])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def press_hardware_button(self, button: str) -> bool:
+        """
+        Press hardware button.
+
+        Args:
+            button: Button name (home, lock, volume-up, etc.)
+
+        Returns:
+            Success status
+        """
+        button_code = self.HARDWARE_BUTTONS.get(button.lower())
+        if not button_code:
+            return False
+
+        cmd = ["idb", "ui", "button", button_code]
+        if self.udid:
+            cmd.extend(["--udid", self.udid])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def clear_text(self, select_all: bool = True) -> bool:
+        """
+        Clear text in current field.
+
+        Args:
+            select_all: Use Cmd+A to select all first
+
+        Returns:
+            Success status
+        """
+        if select_all:
+            # Select all then delete
+            # Note: This might need adjustment for iOS keyboard shortcuts
+            success = self.press_key_combo(["cmd", "a"])
+            if success:
+                return self.press_key("delete")
+        else:
+            # Just delete multiple times
+            return self.press_key("delete", count=50)
+        return None
+
+    def press_key_combo(self, keys: list[str]) -> bool:
+        """
+        Press key combination (like Cmd+A).
+
+        Args:
+            keys: List of keys to press together
+
+        Returns:
+            Success status
+        """
+        # IDB doesn't directly support key combos
+        # This is a workaround - may need platform-specific handling
+        if "cmd" in keys or "command" in keys:
+            # Handle common shortcuts
+            if "a" in keys:
+                # Select all - might work with key sequence
+                return self.press_key_sequence(["command", "a"])
+            if "c" in keys:
+                return self.press_key_sequence(["command", "c"])
+            if "v" in keys:
+                return self.press_key_sequence(["command", "v"])
+            if "x" in keys:
+                return self.press_key_sequence(["command", "x"])
+
+        # Try as sequence
+        return self.press_key_sequence(keys)
+
+    def dismiss_keyboard(self) -> bool:
+        """Dismiss on-screen keyboard."""
+        # Common ways to dismiss keyboard on iOS
+        # Try Done button first, then Return
+        success = self.press_key("return")
+        if not success:
+            # Try tapping outside (would need coordinate)
+            pass
+        return success
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Control keyboard and hardware buttons")
+
+    # Text input
+    parser.add_argument("--type", help="Type text into current focus")
+    parser.add_argument("--slow", action="store_true", help="Type slowly (character by character)")
+
+    # Special keys
+    parser.add_argument("--key", help="Press special key (return, delete, tab, space, etc.)")
+    parser.add_argument("--key-sequence", help="Press key sequence (comma-separated)")
+    parser.add_argument("--count", type=int, default=1, help="Number of times to press key")
+
+    # Hardware buttons
+    parser.add_argument(
+        "--button",
+        choices=["home", "lock", "volume-up", "volume-down", "ringer", "screenshot"],
+        help="Press hardware button",
+    )
+
+    # Other operations
+    parser.add_argument("--clear", action="store_true", help="Clear current text field")
+    parser.add_argument("--dismiss", action="store_true", help="Dismiss keyboard")
+
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    controller = KeyboardController(udid=udid)
+
+    # Execute requested action
+    if args.type:
+        delay = 0.1 if args.slow else 0.0
+        if controller.type_text(args.type, delay):
+            if args.slow:
+                print(f'Typed: "{args.type}" (slowly)')
+            else:
+                print(f'Typed: "{args.type}"')
+        else:
+            print("Failed to type text")
+            sys.exit(1)
+
+    elif args.key:
+        if controller.press_key(args.key, args.count):
+            if args.count > 1:
+                print(f"Pressed {args.key} ({args.count}x)")
+            else:
+                print(f"Pressed {args.key}")
+        else:
+            print(f"Failed to press {args.key}")
+            sys.exit(1)
+
+    elif args.key_sequence:
+        keys = args.key_sequence.split(",")
+        if controller.press_key_sequence(keys):
+            print(f"Pressed sequence: {' -> '.join(keys)}")
+        else:
+            print("Failed to press key sequence")
+            sys.exit(1)
+
+    elif args.button:
+        if controller.press_hardware_button(args.button):
+            print(f"Pressed {args.button} button")
+        else:
+            print(f"Failed to press {args.button}")
+            sys.exit(1)
+
+    elif args.clear:
+        if controller.clear_text():
+            print("Cleared text field")
+        else:
+            print("Failed to clear text")
+            sys.exit(1)
+
+    elif args.dismiss:
+        if controller.dismiss_keyboard():
+            print("Dismissed keyboard")
+        else:
+            print("Failed to dismiss keyboard")
+            sys.exit(1)
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,486 @@
+#!/usr/bin/env python3
+"""
+iOS Simulator Log Monitoring and Analysis
+
+Real-time log streaming from iOS simulators with intelligent filtering, error detection,
+and token-efficient summarization. Enhanced version of app_state_capture.py's log capture.
+
+Features:
+- Real-time log streaming from booted simulators
+- Smart filtering by app bundle ID, subsystem, category, severity
+- Error/warning classification and deduplication
+- Duration-based or continuous follow mode
+- Token-efficient summaries with full logs saved to file
+- Integration with test_recorder and app_state_capture
+
+Usage Examples:
+    # Monitor app logs in real-time (follow mode)
+    python scripts/log_monitor.py --app com.myapp.MyApp --follow
+
+    # Capture logs for specific duration
+    python scripts/log_monitor.py --app com.myapp.MyApp --duration 30s
+
+    # Extract errors and warnings only from last 5 minutes
+    python scripts/log_monitor.py --severity error,warning --last 5m
+
+    # Save logs to file
+    python scripts/log_monitor.py --app com.myapp.MyApp --duration 1m --output logs/
+
+    # Verbose output with full log lines
+    python scripts/log_monitor.py --app com.myapp.MyApp --verbose
+"""
+
+import argparse
+import json
+import re
+import signal
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+
+class LogMonitor:
+    """Monitor and analyze iOS simulator logs with intelligent filtering."""
+
+    def __init__(
+        self,
+        app_bundle_id: str | None = None,
+        device_udid: str | None = None,
+        severity_filter: list[str] | None = None,
+    ):
+        """
+        Initialize log monitor.
+
+        Args:
+            app_bundle_id: Filter logs by app bundle ID
+            device_udid: Device UDID (uses booted if not specified)
+            severity_filter: List of severities to include (error, warning, info, debug)
+        """
+        self.app_bundle_id = app_bundle_id
+        self.device_udid = device_udid or "booted"
+        self.severity_filter = severity_filter or ["error", "warning", "info", "debug"]
+
+        # Log storage
+        self.log_lines: list[str] = []
+        self.errors: list[str] = []
+        self.warnings: list[str] = []
+        self.info_messages: list[str] = []
+
+        # Statistics
+        self.error_count = 0
+        self.warning_count = 0
+        self.info_count = 0
+        self.debug_count = 0
+        self.total_lines = 0
+
+        # Deduplication
+        self.seen_messages: set[str] = set()
+
+        # Process control
+        self.log_process: subprocess.Popen | None = None
+        self.interrupted = False
+
+    def parse_time_duration(self, duration_str: str) -> float:
+        """
+        Parse duration string to seconds.
+
+        Args:
+            duration_str: Duration like "30s", "5m", "1h"
+
+        Returns:
+            Duration in seconds
+        """
+        match = re.match(r"(\d+)([smh])", duration_str.lower())
+        if not match:
+            raise ValueError(
+                f"Invalid duration format: {duration_str}. Use format like '30s', '5m', '1h'"
+            )
+
+        value, unit = match.groups()
+        value = int(value)
+
+        if unit == "s":
+            return value
+        if unit == "m":
+            return value * 60
+        if unit == "h":
+            return value * 3600
+
+        return 0
+
+    def classify_log_line(self, line: str) -> str | None:
+        """
+        Classify log line by severity.
+
+        Args:
+            line: Log line to classify
+
+        Returns:
+            Severity level (error, warning, info, debug) or None
+        """
+        line_lower = line.lower()
+
+        # Error patterns
+        error_patterns = [
+            r"\berror\b",
+            r"\bfault\b",
+            r"\bfailed\b",
+            r"\bexception\b",
+            r"\bcrash\b",
+            r"❌",
+        ]
+
+        # Warning patterns
+        warning_patterns = [r"\bwarning\b", r"\bwarn\b", r"\bdeprecated\b", r"⚠️"]
+
+        # Info patterns
+        info_patterns = [r"\binfo\b", r"\bnotice\b", r"ℹ️"]
+
+        for pattern in error_patterns:
+            if re.search(pattern, line_lower):
+                return "error"
+
+        for pattern in warning_patterns:
+            if re.search(pattern, line_lower):
+                return "warning"
+
+        for pattern in info_patterns:
+            if re.search(pattern, line_lower):
+                return "info"
+
+        return "debug"
+
+    def deduplicate_message(self, line: str) -> bool:
+        """
+        Check if message is duplicate.
+
+        Args:
+            line: Log line
+
+        Returns:
+            True if this is a new message, False if duplicate
+        """
+        # Create signature by removing timestamps and process IDs
+        signature = re.sub(r"\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}", "", line)
+        signature = re.sub(r"\[\d+\]", "", signature)
+        signature = re.sub(r"\s+", " ", signature).strip()
+
+        if signature in self.seen_messages:
+            return False
+
+        self.seen_messages.add(signature)
+        return True
+
+    def process_log_line(self, line: str):
+        """
+        Process a single log line.
+
+        Args:
+            line: Log line to process
+        """
+        if not line.strip():
+            return
+
+        self.total_lines += 1
+        self.log_lines.append(line)
+
+        # Classify severity
+        severity = self.classify_log_line(line)
+
+        # Skip if not in filter
+        if severity not in self.severity_filter:
+            return
+
+        # Deduplicate (for errors and warnings)
+        if severity in ["error", "warning"] and not self.deduplicate_message(line):
+            return
+
+        # Store by severity
+        if severity == "error":
+            self.error_count += 1
+            self.errors.append(line)
+        elif severity == "warning":
+            self.warning_count += 1
+            self.warnings.append(line)
+        elif severity == "info":
+            self.info_count += 1
+            if len(self.info_messages) < 20:  # Keep only recent info
+                self.info_messages.append(line)
+        else:  # debug
+            self.debug_count += 1
+
+    def stream_logs(
+        self,
+        follow: bool = False,
+        duration: float | None = None,
+        last_minutes: float | None = None,
+    ) -> bool:
+        """
+        Stream logs from simulator.
+
+        Args:
+            follow: Follow mode (continuous streaming)
+            duration: Capture duration in seconds
+            last_minutes: Show logs from last N minutes
+
+        Returns:
+            True if successful
+        """
+        # Build log stream command
+        cmd = ["xcrun", "simctl", "spawn", self.device_udid, "log", "stream"]
+
+        # Add filters
+        if self.app_bundle_id:
+            # Filter by process name (extracted from bundle ID)
+            app_name = self.app_bundle_id.split(".")[-1]
+            cmd.extend(["--predicate", f'processImagePath CONTAINS "{app_name}"'])
+
+        # Add time filter for historical logs
+        if last_minutes:
+            start_time = datetime.now() - timedelta(minutes=last_minutes)
+            time_str = start_time.strftime("%Y-%m-%d %H:%M:%S")
+            cmd.extend(["--start", time_str])
+
+        # Setup signal handler for graceful interruption
+        def signal_handler(sig, frame):
+            self.interrupted = True
+            if self.log_process:
+                self.log_process.terminate()
+
+        signal.signal(signal.SIGINT, signal_handler)
+
+        try:
+            # Start log streaming process
+            self.log_process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,  # Line buffered
+            )
+
+            # Track start time for duration
+            start_time = datetime.now()
+
+            # Process log lines
+            for line in iter(self.log_process.stdout.readline, ""):
+                if not line:
+                    break
+
+                # Process the line
+                self.process_log_line(line.rstrip())
+
+                # Print in follow mode
+                if follow:
+                    severity = self.classify_log_line(line)
+                    if severity in self.severity_filter:
+                        print(line.rstrip())
+
+                # Check duration
+                if duration and (datetime.now() - start_time).total_seconds() >= duration:
+                    break
+
+                # Check if interrupted
+                if self.interrupted:
+                    break
+
+            # Wait for process to finish
+            self.log_process.wait()
+            return True
+
+        except Exception as e:
+            print(f"Error streaming logs: {e}", file=sys.stderr)
+            return False
+
+        finally:
+            if self.log_process:
+                self.log_process.terminate()
+
+    def get_summary(self, verbose: bool = False) -> str:
+        """
+        Get log summary.
+
+        Args:
+            verbose: Include full log details
+
+        Returns:
+            Formatted summary string
+        """
+        lines = []
+
+        # Header
+        if self.app_bundle_id:
+            lines.append(f"Logs for: {self.app_bundle_id}")
+        else:
+            lines.append("Logs for: All processes")
+
+        # Statistics
+        lines.append(f"Total lines: {self.total_lines}")
+        lines.append(
+            f"Errors: {self.error_count}, Warnings: {self.warning_count}, Info: {self.info_count}"
+        )
+
+        # Top issues
+        if self.errors:
+            lines.append(f"\nTop Errors ({len(self.errors)}):")
+            for error in self.errors[:5]:  # Show first 5
+                lines.append(f"  ❌ {error[:120]}")  # Truncate long lines
+
+        if self.warnings:
+            lines.append(f"\nTop Warnings ({len(self.warnings)}):")
+            for warning in self.warnings[:5]:  # Show first 5
+                lines.append(f"  ⚠️  {warning[:120]}")
+
+        # Verbose output
+        if verbose and self.log_lines:
+            lines.append("\n=== Recent Log Lines ===")
+            for line in self.log_lines[-50:]:  # Last 50 lines
+                lines.append(line)
+
+        return "\n".join(lines)
+
+    def get_json_output(self) -> dict:
+        """Get log results as JSON."""
+        return {
+            "app_bundle_id": self.app_bundle_id,
+            "device_udid": self.device_udid,
+            "statistics": {
+                "total_lines": self.total_lines,
+                "errors": self.error_count,
+                "warnings": self.warning_count,
+                "info": self.info_count,
+                "debug": self.debug_count,
+            },
+            "errors": self.errors[:20],  # Limit to 20
+            "warnings": self.warnings[:20],
+            "sample_logs": self.log_lines[-50:],  # Last 50 lines
+        }
+
+    def save_logs(self, output_dir: str) -> str:
+        """
+        Save logs to file.
+
+        Args:
+            output_dir: Directory to save logs
+
+        Returns:
+            Path to saved log file
+        """
+        # Create output directory
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        # Generate filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        app_name = self.app_bundle_id.split(".")[-1] if self.app_bundle_id else "simulator"
+        log_file = output_path / f"{app_name}-{timestamp}.log"
+
+        # Write all log lines
+        with open(log_file, "w") as f:
+            f.write("\n".join(self.log_lines))
+
+        # Also save JSON summary
+        json_file = output_path / f"{app_name}-{timestamp}-summary.json"
+        with open(json_file, "w") as f:
+            json.dump(self.get_json_output(), f, indent=2)
+
+        return str(log_file)
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Monitor and analyze iOS simulator logs",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Monitor app in real-time
+  python scripts/log_monitor.py --app com.myapp.MyApp --follow
+
+  # Capture logs for 30 seconds
+  python scripts/log_monitor.py --app com.myapp.MyApp --duration 30s
+
+  # Show errors/warnings from last 5 minutes
+  python scripts/log_monitor.py --severity error,warning --last 5m
+
+  # Save logs to file
+  python scripts/log_monitor.py --app com.myapp.MyApp --duration 1m --output logs/
+        """,
+    )
+
+    # Filtering options
+    parser.add_argument(
+        "--app", dest="app_bundle_id", help="App bundle ID to filter logs (e.g., com.myapp.MyApp)"
+    )
+    parser.add_argument("--device-udid", help="Device UDID (uses booted if not specified)")
+    parser.add_argument(
+        "--severity", help="Comma-separated severity levels (error,warning,info,debug)"
+    )
+
+    # Time options
+    time_group = parser.add_mutually_exclusive_group()
+    time_group.add_argument(
+        "--follow", action="store_true", help="Follow mode (continuous streaming)"
+    )
+    time_group.add_argument("--duration", help="Capture duration (e.g., 30s, 5m, 1h)")
+    time_group.add_argument(
+        "--last", dest="last_minutes", help="Show logs from last N minutes (e.g., 5m)"
+    )
+
+    # Output options
+    parser.add_argument("--output", help="Save logs to directory")
+    parser.add_argument("--verbose", action="store_true", help="Show detailed output")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    # Parse severity filter
+    severity_filter = None
+    if args.severity:
+        severity_filter = [s.strip().lower() for s in args.severity.split(",")]
+
+    # Initialize monitor
+    monitor = LogMonitor(
+        app_bundle_id=args.app_bundle_id,
+        device_udid=args.device_udid,
+        severity_filter=severity_filter,
+    )
+
+    # Parse duration
+    duration = None
+    if args.duration:
+        duration = monitor.parse_time_duration(args.duration)
+
+    # Parse last minutes
+    last_minutes = None
+    if args.last_minutes:
+        last_minutes = monitor.parse_time_duration(args.last_minutes) / 60
+
+    # Stream logs
+    print("Monitoring logs...", file=sys.stderr)
+    if args.app_bundle_id:
+        print(f"App: {args.app_bundle_id}", file=sys.stderr)
+
+    success = monitor.stream_logs(follow=args.follow, duration=duration, last_minutes=last_minutes)
+
+    if not success:
+        sys.exit(1)
+
+    # Save logs if requested
+    if args.output:
+        log_file = monitor.save_logs(args.output)
+        print(f"\nLogs saved to: {log_file}", file=sys.stderr)
+
+    # Output results
+    if not args.follow:  # Don't show summary in follow mode
+        if args.json:
+            print(json.dumps(monitor.get_json_output(), indent=2))
+        else:
+            print("\n" + monitor.get_summary(verbose=args.verbose))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,453 @@
+#!/usr/bin/env python3
+"""
+iOS Simulator Navigator - Smart Element Finder and Interactor
+
+Finds and interacts with UI elements using accessibility data.
+Prioritizes structured navigation over pixel-based interaction.
+
+This script is the core automation tool for iOS simulator navigation. It finds
+UI elements by text, type, or accessibility ID and performs actions on them
+(tap, enter text). Uses semantic element finding instead of fragile pixel coordinates.
+
+Key Features:
+- Find elements by text (fuzzy or exact matching)
+- Find elements by type (Button, TextField, etc.)
+- Find elements by accessibility identifier
+- Tap elements at their center point
+- Enter text into text fields
+- List all tappable elements on screen
+- Automatic element caching for performance
+
+Usage Examples:
+    # Find and tap a button by text
+    python scripts/navigator.py --find-text "Login" --tap --udid <device-id>
+
+    # Enter text into first text field
+    python scripts/navigator.py --find-type TextField --index 0 --enter-text "username" --udid <device-id>
+
+    # Tap element by accessibility ID
+    python scripts/navigator.py --find-id "submitButton" --tap --udid <device-id>
+
+    # List all interactive elements
+    python scripts/navigator.py --list --udid <device-id>
+
+    # Tap at specific coordinates (fallback)
+    python scripts/navigator.py --tap-at 200,400 --udid <device-id>
+
+Output Format:
+    Tapped: Button "Login" at (320, 450)
+    Entered text in: TextField "Username"
+    Not found: text='Submit'
+
+Navigation Priority (best to worst):
+    1. Find by accessibility label/text (most reliable)
+    2. Find by element type + index (good for forms)
+    3. Find by accessibility ID (precise but app-specific)
+    4. Tap at coordinates (last resort, fragile)
+
+Technical Details:
+- Uses IDB's accessibility tree via `idb ui describe-all --json --nested`
+- Caches tree for multiple operations (call with force_refresh to update)
+- Finds elements by parsing tree recursively
+- Calculates tap coordinates from element frame center
+- Uses `idb ui tap` for tapping, `idb ui text` for text entry
+- Extracts data from AXLabel, AXValue, and AXUniqueId fields
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from dataclasses import dataclass
+
+from common import (
+    flatten_tree,
+    get_accessibility_tree,
+    get_device_screen_size,
+    resolve_udid,
+    transform_screenshot_coords,
+)
+
+
+@dataclass
+class Element:
+    """Represents a UI element from accessibility tree."""
+
+    type: str
+    label: str | None
+    value: str | None
+    identifier: str | None
+    frame: dict[str, float]
+    traits: list[str]
+    enabled: bool = True
+
+    @property
+    def center(self) -> tuple[int, int]:
+        """Calculate center point for tapping."""
+        x = int(self.frame["x"] + self.frame["width"] / 2)
+        y = int(self.frame["y"] + self.frame["height"] / 2)
+        return (x, y)
+
+    @property
+    def description(self) -> str:
+        """Human-readable description."""
+        label = self.label or self.value or self.identifier or "Unnamed"
+        return f'{self.type} "{label}"'
+
+
+class Navigator:
+    """Navigates iOS apps using accessibility data."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize navigator with optional device UDID."""
+        self.udid = udid
+        self._tree_cache = None
+
+    def get_accessibility_tree(self, force_refresh: bool = False) -> dict:
+        """Get accessibility tree (cached for efficiency)."""
+        if self._tree_cache and not force_refresh:
+            return self._tree_cache
+
+        # Delegate to shared utility
+        self._tree_cache = get_accessibility_tree(self.udid, nested=True)
+        return self._tree_cache
+
+    def _flatten_tree(self, node: dict, elements: list[Element] | None = None) -> list[Element]:
+        """Flatten accessibility tree into list of elements."""
+        if elements is None:
+            elements = []
+
+        # Create element from node
+        if node.get("type"):
+            element = Element(
+                type=node.get("type", "Unknown"),
+                label=node.get("AXLabel"),
+                value=node.get("AXValue"),
+                identifier=node.get("AXUniqueId"),
+                frame=node.get("frame", {}),
+                traits=node.get("traits", []),
+                enabled=node.get("enabled", True),
+            )
+            elements.append(element)
+
+        # Process children
+        for child in node.get("children", []):
+            self._flatten_tree(child, elements)
+
+        return elements
+
+    def find_element(
+        self,
+        text: str | None = None,
+        element_type: str | None = None,
+        identifier: str | None = None,
+        index: int = 0,
+        fuzzy: bool = True,
+    ) -> Element | None:
+        """
+        Find element by various criteria.
+
+        Args:
+            text: Text to search in label/value
+            element_type: Type of element (Button, TextField, etc.)
+            identifier: Accessibility identifier
+            index: Which matching element to return (0-based)
+            fuzzy: Use fuzzy matching for text
+
+        Returns:
+            Element if found, None otherwise
+        """
+        tree = self.get_accessibility_tree()
+        elements = self._flatten_tree(tree)
+
+        matches = []
+
+        for elem in elements:
+            # Skip disabled elements
+            if not elem.enabled:
+                continue
+
+            # Check type
+            if element_type and elem.type != element_type:
+                continue
+
+            # Check identifier (exact match)
+            if identifier and elem.identifier != identifier:
+                continue
+
+            # Check text (in label or value)
+            if text:
+                elem_text = (elem.label or "") + " " + (elem.value or "")
+                if fuzzy:
+                    if text.lower() not in elem_text.lower():
+                        continue
+                elif text not in (elem.label, elem.value):
+                    continue
+
+            matches.append(elem)
+
+        if matches and index < len(matches):
+            return matches[index]
+
+        return None
+
+    def tap(self, element: Element) -> bool:
+        """Tap on an element."""
+        x, y = element.center
+        return self.tap_at(x, y)
+
+    def tap_at(self, x: int, y: int) -> bool:
+        """Tap at specific coordinates."""
+        cmd = ["idb", "ui", "tap", str(x), str(y)]
+        if self.udid:
+            cmd.extend(["--udid", self.udid])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def enter_text(self, text: str, element: Element | None = None) -> bool:
+        """
+        Enter text into element or current focus.
+
+        Args:
+            text: Text to enter
+            element: Optional element to tap first
+
+        Returns:
+            Success status
+        """
+        # Tap element if provided
+        if element:
+            if not self.tap(element):
+                return False
+            # Small delay for focus
+            import time
+
+            time.sleep(0.5)
+
+        # Enter text
+        cmd = ["idb", "ui", "text", text]
+        if self.udid:
+            cmd.extend(["--udid", self.udid])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def find_and_tap(
+        self,
+        text: str | None = None,
+        element_type: str | None = None,
+        identifier: str | None = None,
+        index: int = 0,
+    ) -> tuple[bool, str]:
+        """
+        Find element and tap it.
+
+        Returns:
+            (success, message) tuple
+        """
+        element = self.find_element(text, element_type, identifier, index)
+
+        if not element:
+            criteria = []
+            if text:
+                criteria.append(f"text='{text}'")
+            if element_type:
+                criteria.append(f"type={element_type}")
+            if identifier:
+                criteria.append(f"id={identifier}")
+            return (False, f"Not found: {', '.join(criteria)}")
+
+        if self.tap(element):
+            return (True, f"Tapped: {element.description} at {element.center}")
+        return (False, f"Failed to tap: {element.description}")
+
+    def find_and_enter_text(
+        self,
+        text_to_enter: str,
+        find_text: str | None = None,
+        element_type: str | None = "TextField",
+        identifier: str | None = None,
+        index: int = 0,
+    ) -> tuple[bool, str]:
+        """
+        Find element and enter text into it.
+
+        Returns:
+            (success, message) tuple
+        """
+        element = self.find_element(find_text, element_type, identifier, index)
+
+        if not element:
+            return (False, "TextField not found")
+
+        if self.enter_text(text_to_enter, element):
+            return (True, f"Entered text in: {element.description}")
+        return (False, "Failed to enter text")
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Navigate iOS apps using accessibility data")
+
+    # Finding options
+    parser.add_argument("--find-text", help="Find element by text (fuzzy match)")
+    parser.add_argument("--find-exact", help="Find element by exact text")
+    parser.add_argument("--find-type", help="Element type (Button, TextField, etc.)")
+    parser.add_argument("--find-id", help="Accessibility identifier")
+    parser.add_argument("--index", type=int, default=0, help="Which match to use (0-based)")
+
+    # Action options
+    parser.add_argument("--tap", action="store_true", help="Tap the found element")
+    parser.add_argument("--tap-at", help="Tap at coordinates (x,y)")
+    parser.add_argument("--enter-text", help="Enter text into element")
+
+    # Coordinate transformation
+    parser.add_argument(
+        "--screenshot-coords",
+        action="store_true",
+        help="Interpret tap coordinates as from a screenshot (requires --screenshot-width/height)",
+    )
+    parser.add_argument(
+        "--screenshot-width",
+        type=int,
+        help="Screenshot width for coordinate transformation",
+    )
+    parser.add_argument(
+        "--screenshot-height",
+        type=int,
+        help="Screenshot height for coordinate transformation",
+    )
+
+    # Other options
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+    parser.add_argument("--list", action="store_true", help="List all tappable elements")
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    navigator = Navigator(udid=udid)
+
+    # List mode
+    if args.list:
+        tree = navigator.get_accessibility_tree()
+        elements = navigator._flatten_tree(tree)
+
+        # Filter to tappable elements
+        tappable = [
+            e
+            for e in elements
+            if e.enabled and e.type in ["Button", "Link", "Cell", "TextField", "SecureTextField"]
+        ]
+
+        print(f"Tappable elements ({len(tappable)}):")
+        for elem in tappable[:10]:  # Limit output for tokens
+            print(f"  {elem.type}: \"{elem.label or elem.value or 'Unnamed'}\" {elem.center}")
+
+        if len(tappable) > 10:
+            print(f"  ... and {len(tappable) - 10} more")
+        sys.exit(0)
+
+    # Direct tap at coordinates
+    if args.tap_at:
+        coords = args.tap_at.split(",")
+        if len(coords) != 2:
+            print("Error: --tap-at requires x,y format")
+            sys.exit(1)
+
+        x, y = int(coords[0]), int(coords[1])
+
+        # Handle coordinate transformation if requested
+        if args.screenshot_coords:
+            if not args.screenshot_width or not args.screenshot_height:
+                print(
+                    "Error: --screenshot-coords requires --screenshot-width and --screenshot-height"
+                )
+                sys.exit(1)
+
+            device_w, device_h = get_device_screen_size(udid)
+            x, y = transform_screenshot_coords(
+                x,
+                y,
+                args.screenshot_width,
+                args.screenshot_height,
+                device_w,
+                device_h,
+            )
+            print(
+                f"Transformed screenshot coords ({coords[0]}, {coords[1]}) "
+                f"to device coords ({x}, {y})"
+            )
+
+        if navigator.tap_at(x, y):
+            print(f"Tapped at ({x}, {y})")
+        else:
+            print(f"Failed to tap at ({x}, {y})")
+            sys.exit(1)
+
+    # Find and tap
+    elif args.tap:
+        text = args.find_text or args.find_exact
+        fuzzy = args.find_text is not None
+
+        success, message = navigator.find_and_tap(
+            text=text, element_type=args.find_type, identifier=args.find_id, index=args.index
+        )
+
+        print(message)
+        if not success:
+            sys.exit(1)
+
+    # Find and enter text
+    elif args.enter_text:
+        text = args.find_text or args.find_exact
+
+        success, message = navigator.find_and_enter_text(
+            text_to_enter=args.enter_text,
+            find_text=text,
+            element_type=args.find_type or "TextField",
+            identifier=args.find_id,
+            index=args.index,
+        )
+
+        print(message)
+        if not success:
+            sys.exit(1)
+
+    # Just find (no action)
+    else:
+        text = args.find_text or args.find_exact
+        fuzzy = args.find_text is not None
+
+        element = navigator.find_element(
+            text=text,
+            element_type=args.find_type,
+            identifier=args.find_id,
+            index=args.index,
+            fuzzy=fuzzy,
+        )
+
+        if element:
+            print(f"Found: {element.description} at {element.center}")
+        else:
+            print("Element not found")
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+iOS Privacy & Permissions Manager
+
+Grant/revoke app permissions for testing permission flows.
+Supports 13+ services with audit trail tracking.
+
+Usage: python scripts/privacy_manager.py --grant camera --bundle-id com.app
+"""
+
+import argparse
+import subprocess
+import sys
+from datetime import datetime
+
+from common import resolve_udid
+
+
+class PrivacyManager:
+    """Manages iOS app privacy and permissions."""
+
+    # Supported services
+    SUPPORTED_SERVICES = {
+        "camera": "Camera access",
+        "microphone": "Microphone access",
+        "location": "Location services",
+        "contacts": "Contacts access",
+        "photos": "Photos library access",
+        "calendar": "Calendar access",
+        "health": "Health data access",
+        "reminders": "Reminders access",
+        "motion": "Motion & fitness",
+        "keyboard": "Keyboard access",
+        "mediaLibrary": "Media library",
+        "calls": "Call history",
+        "siri": "Siri access",
+    }
+
+    def __init__(self, udid: str | None = None):
+        """Initialize privacy manager.
+
+        Args:
+            udid: Optional device UDID (auto-detects booted simulator if None)
+        """
+        self.udid = udid
+
+    def grant_permission(
+        self,
+        bundle_id: str,
+        service: str,
+        scenario: str | None = None,
+        step: int | None = None,
+    ) -> bool:
+        """
+        Grant permission for app.
+
+        Args:
+            bundle_id: App bundle ID
+            service: Service name (camera, microphone, location, etc.)
+            scenario: Test scenario name for audit trail
+            step: Step number in test scenario
+
+        Returns:
+            Success status
+        """
+        if service not in self.SUPPORTED_SERVICES:
+            print(f"Error: Unknown service '{service}'")
+            print(f"Supported: {', '.join(self.SUPPORTED_SERVICES.keys())}")
+            return False
+
+        cmd = ["xcrun", "simctl", "privacy"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.extend(["grant", service, bundle_id])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+
+            # Log audit entry
+            self._log_audit("grant", bundle_id, service, scenario, step)
+
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def revoke_permission(
+        self,
+        bundle_id: str,
+        service: str,
+        scenario: str | None = None,
+        step: int | None = None,
+    ) -> bool:
+        """
+        Revoke permission for app.
+
+        Args:
+            bundle_id: App bundle ID
+            service: Service name
+            scenario: Test scenario name for audit trail
+            step: Step number in test scenario
+
+        Returns:
+            Success status
+        """
+        if service not in self.SUPPORTED_SERVICES:
+            print(f"Error: Unknown service '{service}'")
+            return False
+
+        cmd = ["xcrun", "simctl", "privacy"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.extend(["revoke", service, bundle_id])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+
+            # Log audit entry
+            self._log_audit("revoke", bundle_id, service, scenario, step)
+
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def reset_permission(
+        self,
+        bundle_id: str,
+        service: str,
+        scenario: str | None = None,
+        step: int | None = None,
+    ) -> bool:
+        """
+        Reset permission to default.
+
+        Args:
+            bundle_id: App bundle ID
+            service: Service name
+            scenario: Test scenario name for audit trail
+            step: Step number in test scenario
+
+        Returns:
+            Success status
+        """
+        if service not in self.SUPPORTED_SERVICES:
+            print(f"Error: Unknown service '{service}'")
+            return False
+
+        cmd = ["xcrun", "simctl", "privacy"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.extend(["reset", service, bundle_id])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+
+            # Log audit entry
+            self._log_audit("reset", bundle_id, service, scenario, step)
+
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    @staticmethod
+    def _log_audit(
+        action: str,
+        bundle_id: str,
+        service: str,
+        scenario: str | None = None,
+        step: int | None = None,
+    ) -> None:
+        """Log permission change to audit trail (for test tracking).
+
+        Args:
+            action: grant, revoke, or reset
+            bundle_id: App bundle ID
+            service: Service name
+            scenario: Test scenario name
+            step: Step number
+        """
+        # Could write to file, but for now just log to stdout for transparency
+        timestamp = datetime.now().isoformat()
+        location = f" (step {step})" if step else ""
+        scenario_info = f" in {scenario}" if scenario else ""
+        print(
+            f"[Audit] {timestamp}: {action.upper()} {service} for {bundle_id}{scenario_info}{location}"
+        )
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Manage iOS app privacy and permissions")
+
+    # Required
+    parser.add_argument("--bundle-id", required=True, help="App bundle ID (e.g., com.example.app)")
+
+    # Action (mutually exclusive)
+    action_group = parser.add_mutually_exclusive_group(required=True)
+    action_group.add_argument(
+        "--grant",
+        help="Grant permission (service name or comma-separated list)",
+    )
+    action_group.add_argument(
+        "--revoke", help="Revoke permission (service name or comma-separated list)"
+    )
+    action_group.add_argument(
+        "--reset",
+        help="Reset permission to default (service name or comma-separated list)",
+    )
+    action_group.add_argument(
+        "--list",
+        action="store_true",
+        help="List all supported services",
+    )
+
+    # Test tracking
+    parser.add_argument(
+        "--scenario",
+        help="Test scenario name for audit trail",
+    )
+    parser.add_argument("--step", type=int, help="Step number in test scenario")
+
+    # Device
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+
+    args = parser.parse_args()
+
+    # List supported services
+    if args.list:
+        print("Supported Privacy Services:\n")
+        for service, description in PrivacyManager.SUPPORTED_SERVICES.items():
+            print(f"  {service:<15} - {description}")
+        print()
+        print("Examples:")
+        print("  python scripts/privacy_manager.py --grant camera --bundle-id com.app")
+        print("  python scripts/privacy_manager.py --revoke location --bundle-id com.app")
+        print("  python scripts/privacy_manager.py --grant camera,photos --bundle-id com.app")
+        sys.exit(0)
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    manager = PrivacyManager(udid=udid)
+
+    # Parse service names (support comma-separated list)
+    if args.grant:
+        services = [s.strip() for s in args.grant.split(",")]
+        action = "grant"
+        action_fn = manager.grant_permission
+    elif args.revoke:
+        services = [s.strip() for s in args.revoke.split(",")]
+        action = "revoke"
+        action_fn = manager.revoke_permission
+    else:  # reset
+        services = [s.strip() for s in args.reset.split(",")]
+        action = "reset"
+        action_fn = manager.reset_permission
+
+    # Execute action for each service
+    all_success = True
+    for service in services:
+        if service not in PrivacyManager.SUPPORTED_SERVICES:
+            print(f"Error: Unknown service '{service}'")
+            all_success = False
+            continue
+
+        success = action_fn(
+            args.bundle_id,
+            service,
+            scenario=args.scenario,
+            step=args.step,
+        )
+
+        if success:
+            description = PrivacyManager.SUPPORTED_SERVICES[service]
+            print(f"✓ {action.capitalize()} {service}: {description}")
+        else:
+            print(f"✗ Failed to {action} {service}")
+            all_success = False
+
+    if not all_success:
+        sys.exit(1)
+
+    # Summary
+    if len(services) > 1:
+        print(f"\nPermissions {action}ed: {', '.join(services)}")
+
+    if args.scenario:
+        print(f"Test scenario: {args.scenario}" + (f" (step {args.step})" if args.step else ""))
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+iOS Push Notification Simulator
+
+Send simulated push notifications to test notification handling.
+Supports custom payloads and test tracking.
+
+Usage: python scripts/push_notification.py --bundle-id com.app --title "Alert" --body "Message"
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from common import resolve_udid
+
+
+class PushNotificationSender:
+    """Sends simulated push notifications to iOS simulator."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize push notification sender.
+
+        Args:
+            udid: Optional device UDID (auto-detects booted simulator if None)
+        """
+        self.udid = udid
+
+    def send(
+        self,
+        bundle_id: str,
+        payload: dict | str,
+        _test_name: str | None = None,
+        _expected_behavior: str | None = None,
+    ) -> bool:
+        """
+        Send push notification to app.
+
+        Args:
+            bundle_id: Target app bundle ID
+            payload: Push payload (dict or JSON string) or path to JSON file
+            test_name: Test scenario name for tracking
+            expected_behavior: Expected behavior after notification arrives
+
+        Returns:
+            Success status
+        """
+        # Handle different payload formats
+        if isinstance(payload, str):
+            # Check if it's a file path
+            payload_path = Path(payload)
+            if payload_path.exists():
+                with open(payload_path) as f:
+                    payload_data = json.load(f)
+            else:
+                # Try to parse as JSON string
+                try:
+                    payload_data = json.loads(payload)
+                except json.JSONDecodeError:
+                    print(f"Error: Invalid JSON payload: {payload}")
+                    return False
+        else:
+            payload_data = payload
+
+        # Ensure payload has aps dictionary
+        if "aps" not in payload_data:
+            payload_data = {"aps": payload_data}
+
+        # Create temp file with payload
+        try:
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+                json.dump(payload_data, f)
+                temp_payload_path = f.name
+
+            # Build simctl command
+            cmd = ["xcrun", "simctl", "push"]
+
+            if self.udid:
+                cmd.append(self.udid)
+            else:
+                cmd.append("booted")
+
+            cmd.extend([bundle_id, temp_payload_path])
+
+            # Send notification
+            subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            # Clean up temp file
+            Path(temp_payload_path).unlink()
+
+            return True
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error sending push notification: {e.stderr}")
+            return False
+        except Exception as e:
+            print(f"Error: {e}")
+            return False
+
+    def send_simple(
+        self,
+        bundle_id: str,
+        title: str | None = None,
+        body: str | None = None,
+        badge: int | None = None,
+        sound: bool = True,
+    ) -> bool:
+        """
+        Send simple push notification with common parameters.
+
+        Args:
+            bundle_id: Target app bundle ID
+            title: Alert title
+            body: Alert body
+            badge: Badge number
+            sound: Whether to play sound
+
+        Returns:
+            Success status
+        """
+        payload = {}
+
+        if title or body:
+            alert = {}
+            if title:
+                alert["title"] = title
+            if body:
+                alert["body"] = body
+            payload["alert"] = alert
+
+        if badge is not None:
+            payload["badge"] = badge
+
+        if sound:
+            payload["sound"] = "default"
+
+        # Wrap in aps
+        full_payload = {"aps": payload}
+
+        return self.send(bundle_id, full_payload)
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Send simulated push notification to iOS app")
+
+    # Required
+    parser.add_argument(
+        "--bundle-id", required=True, help="Target app bundle ID (e.g., com.example.app)"
+    )
+
+    # Simple payload options
+    parser.add_argument("--title", help="Alert title (for simple notifications)")
+    parser.add_argument("--body", help="Alert body message")
+    parser.add_argument("--badge", type=int, help="Badge number")
+    parser.add_argument("--no-sound", action="store_true", help="Don't play notification sound")
+
+    # Custom payload
+    parser.add_argument(
+        "--payload",
+        help="Custom JSON payload file or inline JSON string",
+    )
+
+    # Test tracking
+    parser.add_argument("--test-name", help="Test scenario name for tracking")
+    parser.add_argument(
+        "--expected",
+        help="Expected behavior after notification",
+    )
+
+    # Device
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    sender = PushNotificationSender(udid=udid)
+
+    # Send notification
+    if args.payload:
+        # Custom payload mode
+        success = sender.send(args.bundle_id, args.payload)
+    else:
+        # Simple notification mode
+        success = sender.send_simple(
+            args.bundle_id,
+            title=args.title,
+            body=args.body,
+            badge=args.badge,
+            sound=not args.no_sound,
+        )
+
+    if success:
+        # Token-efficient output
+        output = "Push notification sent"
+
+        if args.test_name:
+            output += f" (test: {args.test_name})"
+
+        print(output)
+
+        if args.expected:
+            print(f"Expected: {args.expected}")
+
+        print()
+        print("Notification details:")
+        if args.title:
+            print(f"  Title: {args.title}")
+        if args.body:
+            print(f"  Body: {args.body}")
+        if args.badge:
+            print(f"  Badge: {args.badge}")
+
+        print()
+        print("Verify notification handling:")
+        print("1. Check app log output: python scripts/log_monitor.py --app " + args.bundle_id)
+        print(
+            "2. Capture state: python scripts/app_state_capture.py --app-bundle-id "
+            + args.bundle_id
+        )
+
+    else:
+        print("Failed to send push notification")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""
+iOS Screen Mapper - Current Screen Analyzer
+
+Maps the current screen's UI elements for navigation decisions.
+Provides token-efficient summaries of available interactions.
+
+This script analyzes the iOS simulator screen using IDB's accessibility tree
+and provides a compact, actionable summary of what's currently visible and
+interactive on the screen. Perfect for AI agents making navigation decisions.
+
+Key Features:
+- Token-efficient output (5-7 lines by default)
+- Identifies buttons, text fields, navigation elements
+- Counts interactive and focusable elements
+- Progressive detail with --verbose flag
+- Navigation hints with --hints flag
+
+Usage Examples:
+    # Quick summary (default)
+    python scripts/screen_mapper.py --udid <device-id>
+
+    # Detailed element breakdown
+    python scripts/screen_mapper.py --udid <device-id> --verbose
+
+    # Include navigation suggestions
+    python scripts/screen_mapper.py --udid <device-id> --hints
+
+    # Full JSON output for parsing
+    python scripts/screen_mapper.py --udid <device-id> --json
+
+Output Format (default):
+    Screen: LoginViewController (45 elements, 7 interactive)
+    Buttons: "Login", "Cancel", "Forgot Password"
+    TextFields: 2 (0 filled)
+    Navigation: NavBar: "Sign In"
+    Focusable: 7 elements
+
+Technical Details:
+- Uses IDB's accessibility tree via `idb ui describe-all --json --nested`
+- Parses IDB's array format: [{ root element with children }]
+- Identifies element types: Button, TextField, NavigationBar, TabBar, etc.
+- Extracts labels from AXLabel, AXValue, and AXUniqueId fields
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from collections import defaultdict
+
+from common import get_accessibility_tree, resolve_udid
+
+
+class ScreenMapper:
+    """
+    Analyzes current screen for navigation decisions.
+
+    This class fetches the iOS accessibility tree from IDB and analyzes it
+    to provide actionable summaries for navigation. It categorizes elements
+    by type, counts interactive elements, and identifies key UI patterns.
+
+    Attributes:
+        udid (Optional[str]): Device UDID to target, or None for booted device
+        INTERACTIVE_TYPES (Set[str]): Element types that users can interact with
+
+    Design Philosophy:
+        - Token efficiency: Provide minimal but complete information
+        - Progressive disclosure: Summary by default, details on request
+        - Navigation-focused: Highlight elements relevant for automation
+    """
+
+    # Element types we care about for navigation
+    # These are the accessibility element types that indicate user interaction points
+    INTERACTIVE_TYPES = {
+        "Button",
+        "Link",
+        "TextField",
+        "SecureTextField",
+        "Cell",
+        "Switch",
+        "Slider",
+        "Stepper",
+        "SegmentedControl",
+        "TabBar",
+        "NavigationBar",
+        "Toolbar",
+    }
+
+    def __init__(self, udid: str | None = None):
+        """
+        Initialize screen mapper.
+
+        Args:
+            udid: Optional device UDID. If None, uses booted simulator.
+
+        Example:
+            mapper = ScreenMapper(udid="656DC652-1C9F-4AB2-AD4F-F38E65976BDA")
+            mapper = ScreenMapper()  # Uses booted device
+        """
+        self.udid = udid
+
+    def get_accessibility_tree(self) -> dict:
+        """
+        Fetch accessibility tree from iOS simulator via IDB.
+
+        Delegates to shared utility for consistent tree fetching across all scripts.
+        """
+        return get_accessibility_tree(self.udid, nested=True)
+
+    def analyze_tree(self, node: dict, depth: int = 0) -> dict:
+        """Analyze accessibility tree for navigation info."""
+        analysis = {
+            "elements_by_type": defaultdict(list),
+            "total_elements": 0,
+            "interactive_elements": 0,
+            "text_fields": [],
+            "buttons": [],
+            "navigation": {},
+            "screen_name": None,
+            "focusable": 0,
+        }
+
+        self._analyze_recursive(node, analysis, depth)
+
+        # Post-process for clean output
+        analysis["elements_by_type"] = dict(analysis["elements_by_type"])
+
+        return analysis
+
+    def _analyze_recursive(self, node: dict, analysis: dict, depth: int):
+        """Recursively analyze tree nodes."""
+        elem_type = node.get("type")
+        label = node.get("AXLabel", "")
+        value = node.get("AXValue", "")
+        identifier = node.get("AXUniqueId", "")
+
+        # Count element
+        if elem_type:
+            analysis["total_elements"] += 1
+
+            # Track by type
+            if elem_type in self.INTERACTIVE_TYPES:
+                analysis["interactive_elements"] += 1
+
+                # Store concise info (label only, not full node)
+                elem_info = label or value or identifier or "Unnamed"
+                analysis["elements_by_type"][elem_type].append(elem_info)
+
+                # Special handling for common types
+                if elem_type == "Button":
+                    analysis["buttons"].append(elem_info)
+                elif elem_type in ("TextField", "SecureTextField"):
+                    analysis["text_fields"].append(
+                        {"type": elem_type, "label": elem_info, "has_value": bool(value)}
+                    )
+                elif elem_type == "NavigationBar":
+                    analysis["navigation"]["nav_title"] = label or "Navigation"
+                elif elem_type == "TabBar":
+                    # Count tab items
+                    tab_count = len(node.get("children", []))
+                    analysis["navigation"]["tab_count"] = tab_count
+
+            # Track focusable elements
+            if node.get("enabled", False) and elem_type in self.INTERACTIVE_TYPES:
+                analysis["focusable"] += 1
+
+        # Try to identify screen name from view controller
+        if not analysis["screen_name"] and identifier:
+            if "ViewController" in identifier or "Screen" in identifier:
+                analysis["screen_name"] = identifier
+
+        # Process children
+        for child in node.get("children", []):
+            self._analyze_recursive(child, analysis, depth + 1)
+
+    def format_summary(self, analysis: dict, verbose: bool = False) -> str:
+        """Format analysis as token-efficient summary."""
+        lines = []
+
+        # Screen identification (1 line)
+        screen = analysis["screen_name"] or "Unknown Screen"
+        total = analysis["total_elements"]
+        interactive = analysis["interactive_elements"]
+        lines.append(f"Screen: {screen} ({total} elements, {interactive} interactive)")
+
+        # Buttons summary (1 line)
+        if analysis["buttons"]:
+            button_list = ", ".join(f'"{b}"' for b in analysis["buttons"][:5])
+            if len(analysis["buttons"]) > 5:
+                button_list += f" +{len(analysis['buttons']) - 5} more"
+            lines.append(f"Buttons: {button_list}")
+
+        # Text fields summary (1 line)
+        if analysis["text_fields"]:
+            field_count = len(analysis["text_fields"])
+            [f["type"] for f in analysis["text_fields"]]
+            filled = sum(1 for f in analysis["text_fields"] if f["has_value"])
+            lines.append(f"TextFields: {field_count} ({filled} filled)")
+
+        # Navigation summary (1 line)
+        nav_parts = []
+        if "nav_title" in analysis["navigation"]:
+            nav_parts.append(f"NavBar: \"{analysis['navigation']['nav_title']}\"")
+        if "tab_count" in analysis["navigation"]:
+            nav_parts.append(f"TabBar: {analysis['navigation']['tab_count']} tabs")
+        if nav_parts:
+            lines.append(f"Navigation: {', '.join(nav_parts)}")
+
+        # Focusable count (1 line)
+        lines.append(f"Focusable: {analysis['focusable']} elements")
+
+        # Verbose mode adds element type breakdown
+        if verbose:
+            lines.append("\nElements by type:")
+            for elem_type, items in analysis["elements_by_type"].items():
+                if items:  # Only show types that exist
+                    lines.append(f"  {elem_type}: {len(items)}")
+                    for item in items[:3]:  # Show first 3
+                        lines.append(f"    - {item}")
+                    if len(items) > 3:
+                        lines.append(f"    ... +{len(items) - 3} more")
+
+        return "\n".join(lines)
+
+    def get_navigation_hints(self, analysis: dict) -> list[str]:
+        """Generate navigation hints based on screen analysis."""
+        hints = []
+
+        # Check for common patterns
+        if "Login" in str(analysis.get("buttons", [])):
+            hints.append("Login screen detected - find TextFields for credentials")
+
+        if analysis["text_fields"]:
+            unfilled = [f for f in analysis["text_fields"] if not f["has_value"]]
+            if unfilled:
+                hints.append(f"{len(unfilled)} empty text field(s) - may need input")
+
+        if not analysis["buttons"] and not analysis["text_fields"]:
+            hints.append("No interactive elements - try swiping or going back")
+
+        if "tab_count" in analysis.get("navigation", {}):
+            hints.append(f"Tab bar available with {analysis['navigation']['tab_count']} tabs")
+
+        return hints
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Map current screen UI elements")
+    parser.add_argument("--verbose", action="store_true", help="Show detailed element breakdown")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON analysis")
+    parser.add_argument("--hints", action="store_true", help="Include navigation hints")
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    # Create mapper and analyze
+    mapper = ScreenMapper(udid=udid)
+    tree = mapper.get_accessibility_tree()
+    analysis = mapper.analyze_tree(tree)
+
+    # Output based on format
+    if args.json:
+        # Full JSON (verbose)
+        print(json.dumps(analysis, indent=2, default=str))
+    else:
+        # Token-efficient summary (default)
+        summary = mapper.format_summary(analysis, verbose=args.verbose)
+        print(summary)
+
+        # Add hints if requested
+        if args.hints:
+            hints = mapper.get_navigation_hints(analysis)
+            if hints:
+                print("\nHints:")
+                for hint in hints:
+                    print(f"  - {hint}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,239 @@
+#!/usr/bin/env bash
+#
+# iOS Simulator Testing Environment Health Check
+#
+# Verifies that all required tools and dependencies are properly installed
+# and configured for iOS simulator testing.
+#
+# Usage: bash scripts/sim_health_check.sh [--help]
+
+set -e
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Check flags
+SHOW_HELP=false
+
+# Parse arguments
+for arg in "$@"; do
+    case $arg in
+        --help|-h)
+            SHOW_HELP=true
+            shift
+            ;;
+    esac
+done
+
+if [ "$SHOW_HELP" = true ]; then
+    cat <<EOF
+iOS Simulator Testing - Environment Health Check
+
+Verifies that your environment is properly configured for iOS simulator testing.
+
+Usage: bash scripts/sim_health_check.sh [options]
+
+Options:
+  --help, -h    Show this help message
+
+This script checks for:
+  - Xcode Command Line Tools installation
+  - iOS Simulator availability
+  - IDB (iOS Development Bridge) installation
+  - Available simulator devices
+  - Python 3 installation (for scripts)
+
+Exit codes:
+  0 - All checks passed
+  1 - One or more checks failed (see output for details)
+EOF
+    exit 0
+fi
+
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}  iOS Simulator Testing - Environment Health Check${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+CHECKS_PASSED=0
+CHECKS_FAILED=0
+
+# Function to print check status
+check_passed() {
+    echo -e "${GREEN}✓${NC} $1"
+    ((CHECKS_PASSED++))
+}
+
+check_failed() {
+    echo -e "${RED}✗${NC} $1"
+    ((CHECKS_FAILED++))
+}
+
+check_warning() {
+    echo -e "${YELLOW}⚠${NC} $1"
+}
+
+# Check 1: macOS
+echo -e "${BLUE}[1/8]${NC} Checking operating system..."
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    OS_VERSION=$(sw_vers -productVersion)
+    check_passed "macOS detected (version $OS_VERSION)"
+else
+    check_failed "Not running on macOS (detected: $OSTYPE)"
+    echo "       iOS Simulator testing requires macOS"
+fi
+echo ""
+
+# Check 2: Xcode Command Line Tools
+echo -e "${BLUE}[2/8]${NC} Checking Xcode Command Line Tools..."
+if command -v xcrun &> /dev/null; then
+    XCODE_PATH=$(xcode-select -p 2>/dev/null || echo "not found")
+    if [ "$XCODE_PATH" != "not found" ]; then
+        XCODE_VERSION=$(xcodebuild -version 2>/dev/null | head -n 1 || echo "Unknown")
+        check_passed "Xcode Command Line Tools installed"
+        echo "       Path: $XCODE_PATH"
+        echo "       Version: $XCODE_VERSION"
+    else
+        check_failed "Xcode Command Line Tools path not set"
+        echo "       Run: xcode-select --install"
+    fi
+else
+    check_failed "xcrun command not found"
+    echo "       Install Xcode Command Line Tools: xcode-select --install"
+fi
+echo ""
+
+# Check 3: simctl availability
+echo -e "${BLUE}[3/8]${NC} Checking simctl (Simulator Control)..."
+if command -v xcrun &> /dev/null && xcrun simctl help &> /dev/null; then
+    check_passed "simctl is available"
+else
+    check_failed "simctl not available"
+    echo "       simctl comes with Xcode Command Line Tools"
+fi
+echo ""
+
+# Check 4: IDB installation
+echo -e "${BLUE}[4/8]${NC} Checking IDB (iOS Development Bridge)..."
+if command -v idb &> /dev/null; then
+    IDB_PATH=$(which idb)
+    IDB_VERSION=$(idb --version 2>/dev/null || echo "Unknown")
+    check_passed "IDB is installed"
+    echo "       Path: $IDB_PATH"
+    echo "       Version: $IDB_VERSION"
+else
+    check_warning "IDB not found in PATH"
+    echo "       IDB is optional but provides advanced UI automation"
+    echo "       Install: https://fbidb.io/docs/installation"
+    echo "       Recommended: brew tap facebook/fb && brew install idb-companion"
+fi
+echo ""
+
+# Check 5: Python 3 installation
+echo -e "${BLUE}[5/8]${NC} Checking Python 3..."
+if command -v python3 &> /dev/null; then
+    PYTHON_VERSION=$(python3 --version | cut -d' ' -f2)
+    check_passed "Python 3 is installed (version $PYTHON_VERSION)"
+else
+    check_failed "Python 3 not found"
+    echo "       Python 3 is required for testing scripts"
+    echo "       Install: brew install python3"
+fi
+echo ""
+
+# Check 6: Available simulators
+echo -e "${BLUE}[6/8]${NC} Checking available iOS Simulators..."
+if command -v xcrun &> /dev/null; then
+    SIMULATOR_COUNT=$(xcrun simctl list devices available 2>/dev/null | grep -c "iPhone\|iPad" || echo "0")
+
+    if [ "$SIMULATOR_COUNT" -gt 0 ]; then
+        check_passed "Found $SIMULATOR_COUNT available simulator(s)"
+
+        # Show first 5 simulators
+        echo ""
+        echo "       Available simulators (showing up to 5):"
+        xcrun simctl list devices available 2>/dev/null | grep "iPhone\|iPad" | head -5 | while read -r line; do
+            echo "       - $line"
+        done
+    else
+        check_warning "No simulators found"
+        echo "       Create simulators via Xcode or simctl"
+        echo "       Example: xcrun simctl create 'iPhone 15' 'iPhone 15'"
+    fi
+else
+    check_failed "Cannot check simulators (simctl not available)"
+fi
+echo ""
+
+# Check 7: Booted simulators
+echo -e "${BLUE}[7/8]${NC} Checking booted simulators..."
+if command -v xcrun &> /dev/null; then
+    BOOTED_SIMS=$(xcrun simctl list devices booted 2>/dev/null | grep -c "iPhone\|iPad" || echo "0")
+
+    if [ "$BOOTED_SIMS" -gt 0 ]; then
+        check_passed "$BOOTED_SIMS simulator(s) currently booted"
+
+        echo ""
+        echo "       Booted simulators:"
+        xcrun simctl list devices booted 2>/dev/null | grep "iPhone\|iPad" | while read -r line; do
+            echo "       - $line"
+        done
+    else
+        check_warning "No simulators currently booted"
+        echo "       Boot a simulator to begin testing"
+        echo "       Example: xcrun simctl boot <device-udid>"
+        echo "       Or: open -a Simulator"
+    fi
+else
+    check_failed "Cannot check booted simulators (simctl not available)"
+fi
+echo ""
+
+# Check 8: Required Python packages (optional check)
+echo -e "${BLUE}[8/8]${NC} Checking Python packages..."
+if command -v python3 &> /dev/null; then
+    MISSING_PACKAGES=()
+
+    # Check for PIL/Pillow (for visual_diff.py)
+    if python3 -c "import PIL" 2>/dev/null; then
+        check_passed "Pillow (PIL) installed - visual diff available"
+    else
+        MISSING_PACKAGES+=("pillow")
+        check_warning "Pillow (PIL) not installed - visual diff won't work"
+    fi
+
+    if [ ${#MISSING_PACKAGES[@]} -gt 0 ]; then
+        echo ""
+        echo "       Install missing packages:"
+        echo "       pip3 install ${MISSING_PACKAGES[*]}"
+    fi
+else
+    check_warning "Cannot check Python packages (Python 3 not available)"
+fi
+echo ""
+
+# Summary
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}  Summary${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+echo -e "Checks passed: ${GREEN}$CHECKS_PASSED${NC}"
+if [ "$CHECKS_FAILED" -gt 0 ]; then
+    echo -e "Checks failed: ${RED}$CHECKS_FAILED${NC}"
+    echo ""
+    echo -e "${YELLOW}Action required:${NC} Fix the failed checks above before testing"
+    exit 1
+else
+    echo ""
+    echo -e "${GREEN}✓ Environment is ready for iOS simulator testing${NC}"
+    echo ""
+    echo "Next steps:"
+    echo "  1. Boot a simulator: open -a Simulator"
+    echo "  2. Launch your app: xcrun simctl launch booted <bundle-id>"
+    echo "  3. Run accessibility audit: python scripts/accessibility_audit.py"
+    exit 0
+fi
@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+iOS Simulator Listing with Progressive Disclosure
+
+Lists available simulators with token-efficient summaries.
+Full details available on demand via cache IDs.
+
+Achieves 96% token reduction (57k→2k tokens) for common queries.
+
+Usage Examples:
+    # Concise summary (default)
+    python scripts/sim_list.py
+
+    # Get full details for cached list
+    python scripts/sim_list.py --get-details <cache-id>
+
+    # Get recommendations
+    python scripts/sim_list.py --suggest
+
+    # Filter by device type
+    python scripts/sim_list.py --device-type iPhone
+
+Output (default):
+    Simulator Summary [cache-sim-20251028-143052]
+    ├─ Total: 47 devices
+    ├─ Available: 31
+    └─ Booted: 1
+
+    ✓ iPhone 16 Pro (iOS 18.1) [ABC-123...]
+
+    Use --get-details cache-sim-20251028-143052 for full list
+
+Technical Details:
+- Uses xcrun simctl list devices
+- Caches results with 1-hour TTL
+- Reduces output by 96% by default
+- Token efficiency: summary = ~30 tokens, full list = ~1500 tokens
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from typing import Any
+
+from common import get_cache
+
+
+class SimulatorLister:
+    """Lists iOS simulators with progressive disclosure."""
+
+    def __init__(self):
+        """Initialize lister with cache."""
+        self.cache = get_cache()
+
+    def list_simulators(self) -> dict:
+        """
+        Get list of all simulators.
+
+        Returns:
+            Dict with structure:
+            {
+                "devices": [...],
+                "runtimes": [...],
+                "total_devices": int,
+                "available_devices": int,
+                "booted_devices": [...]
+            }
+        """
+        try:
+            result = subprocess.run(
+                ["xcrun", "simctl", "list", "devices", "--json"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            return json.loads(result.stdout)
+        except (subprocess.CalledProcessError, json.JSONDecodeError):
+            return {"devices": {}, "runtimes": []}
+
+    def parse_devices(self, sim_data: dict) -> list[dict]:
+        """
+        Parse simulator data into flat list.
+
+        Returns:
+            List of device dicts with runtime info
+        """
+        devices = []
+
+        devices_by_runtime = sim_data.get("devices", {})
+
+        for runtime_str, device_list in devices_by_runtime.items():
+            # Extract iOS version from runtime string
+            # Format: "iOS 18.1", "tvOS 18", etc.
+            runtime_name = runtime_str.replace(" Simulator", "").strip()
+
+            for device in device_list:
+                devices.append(
+                    {
+                        "name": device.get("name"),
+                        "udid": device.get("udid"),
+                        "state": device.get("state"),
+                        "runtime": runtime_name,
+                        "is_available": device.get("isAvailable", False),
+                    }
+                )
+
+        return devices
+
+    def get_concise_summary(self, devices: list[dict]) -> dict:
+        """
+        Generate concise summary with cache ID.
+
+        Returns 96% fewer tokens than full list.
+        """
+        booted = [d for d in devices if d["state"] == "Booted"]
+        available = [d for d in devices if d["is_available"]]
+        iphone = [d for d in available if "iPhone" in d["name"]]
+
+        # Cache full list for later retrieval
+        cache_id = self.cache.save(
+            {
+                "devices": devices,
+                "timestamp": __import__("datetime").datetime.now().isoformat(),
+            },
+            "simulator-list",
+        )
+
+        return {
+            "cache_id": cache_id,
+            "summary": {
+                "total_devices": len(devices),
+                "available_devices": len(available),
+                "booted_devices": len(booted),
+            },
+            "quick_access": {
+                "booted": booted[:3] if booted else [],
+                "recommended_iphone": iphone[:3] if iphone else [],
+            },
+        }
+
+    def get_full_list(
+        self,
+        cache_id: str,
+        device_type: str | None = None,
+        runtime: str | None = None,
+    ) -> list[dict] | None:
+        """
+        Retrieve full simulator list from cache.
+
+        Args:
+            cache_id: Cache ID from concise summary
+            device_type: Filter by type (iPhone, iPad, etc.)
+            runtime: Filter by iOS version
+
+        Returns:
+            List of devices matching filters
+        """
+        data = self.cache.get(cache_id)
+        if not data:
+            return None
+
+        devices = data.get("devices", [])
+
+        # Apply filters
+        if device_type:
+            devices = [d for d in devices if device_type in d["name"]]
+        if runtime:
+            devices = [d for d in devices if runtime.lower() in d["runtime"].lower()]
+
+        return devices
+
+    def suggest_simulators(self, limit: int = 4) -> list[dict]:
+        """
+        Get simulator recommendations.
+
+        Returns:
+            List of recommended simulators (best candidates for building)
+        """
+        all_sims = self.list_simulators()
+        devices = self.parse_devices(all_sims)
+
+        # Score devices for recommendations
+        scored = []
+        for device in devices:
+            score = 0
+
+            # Prefer booted
+            if device["state"] == "Booted":
+                score += 10
+            # Prefer available
+            if device["is_available"]:
+                score += 5
+            # Prefer recent iOS versions
+            ios_version = device["runtime"]
+            if "18" in ios_version:
+                score += 3
+            elif "17" in ios_version:
+                score += 2
+            # Prefer iPhones over other types
+            if "iPhone" in device["name"]:
+                score += 1
+
+            scored.append({"device": device, "score": score})
+
+        # Sort by score and return top N
+        scored.sort(key=lambda x: x["score"], reverse=True)
+        return [s["device"] for s in scored[:limit]]
+
+
+def format_device(device: dict) -> str:
+    """Format device for display."""
+    state_icon = "✓" if device["state"] == "Booted" else " "
+    avail_icon = "●" if device["is_available"] else "○"
+    name = device["name"]
+    runtime = device["runtime"]
+    udid_short = device["udid"][:8] + "..."
+    return f"{state_icon} {avail_icon} {name} ({runtime}) [{udid_short}]"
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="List iOS simulators with progressive disclosure")
+    parser.add_argument(
+        "--get-details",
+        metavar="CACHE_ID",
+        help="Get full details for cached simulator list",
+    )
+    parser.add_argument("--suggest", action="store_true", help="Get simulator recommendations")
+    parser.add_argument(
+        "--device-type",
+        help="Filter by device type (iPhone, iPad, Apple Watch, etc.)",
+    )
+    parser.add_argument("--runtime", help="Filter by iOS version (e.g., iOS-18, iOS-17)")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    lister = SimulatorLister()
+
+    # Get full list with details
+    if args.get_details:
+        devices = lister.get_full_list(
+            args.get_details, device_type=args.device_type, runtime=args.runtime
+        )
+
+        if devices is None:
+            print(f"Error: Cache ID not found or expired: {args.get_details}")
+            sys.exit(1)
+
+        if args.json:
+            print(json.dumps(devices, indent=2))
+        else:
+            print(f"Simulators ({len(devices)}):\n")
+            for device in devices:
+                print(f"  {format_device(device)}")
+
+    # Get recommendations
+    elif args.suggest:
+        suggestions = lister.suggest_simulators()
+
+        if args.json:
+            print(json.dumps(suggestions, indent=2))
+        else:
+            print("Recommended Simulators:\n")
+            for i, device in enumerate(suggestions, 1):
+                print(f"{i}. {format_device(device)}")
+
+    # Default: concise summary
+    else:
+        all_sims = lister.list_simulators()
+        devices = lister.parse_devices(all_sims)
+        summary = lister.get_concise_summary(devices)
+
+        if args.json:
+            print(json.dumps(summary, indent=2))
+        else:
+            # Human-readable concise output
+            cache_id = summary["cache_id"]
+            s = summary["summary"]
+            q = summary["quick_access"]
+
+            print(f"Simulator Summary [{cache_id}]")
+            print(f"├─ Total: {s['total_devices']} devices")
+            print(f"├─ Available: {s['available_devices']}")
+            print(f"└─ Booted: {s['booted_devices']}")
+
+            if q["booted"]:
+                print()
+                for device in q["booted"]:
+                    print(f"  {format_device(device)}")
+
+            print()
+            print(f"Use --get-details {cache_id} for full list")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""
+Boot iOS simulators and wait for readiness.
+
+This script boots one or more simulators and optionally waits for them to reach
+a ready state. It measures boot time and provides progress feedback.
+
+Key features:
+- Boot by UDID or device name
+- Wait for device readiness with configurable timeout
+- Measure boot performance
+- Batch boot operations (boot all, boot by type)
+- Progress reporting for CI/CD pipelines
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+from typing import Optional
+
+from common.device_utils import (
+    get_booted_device_udid,
+    list_simulators,
+    resolve_device_identifier,
+)
+
+
+class SimulatorBooter:
+    """Boot iOS simulators with optional readiness waiting."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize booter with optional device UDID."""
+        self.udid = udid
+
+    def boot(self, wait_ready: bool = False, timeout_seconds: int = 120) -> tuple[bool, str]:
+        """
+        Boot simulator and optionally wait for readiness.
+
+        Args:
+            wait_ready: Wait for device to be ready before returning
+            timeout_seconds: Maximum seconds to wait for readiness
+
+        Returns:
+            (success, message) tuple
+        """
+        if not self.udid:
+            return False, "Error: Device UDID not specified"
+
+        start_time = time.time()
+
+        # Check if already booted
+        try:
+            booted = get_booted_device_udid()
+            if booted == self.udid:
+                elapsed = time.time() - start_time
+                return True, (f"Device already booted: {self.udid} " f"[checked in {elapsed:.1f}s]")
+        except RuntimeError:
+            pass  # No booted device, proceed with boot
+
+        # Execute boot command
+        try:
+            cmd = ["xcrun", "simctl", "boot", self.udid]
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, timeout=30)
+
+            if result.returncode != 0:
+                error = result.stderr.strip()
+                return False, f"Boot failed: {error}"
+        except subprocess.TimeoutExpired:
+            return False, "Boot command timed out"
+        except Exception as e:
+            return False, f"Boot error: {e}"
+
+        # Optionally wait for readiness
+        if wait_ready:
+            ready, wait_message = self._wait_for_ready(timeout_seconds)
+            elapsed = time.time() - start_time
+            if ready:
+                return True, (f"Device booted and ready: {self.udid} " f"[{elapsed:.1f}s total]")
+            return False, wait_message
+
+        elapsed = time.time() - start_time
+        return True, (
+            f"Device booted: {self.udid} [boot in {elapsed:.1f}s] "
+            "(use --wait-ready to wait for availability)"
+        )
+
+    def _wait_for_ready(self, timeout_seconds: int = 120) -> tuple[bool, str]:
+        """
+        Wait for device to reach ready state.
+
+        Args:
+            timeout_seconds: Maximum seconds to wait
+
+        Returns:
+            (success, message) tuple
+        """
+        start_time = time.time()
+        poll_interval = 0.5
+        checks = 0
+
+        while time.time() - start_time < timeout_seconds:
+            try:
+                checks += 1
+                # Check if device responds to simctl commands
+                result = subprocess.run(
+                    ["xcrun", "simctl", "spawn", self.udid, "launchctl", "list"],
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+
+                if result.returncode == 0:
+                    elapsed = time.time() - start_time
+                    return True, (
+                        f"Device ready: {self.udid} " f"[{elapsed:.1f}s, {checks} checks]"
+                    )
+            except (subprocess.TimeoutExpired, RuntimeError):
+                pass  # Not ready yet
+
+            time.sleep(poll_interval)
+
+        elapsed = time.time() - start_time
+        return False, (
+            f"Boot timeout: Device did not reach ready state "
+            f"within {elapsed:.1f}s ({checks} checks)"
+        )
+
+    @staticmethod
+    def boot_all() -> tuple[int, int]:
+        """
+        Boot all available simulators.
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state="available")
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            booter = SimulatorBooter(udid=sim["udid"])
+            success, _message = booter.boot(wait_ready=False)
+            if success:
+                succeeded += 1
+            else:
+                failed += 1
+
+        return succeeded, failed
+
+    @staticmethod
+    def boot_by_type(device_type: str) -> tuple[int, int]:
+        """
+        Boot all simulators of a specific type.
+
+        Args:
+            device_type: Device type filter (e.g., "iPhone", "iPad")
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state="available")
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            if device_type.lower() in sim["name"].lower():
+                booter = SimulatorBooter(udid=sim["udid"])
+                success, _message = booter.boot(wait_ready=False)
+                if success:
+                    succeeded += 1
+                else:
+                    failed += 1
+
+        return succeeded, failed
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Boot iOS simulators and wait for readiness")
+    parser.add_argument(
+        "--udid",
+        help="Device UDID or name (required unless using --all or --type)",
+    )
+    parser.add_argument(
+        "--name",
+        help="Device name (alternative to --udid)",
+    )
+    parser.add_argument(
+        "--wait-ready",
+        action="store_true",
+        help="Wait for device to reach ready state",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=120,
+        help="Timeout for --wait-ready in seconds (default: 120)",
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Boot all available simulators",
+    )
+    parser.add_argument(
+        "--type",
+        help="Boot all simulators of a specific type (e.g., iPhone, iPad)",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+
+    args = parser.parse_args()
+
+    # Handle batch operations
+    if args.all:
+        succeeded, failed = SimulatorBooter.boot_all()
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "boot_all",
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Boot summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    if args.type:
+        succeeded, failed = SimulatorBooter.boot_by_type(args.type)
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "boot_by_type",
+                        "type": args.type,
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Boot {args.type} summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    # Resolve device identifier
+    device_id = args.udid or args.name
+    if not device_id:
+        print("Error: Specify --udid, --name, --all, or --type", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        udid = resolve_device_identifier(device_id)
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Boot device
+    booter = SimulatorBooter(udid=udid)
+    success, message = booter.boot(wait_ready=args.wait_ready, timeout_seconds=args.timeout)
+
+    if args.json:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "action": "boot",
+                    "device_id": device_id,
+                    "udid": udid,
+                    "success": success,
+                    "message": message,
+                }
+            )
+        )
+    else:
+        print(message)
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""
+Create iOS simulators dynamically.
+
+This script creates new simulators with specified device type and iOS version.
+Useful for CI/CD pipelines that need on-demand test device provisioning.
+
+Key features:
+- Create by device type (iPhone 16 Pro, iPad Air, etc.)
+- Specify iOS version (17.0, 18.0, etc.)
+- Custom device naming
+- Return newly created device UDID
+- List available device types and runtimes
+"""
+
+import argparse
+import subprocess
+import sys
+from typing import Optional
+
+from common.device_utils import list_simulators
+
+
+class SimulatorCreator:
+    """Create iOS simulators with specified configurations."""
+
+    def __init__(self):
+        """Initialize simulator creator."""
+        pass
+
+    def create(
+        self,
+        device_type: str,
+        ios_version: str | None = None,
+        custom_name: str | None = None,
+    ) -> tuple[bool, str, str | None]:
+        """
+        Create new iOS simulator.
+
+        Args:
+            device_type: Device type (e.g., "iPhone 16 Pro", "iPad Air")
+            ios_version: iOS version (e.g., "18.0"). If None, uses latest.
+            custom_name: Custom device name. If None, uses default.
+
+        Returns:
+            (success, message, new_udid) tuple
+        """
+        # Get available device types and runtimes
+        available_types = self._get_device_types()
+        if not available_types:
+            return False, "Failed to get available device types", None
+
+        # Normalize device type
+        device_type_id = None
+        for dt in available_types:
+            if device_type.lower() in dt["name"].lower():
+                device_type_id = dt["identifier"]
+                break
+
+        if not device_type_id:
+            return (
+                False,
+                f"Device type '{device_type}' not found. "
+                f"Use --list-devices for available types.",
+                None,
+            )
+
+        # Get available runtimes
+        available_runtimes = self._get_runtimes()
+        if not available_runtimes:
+            return False, "Failed to get available runtimes", None
+
+        # Resolve iOS version
+        runtime_id = None
+        if ios_version:
+            for rt in available_runtimes:
+                if ios_version in rt["name"]:
+                    runtime_id = rt["identifier"]
+                    break
+
+            if not runtime_id:
+                return (
+                    False,
+                    f"iOS version '{ios_version}' not found. "
+                    f"Use --list-runtimes for available versions.",
+                    None,
+                )
+        # Use latest runtime
+        elif available_runtimes:
+            runtime_id = available_runtimes[-1]["identifier"]
+
+        if not runtime_id:
+            return False, "No iOS runtime available", None
+
+        # Create device
+        try:
+            # Build device name
+            device_name = (
+                custom_name or f"{device_type_id.split('.')[-1]}-{ios_version or 'latest'}"
+            )
+
+            cmd = [
+                "xcrun",
+                "simctl",
+                "create",
+                device_name,
+                device_type_id,
+                runtime_id,
+            ]
+
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, timeout=60)
+
+            if result.returncode != 0:
+                error = result.stderr.strip() or result.stdout.strip()
+                return False, f"Creation failed: {error}", None
+
+            # Extract UDID from output
+            new_udid = result.stdout.strip()
+
+            return (
+                True,
+                f"Device created: {device_name} ({device_type}) iOS {ios_version or 'latest'} "
+                f"UDID: {new_udid}",
+                new_udid,
+            )
+
+        except subprocess.TimeoutExpired:
+            return False, "Creation command timed out", None
+        except Exception as e:
+            return False, f"Creation error: {e}", None
+
+    @staticmethod
+    def _get_device_types() -> list[dict]:
+        """
+        Get available device types.
+
+        Returns:
+            List of device type dicts with "name" and "identifier" keys
+        """
+        try:
+            cmd = ["xcrun", "simctl", "list", "devicetypes", "-j"]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            import json
+
+            data = json.loads(result.stdout)
+            devices = []
+
+            for device in data.get("devicetypes", []):
+                devices.append(
+                    {
+                        "name": device.get("name", ""),
+                        "identifier": device.get("identifier", ""),
+                    }
+                )
+
+            return devices
+        except Exception:
+            return []
+
+    @staticmethod
+    def _get_runtimes() -> list[dict]:
+        """
+        Get available iOS runtimes.
+
+        Returns:
+            List of runtime dicts with "name" and "identifier" keys
+        """
+        try:
+            cmd = ["xcrun", "simctl", "list", "runtimes", "-j"]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            import json
+
+            data = json.loads(result.stdout)
+            runtimes = []
+
+            for runtime in data.get("runtimes", []):
+                # Only include iOS runtimes (skip watchOS, tvOS, etc.)
+                identifier = runtime.get("identifier", "")
+                if "iOS" in identifier or "iOS" in runtime.get("name", ""):
+                    runtimes.append(
+                        {
+                            "name": runtime.get("name", ""),
+                            "identifier": runtime.get("identifier", ""),
+                        }
+                    )
+
+            # Sort by version number (latest first)
+            runtimes.sort(key=lambda r: r.get("identifier", ""), reverse=True)
+
+            return runtimes
+        except Exception:
+            return []
+
+    @staticmethod
+    def list_device_types() -> list[dict]:
+        """
+        List all available device types.
+
+        Returns:
+            List of device types with name and identifier
+        """
+        return SimulatorCreator._get_device_types()
+
+    @staticmethod
+    def list_runtimes() -> list[dict]:
+        """
+        List all available iOS runtimes.
+
+        Returns:
+            List of runtimes with name and identifier
+        """
+        return SimulatorCreator._get_runtimes()
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Create iOS simulators dynamically")
+    parser.add_argument(
+        "--device",
+        required=False,
+        help="Device type (e.g., 'iPhone 16 Pro', 'iPad Air')",
+    )
+    parser.add_argument(
+        "--runtime",
+        help="iOS version (e.g., '18.0', '17.0'). Defaults to latest.",
+    )
+    parser.add_argument(
+        "--name",
+        help="Custom device name. Defaults to auto-generated.",
+    )
+    parser.add_argument(
+        "--list-devices",
+        action="store_true",
+        help="List all available device types",
+    )
+    parser.add_argument(
+        "--list-runtimes",
+        action="store_true",
+        help="List all available iOS runtimes",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+
+    args = parser.parse_args()
+
+    creator = SimulatorCreator()
+
+    # Handle info queries
+    if args.list_devices:
+        devices = creator.list_device_types()
+        if args.json:
+            import json
+
+            print(json.dumps({"devices": devices}))
+        else:
+            print(f"Available device types ({len(devices)}):")
+            for dev in devices[:20]:  # Show first 20
+                print(f"  - {dev['name']}")
+            if len(devices) > 20:
+                print(f"  ... and {len(devices) - 20} more")
+        sys.exit(0)
+
+    if args.list_runtimes:
+        runtimes = creator.list_runtimes()
+        if args.json:
+            import json
+
+            print(json.dumps({"runtimes": runtimes}))
+        else:
+            print(f"Available iOS runtimes ({len(runtimes)}):")
+            for rt in runtimes:
+                print(f"  - {rt['name']}")
+        sys.exit(0)
+
+    # Create device
+    if not args.device:
+        print(
+            "Error: Specify --device, --list-devices, or --list-runtimes",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    success, message, new_udid = creator.create(
+        device_type=args.device,
+        ios_version=args.runtime,
+        custom_name=args.name,
+    )
+
+    if args.json:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "action": "create",
+                    "device_type": args.device,
+                    "runtime": args.runtime,
+                    "success": success,
+                    "message": message,
+                    "new_udid": new_udid,
+                }
+            )
+        )
+    else:
+        print(message)
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,357 @@
+#!/usr/bin/env python3
+"""
+Delete iOS simulators permanently.
+
+This script permanently removes simulators and frees disk space.
+Includes safety confirmation to prevent accidental deletion.
+
+Key features:
+- Delete by UDID or device name
+- Confirmation required for safety
+- Batch delete operations
+- Report freed disk space estimate
+"""
+
+import argparse
+import subprocess
+import sys
+from typing import Optional
+
+from common.device_utils import (
+    list_simulators,
+    resolve_device_identifier,
+)
+
+
+class SimulatorDeleter:
+    """Delete iOS simulators with safety confirmation."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize with optional device UDID."""
+        self.udid = udid
+
+    def delete(self, confirm: bool = False) -> tuple[bool, str]:
+        """
+        Delete simulator permanently.
+
+        Args:
+            confirm: Skip confirmation prompt (for batch operations)
+
+        Returns:
+            (success, message) tuple
+        """
+        if not self.udid:
+            return False, "Error: Device UDID not specified"
+
+        # Safety confirmation
+        if not confirm:
+            try:
+                response = input(
+                    f"Permanently delete simulator {self.udid}? " f"(type 'yes' to confirm): "
+                )
+                if response.lower() != "yes":
+                    return False, "Deletion cancelled by user"
+            except KeyboardInterrupt:
+                return False, "Deletion cancelled"
+
+        # Execute delete command
+        try:
+            cmd = ["xcrun", "simctl", "delete", self.udid]
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, timeout=60)
+
+            if result.returncode != 0:
+                error = result.stderr.strip() or result.stdout.strip()
+                return False, f"Deletion failed: {error}"
+
+            return True, f"Device deleted: {self.udid} [disk space freed]"
+
+        except subprocess.TimeoutExpired:
+            return False, "Deletion command timed out"
+        except Exception as e:
+            return False, f"Deletion error: {e}"
+
+    @staticmethod
+    def delete_all(confirm: bool = False) -> tuple[int, int]:
+        """
+        Delete all simulators permanently.
+
+        Args:
+            confirm: Skip confirmation prompt
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state=None)
+
+        if not confirm:
+            count = len(simulators)
+            try:
+                response = input(
+                    f"Permanently delete ALL {count} simulators? " f"(type 'yes' to confirm): "
+                )
+                if response.lower() != "yes":
+                    return 0, count
+            except KeyboardInterrupt:
+                return 0, count
+
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            deleter = SimulatorDeleter(udid=sim["udid"])
+            success, _message = deleter.delete(confirm=True)
+            if success:
+                succeeded += 1
+            else:
+                failed += 1
+
+        return succeeded, failed
+
+    @staticmethod
+    def delete_by_type(device_type: str, confirm: bool = False) -> tuple[int, int]:
+        """
+        Delete all simulators of a specific type.
+
+        Args:
+            device_type: Device type filter (e.g., "iPhone", "iPad")
+            confirm: Skip confirmation prompt
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state=None)
+        matching = [s for s in simulators if device_type.lower() in s["name"].lower()]
+
+        if not matching:
+            return 0, 0
+
+        if not confirm:
+            count = len(matching)
+            try:
+                response = input(
+                    f"Permanently delete {count} {device_type} simulators? "
+                    f"(type 'yes' to confirm): "
+                )
+                if response.lower() != "yes":
+                    return 0, count
+            except KeyboardInterrupt:
+                return 0, count
+
+        succeeded = 0
+        failed = 0
+
+        for sim in matching:
+            deleter = SimulatorDeleter(udid=sim["udid"])
+            success, _message = deleter.delete(confirm=True)
+            if success:
+                succeeded += 1
+            else:
+                failed += 1
+
+        return succeeded, failed
+
+    @staticmethod
+    def delete_old(keep_count: int = 3, confirm: bool = False) -> tuple[int, int]:
+        """
+        Delete older simulators, keeping most recent versions.
+
+        Useful for cleanup after testing multiple iOS versions.
+        Keeps the most recent N simulators of each type.
+
+        Args:
+            keep_count: Number of recent simulators to keep per type (default: 3)
+            confirm: Skip confirmation prompt
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state=None)
+
+        # Group by device type
+        by_type: dict[str, list] = {}
+        for sim in simulators:
+            dev_type = sim["type"]
+            if dev_type not in by_type:
+                by_type[dev_type] = []
+            by_type[dev_type].append(sim)
+
+        # Find candidates for deletion (older ones)
+        to_delete = []
+        for _dev_type, sims in by_type.items():
+            # Sort by runtime (iOS version) - keep newest
+            sorted_sims = sorted(sims, key=lambda s: s["runtime"], reverse=True)
+            # Mark older ones for deletion
+            to_delete.extend(sorted_sims[keep_count:])
+
+        if not to_delete:
+            return 0, 0
+
+        if not confirm:
+            count = len(to_delete)
+            try:
+                response = input(
+                    f"Delete {count} older simulators, keeping {keep_count} per type? "
+                    f"(type 'yes' to confirm): "
+                )
+                if response.lower() != "yes":
+                    return 0, count
+            except KeyboardInterrupt:
+                return 0, count
+
+        succeeded = 0
+        failed = 0
+
+        for sim in to_delete:
+            deleter = SimulatorDeleter(udid=sim["udid"])
+            success, _message = deleter.delete(confirm=True)
+            if success:
+                succeeded += 1
+            else:
+                failed += 1
+
+        return succeeded, failed
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Delete iOS simulators permanently")
+    parser.add_argument(
+        "--udid",
+        help="Device UDID or name (required unless using batch options)",
+    )
+    parser.add_argument(
+        "--name",
+        help="Device name (alternative to --udid)",
+    )
+    parser.add_argument(
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt",
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Delete all simulators",
+    )
+    parser.add_argument(
+        "--type",
+        help="Delete all simulators of a specific type (e.g., iPhone)",
+    )
+    parser.add_argument(
+        "--old",
+        type=int,
+        metavar="KEEP_COUNT",
+        help="Delete older simulators, keeping this many per type (e.g., --old 3)",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+
+    args = parser.parse_args()
+
+    # Handle batch operations
+    if args.all:
+        succeeded, failed = SimulatorDeleter.delete_all(confirm=args.yes)
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "delete_all",
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Delete summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    if args.type:
+        succeeded, failed = SimulatorDeleter.delete_by_type(args.type, confirm=args.yes)
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "delete_by_type",
+                        "type": args.type,
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Delete {args.type} summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    if args.old is not None:
+        succeeded, failed = SimulatorDeleter.delete_old(keep_count=args.old, confirm=args.yes)
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "delete_old",
+                        "keep_count": args.old,
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(
+                f"Delete old summary: {succeeded}/{total} succeeded, "
+                f"{failed} failed (kept {args.old} per type)"
+            )
+        sys.exit(0 if failed == 0 else 1)
+
+    # Delete single device
+    device_id = args.udid or args.name
+    if not device_id:
+        print("Error: Specify --udid, --name, --all, --type, or --old", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        udid = resolve_device_identifier(device_id)
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Delete device
+    deleter = SimulatorDeleter(udid=udid)
+    success, message = deleter.delete(confirm=args.yes)
+
+    if args.json:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "action": "delete",
+                    "device_id": device_id,
+                    "udid": udid,
+                    "success": success,
+                    "message": message,
+                }
+            )
+        )
+    else:
+        print(message)
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""
+Erase iOS simulators (factory reset).
+
+This script performs a factory reset on simulators, returning them to
+a clean state while preserving the device UUID. Much faster than
+delete + create for CI/CD cleanup.
+
+Key features:
+- Erase by UDID or device name
+- Preserve device UUID (faster than delete)
+- Verify erase completion
+- Batch erase operations (all, by type)
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+from typing import Optional
+
+from common.device_utils import (
+    list_simulators,
+    resolve_device_identifier,
+)
+
+
+class SimulatorEraser:
+    """Erase iOS simulators with optional verification."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize with optional device UDID."""
+        self.udid = udid
+
+    def erase(self, verify: bool = True, timeout_seconds: int = 30) -> tuple[bool, str]:
+        """
+        Erase simulator and optionally verify completion.
+
+        Performs a factory reset, clearing all app data and settings
+        while preserving the simulator UUID.
+
+        Args:
+            verify: Wait for erase to complete and verify state
+            timeout_seconds: Maximum seconds to wait for verification
+
+        Returns:
+            (success, message) tuple
+        """
+        if not self.udid:
+            return False, "Error: Device UDID not specified"
+
+        start_time = time.time()
+
+        # Execute erase command
+        try:
+            cmd = ["xcrun", "simctl", "erase", self.udid]
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, timeout=60)
+
+            if result.returncode != 0:
+                error = result.stderr.strip()
+                return False, f"Erase failed: {error}"
+        except subprocess.TimeoutExpired:
+            return False, "Erase command timed out"
+        except Exception as e:
+            return False, f"Erase error: {e}"
+
+        # Optionally verify erase completion
+        if verify:
+            ready, verify_message = self._verify_erase(timeout_seconds)
+            elapsed = time.time() - start_time
+            if ready:
+                return True, (
+                    f"Device erased: {self.udid} " f"[factory reset complete, {elapsed:.1f}s]"
+                )
+            return False, verify_message
+
+        elapsed = time.time() - start_time
+        return True, (
+            f"Device erase initiated: {self.udid} [{elapsed:.1f}s] "
+            "(use --verify to wait for completion)"
+        )
+
+    def _verify_erase(self, timeout_seconds: int = 30) -> tuple[bool, str]:
+        """
+        Verify erase has completed.
+
+        Polls device state to confirm erase finished successfully.
+
+        Args:
+            timeout_seconds: Maximum seconds to wait
+
+        Returns:
+            (success, message) tuple
+        """
+        start_time = time.time()
+        poll_interval = 0.5
+        checks = 0
+
+        while time.time() - start_time < timeout_seconds:
+            try:
+                checks += 1
+                # Check if device can be queried (indicates boot status)
+                result = subprocess.run(
+                    ["xcrun", "simctl", "spawn", self.udid, "launchctl", "list"],
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+
+                # Device responding = erase likely complete
+                if result.returncode == 0:
+                    elapsed = time.time() - start_time
+                    return True, (
+                        f"Erase verified: {self.udid} " f"[{elapsed:.1f}s, {checks} checks]"
+                    )
+            except (subprocess.TimeoutExpired, RuntimeError):
+                pass  # Not ready yet, keep polling
+
+            time.sleep(poll_interval)
+
+        elapsed = time.time() - start_time
+        return False, (
+            f"Erase verification timeout: Device did not respond "
+            f"within {elapsed:.1f}s ({checks} checks)"
+        )
+
+    @staticmethod
+    def erase_all() -> tuple[int, int]:
+        """
+        Erase all simulators (factory reset).
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state=None)
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            eraser = SimulatorEraser(udid=sim["udid"])
+            success, _message = eraser.erase(verify=False)
+            if success:
+                succeeded += 1
+            else:
+                failed += 1
+
+        return succeeded, failed
+
+    @staticmethod
+    def erase_by_type(device_type: str) -> tuple[int, int]:
+        """
+        Erase all simulators of a specific type.
+
+        Args:
+            device_type: Device type filter (e.g., "iPhone", "iPad")
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state=None)
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            if device_type.lower() in sim["name"].lower():
+                eraser = SimulatorEraser(udid=sim["udid"])
+                success, _message = eraser.erase(verify=False)
+                if success:
+                    succeeded += 1
+                else:
+                    failed += 1
+
+        return succeeded, failed
+
+    @staticmethod
+    def erase_booted() -> tuple[int, int]:
+        """
+        Erase all currently booted simulators.
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state="booted")
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            eraser = SimulatorEraser(udid=sim["udid"])
+            success, _message = eraser.erase(verify=False)
+            if success:
+                succeeded += 1
+            else:
+                failed += 1
+
+        return succeeded, failed
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Erase iOS simulators (factory reset)")
+    parser.add_argument(
+        "--udid",
+        help="Device UDID or name (required unless using --all, --type, or --booted)",
+    )
+    parser.add_argument(
+        "--name",
+        help="Device name (alternative to --udid)",
+    )
+    parser.add_argument(
+        "--verify",
+        action="store_true",
+        help="Wait for erase to complete and verify state",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=30,
+        help="Timeout for --verify in seconds (default: 30)",
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Erase all simulators (factory reset)",
+    )
+    parser.add_argument(
+        "--type",
+        help="Erase all simulators of a specific type (e.g., iPhone)",
+    )
+    parser.add_argument(
+        "--booted",
+        action="store_true",
+        help="Erase all currently booted simulators",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+
+    args = parser.parse_args()
+
+    # Handle batch operations
+    if args.all:
+        succeeded, failed = SimulatorEraser.erase_all()
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "erase_all",
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Erase summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    if args.type:
+        succeeded, failed = SimulatorEraser.erase_by_type(args.type)
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "erase_by_type",
+                        "type": args.type,
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Erase {args.type} summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    if args.booted:
+        succeeded, failed = SimulatorEraser.erase_booted()
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "erase_booted",
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Erase booted summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    # Erase single device
+    device_id = args.udid or args.name
+    if not device_id:
+        print("Error: Specify --udid, --name, --all, --type, or --booted", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        udid = resolve_device_identifier(device_id)
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Erase device
+    eraser = SimulatorEraser(udid=udid)
+    success, message = eraser.erase(verify=args.verify, timeout_seconds=args.timeout)
+
+    if args.json:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "action": "erase",
+                    "device_id": device_id,
+                    "udid": udid,
+                    "success": success,
+                    "message": message,
+                }
+            )
+        )
+    else:
+        print(message)
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""
+Shutdown iOS simulators with optional state verification.
+
+This script shuts down one or more running simulators and optionally
+verifies completion. Supports batch operations for efficient cleanup.
+
+Key features:
+- Shutdown by UDID or device name
+- Verify shutdown completion with timeout
+- Batch shutdown operations (all, by type)
+- Progress reporting for CI/CD pipelines
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+from typing import Optional
+
+from common.device_utils import (
+    list_simulators,
+    resolve_device_identifier,
+)
+
+
+class SimulatorShutdown:
+    """Shutdown iOS simulators with optional verification."""
+
+    def __init__(self, udid: str | None = None):
+        """Initialize with optional device UDID."""
+        self.udid = udid
+
+    def shutdown(self, verify: bool = True, timeout_seconds: int = 30) -> tuple[bool, str]:
+        """
+        Shutdown simulator and optionally verify completion.
+
+        Args:
+            verify: Wait for shutdown to complete
+            timeout_seconds: Maximum seconds to wait for shutdown
+
+        Returns:
+            (success, message) tuple
+        """
+        if not self.udid:
+            return False, "Error: Device UDID not specified"
+
+        start_time = time.time()
+
+        # Check if already shutdown
+        simulators = list_simulators(state="booted")
+        if not any(s["udid"] == self.udid for s in simulators):
+            elapsed = time.time() - start_time
+            return True, (f"Device already shutdown: {self.udid} " f"[checked in {elapsed:.1f}s]")
+
+        # Execute shutdown command
+        try:
+            cmd = ["xcrun", "simctl", "shutdown", self.udid]
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, timeout=30)
+
+            if result.returncode != 0:
+                error = result.stderr.strip()
+                return False, f"Shutdown failed: {error}"
+        except subprocess.TimeoutExpired:
+            return False, "Shutdown command timed out"
+        except Exception as e:
+            return False, f"Shutdown error: {e}"
+
+        # Optionally verify shutdown
+        if verify:
+            ready, verify_message = self._verify_shutdown(timeout_seconds)
+            elapsed = time.time() - start_time
+            if ready:
+                return True, (f"Device shutdown confirmed: {self.udid} " f"[{elapsed:.1f}s total]")
+            return False, verify_message
+
+        elapsed = time.time() - start_time
+        return True, (
+            f"Device shutdown: {self.udid} [{elapsed:.1f}s] "
+            "(use --verify to wait for confirmation)"
+        )
+
+    def _verify_shutdown(self, timeout_seconds: int = 30) -> tuple[bool, str]:
+        """
+        Verify device has fully shutdown.
+
+        Args:
+            timeout_seconds: Maximum seconds to wait
+
+        Returns:
+            (success, message) tuple
+        """
+        start_time = time.time()
+        poll_interval = 0.5
+        checks = 0
+
+        while time.time() - start_time < timeout_seconds:
+            try:
+                checks += 1
+                # Check booted devices
+                simulators = list_simulators(state="booted")
+                if not any(s["udid"] == self.udid for s in simulators):
+                    elapsed = time.time() - start_time
+                    return True, (
+                        f"Device shutdown verified: {self.udid} "
+                        f"[{elapsed:.1f}s, {checks} checks]"
+                    )
+            except RuntimeError:
+                pass  # Error checking, retry
+
+            time.sleep(poll_interval)
+
+        elapsed = time.time() - start_time
+        return False, (
+            f"Shutdown verification timeout: Device did not fully shutdown "
+            f"within {elapsed:.1f}s ({checks} checks)"
+        )
+
+    @staticmethod
+    def shutdown_all() -> tuple[int, int]:
+        """
+        Shutdown all booted simulators.
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state="booted")
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            shutdown = SimulatorShutdown(udid=sim["udid"])
+            success, _message = shutdown.shutdown(verify=False)
+            if success:
+                succeeded += 1
+            else:
+                failed += 1
+
+        return succeeded, failed
+
+    @staticmethod
+    def shutdown_by_type(device_type: str) -> tuple[int, int]:
+        """
+        Shutdown all booted simulators of a specific type.
+
+        Args:
+            device_type: Device type filter (e.g., "iPhone", "iPad")
+
+        Returns:
+            (succeeded, failed) tuple with counts
+        """
+        simulators = list_simulators(state="booted")
+        succeeded = 0
+        failed = 0
+
+        for sim in simulators:
+            if device_type.lower() in sim["name"].lower():
+                shutdown = SimulatorShutdown(udid=sim["udid"])
+                success, _message = shutdown.shutdown(verify=False)
+                if success:
+                    succeeded += 1
+                else:
+                    failed += 1
+
+        return succeeded, failed
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Shutdown iOS simulators with optional verification"
+    )
+    parser.add_argument(
+        "--udid",
+        help="Device UDID or name (required unless using --all or --type)",
+    )
+    parser.add_argument(
+        "--name",
+        help="Device name (alternative to --udid)",
+    )
+    parser.add_argument(
+        "--verify",
+        action="store_true",
+        help="Wait for shutdown to complete and verify state",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=30,
+        help="Timeout for --verify in seconds (default: 30)",
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Shutdown all booted simulators",
+    )
+    parser.add_argument(
+        "--type",
+        help="Shutdown all booted simulators of a specific type (e.g., iPhone)",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+
+    args = parser.parse_args()
+
+    # Handle batch operations
+    if args.all:
+        succeeded, failed = SimulatorShutdown.shutdown_all()
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "shutdown_all",
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(f"Shutdown summary: {succeeded}/{total} succeeded, " f"{failed} failed")
+        sys.exit(0 if failed == 0 else 1)
+
+    if args.type:
+        succeeded, failed = SimulatorShutdown.shutdown_by_type(args.type)
+        if args.json:
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "action": "shutdown_by_type",
+                        "type": args.type,
+                        "succeeded": succeeded,
+                        "failed": failed,
+                        "total": succeeded + failed,
+                    }
+                )
+            )
+        else:
+            total = succeeded + failed
+            print(
+                f"Shutdown {args.type} summary: {succeeded}/{total} succeeded, " f"{failed} failed"
+            )
+        sys.exit(0 if failed == 0 else 1)
+
+    # Resolve device identifier
+    device_id = args.udid or args.name
+    if not device_id:
+        print("Error: Specify --udid, --name, --all, or --type", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        udid = resolve_device_identifier(device_id)
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Shutdown device
+    shutdown = SimulatorShutdown(udid=udid)
+    success, message = shutdown.shutdown(verify=args.verify, timeout_seconds=args.timeout)
+
+    if args.json:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "action": "shutdown",
+                    "device_id": device_id,
+                    "udid": udid,
+                    "success": success,
+                    "message": message,
+                }
+            )
+        )
+    else:
+        print(message)
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+"""
+Intelligent Simulator Selector
+
+Suggests the best available iOS simulators based on:
+- Recently used (from config)
+- Latest iOS version
+- Common models for testing
+- Boot status
+
+Usage Examples:
+    # Get suggestions for user selection
+    python scripts/simulator_selector.py --suggest
+
+    # List all available simulators
+    python scripts/simulator_selector.py --list
+
+    # Boot a specific simulator
+    python scripts/simulator_selector.py --boot "67A99DF0-27BD-4507-A3DE-B7D8C38F764A"
+
+    # Get suggestions as JSON for programmatic use
+    python scripts/simulator_selector.py --suggest --json
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+# Try to import config from build_and_test if available
+try:
+    from xcode.config import Config
+except ImportError:
+    Config = None
+
+
+class SimulatorInfo:
+    """Information about an iOS simulator."""
+
+    def __init__(
+        self,
+        name: str,
+        udid: str,
+        ios_version: str,
+        status: str,
+    ):
+        """Initialize simulator info."""
+        self.name = name
+        self.udid = udid
+        self.ios_version = ios_version
+        self.status = status
+        self.reasons: list[str] = []
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "device": self.name,
+            "udid": self.udid,
+            "ios": self.ios_version,
+            "status": self.status,
+            "reasons": self.reasons,
+        }
+
+
+class SimulatorSelector:
+    """Intelligent simulator selection."""
+
+    # Common iPhone models ranked by testing priority
+    COMMON_MODELS = [
+        "iPhone 16 Pro",
+        "iPhone 16",
+        "iPhone 15 Pro",
+        "iPhone 15",
+        "iPhone SE (3rd generation)",
+    ]
+
+    def __init__(self):
+        """Initialize selector."""
+        self.simulators: list[SimulatorInfo] = []
+        self.config: dict | None = None
+        self.last_used_simulator: str | None = None
+
+        # Load config if available
+        if Config:
+            try:
+                config = Config.load()
+                self.last_used_simulator = config.get_preferred_simulator()
+            except Exception:
+                pass
+
+    def list_simulators(self) -> list[SimulatorInfo]:
+        """
+        List all available simulators.
+
+        Returns:
+            List of SimulatorInfo objects
+        """
+        try:
+            result = subprocess.run(
+                ["xcrun", "simctl", "list", "devices", "--json"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            data = json.loads(result.stdout)
+            simulators = []
+
+            # Parse devices by iOS version
+            for runtime, devices in data.get("devices", {}).items():
+                # Extract iOS version from runtime (e.g., "com.apple.CoreSimulator.SimRuntime.iOS-18-0")
+                ios_version_match = re.search(r"iOS-(\d+-\d+)", runtime)
+                if not ios_version_match:
+                    continue
+
+                ios_version = ios_version_match.group(1).replace("-", ".")
+
+                for device in devices:
+                    name = device.get("name", "")
+                    udid = device.get("udid", "")
+                    is_available = device.get("isAvailable", False)
+
+                    if not is_available or "iPhone" not in name:
+                        continue
+
+                    status = device.get("state", "").capitalize()
+                    sim_info = SimulatorInfo(name, udid, ios_version, status)
+                    simulators.append(sim_info)
+
+            self.simulators = simulators
+            return simulators
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error listing simulators: {e.stderr}", file=sys.stderr)
+            return []
+        except json.JSONDecodeError as e:
+            print(f"Error parsing simulator list: {e}", file=sys.stderr)
+            return []
+
+    def get_suggestions(self, count: int = 4) -> list[SimulatorInfo]:
+        """
+        Get top N suggested simulators.
+
+        Ranking factors:
+        1. Recently used (from config)
+        2. Latest iOS version
+        3. Common models
+        4. Boot status (Booted preferred)
+
+        Args:
+            count: Number of suggestions to return
+
+        Returns:
+            List of suggested SimulatorInfo objects
+        """
+        if not self.simulators:
+            return []
+
+        # Score each simulator
+        scored = []
+        for sim in self.simulators:
+            score = self._score_simulator(sim)
+            scored.append((score, sim))
+
+        # Sort by score (descending)
+        scored.sort(key=lambda x: x[0], reverse=True)
+
+        # Return top N
+        suggestions = [sim for _, sim in scored[:count]]
+
+        # Add reasons to each suggestion
+        for i, sim in enumerate(suggestions, 1):
+            if i == 1:
+                sim.reasons.append("Recommended")
+
+            # Check if recently used
+            if self.last_used_simulator and self.last_used_simulator == sim.name:
+                sim.reasons.append("Recently used")
+
+            # Check if latest iOS
+            latest_ios = max(s.ios_version for s in self.simulators)
+            if sim.ios_version == latest_ios:
+                sim.reasons.append("Latest iOS")
+
+            # Check if common model
+            for j, model in enumerate(self.COMMON_MODELS):
+                if model in sim.name:
+                    sim.reasons.append(f"#{j+1} common model")
+                    break
+
+            # Check if booted
+            if sim.status == "Booted":
+                sim.reasons.append("Currently running")
+
+        return suggestions
+
+    def _score_simulator(self, sim: SimulatorInfo) -> float:
+        """
+        Score a simulator for ranking.
+
+        Higher score = better recommendation.
+
+        Args:
+            sim: Simulator to score
+
+        Returns:
+            Score value
+        """
+        score = 0.0
+
+        # Recently used gets highest priority (100 points)
+        if self.last_used_simulator and self.last_used_simulator == sim.name:
+            score += 100
+
+        # Latest iOS version (50 points)
+        latest_ios = max(s.ios_version for s in self.simulators)
+        if sim.ios_version == latest_ios:
+            score += 50
+
+        # Common models (30-20 points based on ranking)
+        for i, model in enumerate(self.COMMON_MODELS):
+            if model in sim.name:
+                score += 30 - (i * 2)  # Higher ranking models get more points
+                break
+
+        # Currently booted (10 points)
+        if sim.status == "Booted":
+            score += 10
+
+        # iOS version number (minor factor for breaking ties)
+        ios_numeric = float(sim.ios_version.replace(".", ""))
+        score += ios_numeric * 0.1
+
+        return score
+
+    def boot_simulator(self, udid: str) -> bool:
+        """
+        Boot a simulator.
+
+        Args:
+            udid: Simulator UDID
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            subprocess.run(
+                ["xcrun", "simctl", "boot", udid],
+                capture_output=True,
+                check=True,
+            )
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"Error booting simulator: {e.stderr}", file=sys.stderr)
+            return False
+
+
+def format_suggestions(suggestions: list[SimulatorInfo], json_format: bool = False) -> str:
+    """
+    Format suggestions for output.
+
+    Args:
+        suggestions: List of suggestions
+        json_format: If True, output as JSON
+
+    Returns:
+        Formatted string
+    """
+    if json_format:
+        data = {"suggestions": [s.to_dict() for s in suggestions]}
+        return json.dumps(data, indent=2)
+
+    if not suggestions:
+        return "No simulators available"
+
+    lines = ["Available Simulators:\n"]
+    for i, sim in enumerate(suggestions, 1):
+        lines.append(f"{i}. {sim.name} (iOS {sim.ios_version})")
+        if sim.reasons:
+            lines.append(f"   {', '.join(sim.reasons)}")
+        lines.append(f"   UDID: {sim.udid}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Intelligent iOS simulator selector",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Get suggestions for user selection
+  python scripts/simulator_selector.py --suggest
+
+  # List all available simulators
+  python scripts/simulator_selector.py --list
+
+  # Boot a specific simulator
+  python scripts/simulator_selector.py --boot <UDID>
+
+  # Get suggestions as JSON
+  python scripts/simulator_selector.py --suggest --json
+        """,
+    )
+
+    parser.add_argument(
+        "--suggest",
+        action="store_true",
+        help="Get top simulator suggestions",
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help="List all available simulators",
+    )
+    parser.add_argument(
+        "--boot",
+        metavar="UDID",
+        help="Boot specific simulator by UDID",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+    parser.add_argument(
+        "--count",
+        type=int,
+        default=4,
+        help="Number of suggestions (default: 4)",
+    )
+
+    args = parser.parse_args()
+
+    selector = SimulatorSelector()
+
+    if args.boot:
+        # Boot specific simulator
+        success = selector.boot_simulator(args.boot)
+        if success:
+            print(f"Booted simulator: {args.boot}")
+            return 0
+        return 1
+
+    if args.list:
+        # List all simulators
+        simulators = selector.list_simulators()
+        output = format_suggestions(simulators, args.json)
+        print(output)
+        return 0
+
+    if args.suggest:
+        # Get suggestions
+        selector.list_simulators()
+        suggestions = selector.get_suggestions(args.count)
+        output = format_suggestions(suggestions, args.json)
+        print(output)
+        return 0
+
+    # Default: show suggestions
+    selector.list_simulators()
+    suggestions = selector.get_suggestions(args.count)
+    output = format_suggestions(suggestions, args.json)
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+iOS Status Bar Controller
+
+Override simulator status bar for clean screenshots and testing.
+Control time, network, wifi, battery display.
+
+Usage: python scripts/status_bar.py --preset clean
+"""
+
+import argparse
+import subprocess
+import sys
+
+from common import resolve_udid
+
+
+class StatusBarController:
+    """Controls iOS simulator status bar appearance."""
+
+    # Preset configurations
+    PRESETS = {
+        "clean": {
+            "time": "9:41",
+            "data_network": "5g",
+            "wifi_mode": "active",
+            "battery_state": "charged",
+            "battery_level": 100,
+        },
+        "testing": {
+            "time": "11:11",
+            "data_network": "4g",
+            "wifi_mode": "active",
+            "battery_state": "discharging",
+            "battery_level": 50,
+        },
+        "low_battery": {
+            "time": "9:41",
+            "data_network": "5g",
+            "wifi_mode": "active",
+            "battery_state": "discharging",
+            "battery_level": 20,
+        },
+        "airplane": {
+            "time": "9:41",
+            "data_network": "none",
+            "wifi_mode": "failed",
+            "battery_state": "charged",
+            "battery_level": 100,
+        },
+    }
+
+    def __init__(self, udid: str | None = None):
+        """Initialize status bar controller.
+
+        Args:
+            udid: Optional device UDID (auto-detects booted simulator if None)
+        """
+        self.udid = udid
+
+    def override(
+        self,
+        time: str | None = None,
+        data_network: str | None = None,
+        wifi_mode: str | None = None,
+        battery_state: str | None = None,
+        battery_level: int | None = None,
+    ) -> bool:
+        """
+        Override status bar appearance.
+
+        Args:
+            time: Time in HH:MM format (e.g., "9:41")
+            data_network: Network type (none, 1x, 3g, 4g, 5g, lte, lte-a)
+            wifi_mode: WiFi state (active, searching, failed)
+            battery_state: Battery state (charging, charged, discharging)
+            battery_level: Battery percentage (0-100)
+
+        Returns:
+            Success status
+        """
+        cmd = ["xcrun", "simctl", "status_bar"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.append("override")
+
+        # Add parameters if provided
+        if time:
+            cmd.extend(["--time", time])
+        if data_network:
+            cmd.extend(["--dataNetwork", data_network])
+        if wifi_mode:
+            cmd.extend(["--wifiMode", wifi_mode])
+        if battery_state:
+            cmd.extend(["--batteryState", battery_state])
+        if battery_level is not None:
+            cmd.extend(["--batteryLevel", str(battery_level)])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def clear(self) -> bool:
+        """
+        Clear status bar override and restore defaults.
+
+        Returns:
+            Success status
+        """
+        cmd = ["xcrun", "simctl", "status_bar"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.append("clear")
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Override iOS simulator status bar for screenshots and testing"
+    )
+
+    # Preset option
+    parser.add_argument(
+        "--preset",
+        choices=list(StatusBarController.PRESETS.keys()),
+        help="Use preset configuration (clean, testing, low-battery, airplane)",
+    )
+
+    # Custom options
+    parser.add_argument(
+        "--time",
+        help="Override time (HH:MM format, e.g., '9:41')",
+    )
+    parser.add_argument(
+        "--data-network",
+        choices=["none", "1x", "3g", "4g", "5g", "lte", "lte-a"],
+        help="Data network type",
+    )
+    parser.add_argument(
+        "--wifi-mode",
+        choices=["active", "searching", "failed"],
+        help="WiFi state",
+    )
+    parser.add_argument(
+        "--battery-state",
+        choices=["charging", "charged", "discharging"],
+        help="Battery state",
+    )
+    parser.add_argument(
+        "--battery-level",
+        type=int,
+        help="Battery level 0-100",
+    )
+
+    # Other options
+    parser.add_argument(
+        "--clear",
+        action="store_true",
+        help="Clear status bar override and restore defaults",
+    )
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    controller = StatusBarController(udid=udid)
+
+    # Clear mode
+    if args.clear:
+        if controller.clear():
+            print("Status bar override cleared - defaults restored")
+        else:
+            print("Failed to clear status bar override")
+            sys.exit(1)
+
+    # Preset mode
+    elif args.preset:
+        preset = StatusBarController.PRESETS[args.preset]
+        if controller.override(**preset):
+            print(f"Status bar: {args.preset} preset applied")
+            print(
+                f"  Time: {preset['time']}, "
+                f"Network: {preset['data_network']}, "
+                f"Battery: {preset['battery_level']}%"
+            )
+        else:
+            print(f"Failed to apply {args.preset} preset")
+            sys.exit(1)
+
+    # Custom mode
+    elif any(
+        [
+            args.time,
+            args.data_network,
+            args.wifi_mode,
+            args.battery_state,
+            args.battery_level is not None,
+        ]
+    ):
+        if controller.override(
+            time=args.time,
+            data_network=args.data_network,
+            wifi_mode=args.wifi_mode,
+            battery_state=args.battery_state,
+            battery_level=args.battery_level,
+        ):
+            output = "Status bar override applied:"
+            if args.time:
+                output += f" Time={args.time}"
+            if args.data_network:
+                output += f" Network={args.data_network}"
+            if args.battery_level is not None:
+                output += f" Battery={args.battery_level}%"
+            print(output)
+        else:
+            print("Failed to override status bar")
+            sys.exit(1)
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Test Recorder for iOS Simulator Testing
+
+Records test execution with automatic screenshots and documentation.
+Optimized for minimal token output during execution.
+
+Usage:
+    As a script: python scripts/test_recorder.py --test-name "Test Name" --output dir/
+    As a module: from scripts.test_recorder import TestRecorder
+"""
+
+import argparse
+import json
+import subprocess
+import time
+from datetime import datetime
+from pathlib import Path
+
+from common import (
+    capture_screenshot,
+    count_elements,
+    generate_screenshot_name,
+    get_accessibility_tree,
+    resolve_udid,
+)
+
+
+class TestRecorder:
+    """Records test execution with screenshots and accessibility snapshots."""
+
+    def __init__(
+        self,
+        test_name: str,
+        output_dir: str = "test-artifacts",
+        udid: str | None = None,
+        inline: bool = False,
+        screenshot_size: str = "half",
+        app_name: str | None = None,
+    ):
+        """
+        Initialize test recorder.
+
+        Args:
+            test_name: Name of the test being recorded
+            output_dir: Directory for test artifacts
+            udid: Optional device UDID (uses booted if not specified)
+            inline: If True, return screenshots as base64 (for vision-based automation)
+            screenshot_size: 'full', 'half', 'quarter', 'thumb' (default: 'half')
+            app_name: App name for semantic screenshot naming
+        """
+        self.test_name = test_name
+        self.udid = udid
+        self.inline = inline
+        self.screenshot_size = screenshot_size
+        self.app_name = app_name
+        self.start_time = time.time()
+        self.steps: list[dict] = []
+        self.current_step = 0
+
+        # Create timestamped output directory
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        safe_name = test_name.lower().replace(" ", "-")
+        self.output_dir = Path(output_dir) / f"{safe_name}-{timestamp}"
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create subdirectories (only if not in inline mode)
+        if not inline:
+            self.screenshots_dir = self.output_dir / "screenshots"
+            self.screenshots_dir.mkdir(exist_ok=True)
+        else:
+            self.screenshots_dir = None
+
+        self.accessibility_dir = self.output_dir / "accessibility"
+        self.accessibility_dir.mkdir(exist_ok=True)
+
+        # Token-efficient output
+        mode_str = "(inline mode)" if inline else ""
+        print(f"Recording: {test_name} {mode_str}")
+        print(f"Output: {self.output_dir}/")
+
+    def step(
+        self,
+        description: str,
+        screen_name: str | None = None,
+        state: str | None = None,
+        assertion: str | None = None,
+        metadata: dict | None = None,
+    ):
+        """
+        Record a test step with automatic screenshot.
+
+        Args:
+            description: Step description
+            screen_name: Screen name for semantic naming
+            state: State description for semantic naming
+            assertion: Optional assertion to verify
+            metadata: Optional metadata for the step
+        """
+        self.current_step += 1
+        step_time = time.time() - self.start_time
+
+        # Capture screenshot using new utility
+        screenshot_result = capture_screenshot(
+            self.udid,
+            size=self.screenshot_size,
+            inline=self.inline,
+            app_name=self.app_name,
+            screen_name=screen_name or description,
+            state=state,
+        )
+
+        # Capture accessibility tree
+        accessibility_path = (
+            self.accessibility_dir
+            / f"{self.current_step:03d}-{description.lower().replace(' ', '-')[:20]}.json"
+        )
+        element_count = self._capture_accessibility(accessibility_path)
+
+        # Store step data
+        step_data = {
+            "number": self.current_step,
+            "description": description,
+            "timestamp": step_time,
+            "element_count": element_count,
+            "accessibility": accessibility_path.name,
+            "screenshot_mode": screenshot_result["mode"],
+            "screenshot_size": self.screenshot_size,
+        }
+
+        # Handle screenshot data based on mode
+        if screenshot_result["mode"] == "file":
+            step_data["screenshot"] = screenshot_result["file_path"]
+            step_data["screenshot_name"] = Path(screenshot_result["file_path"]).name
+        else:
+            # Inline mode
+            step_data["screenshot_base64"] = screenshot_result["base64_data"]
+            step_data["screenshot_dimensions"] = (
+                screenshot_result["width"],
+                screenshot_result["height"],
+            )
+
+        if assertion:
+            step_data["assertion"] = assertion
+            step_data["assertion_passed"] = True
+
+        if metadata:
+            step_data["metadata"] = metadata
+
+        self.steps.append(step_data)
+
+        # Token-efficient output (single line)
+        status = "✓" if not assertion or step_data.get("assertion_passed") else "✗"
+        screenshot_info = (
+            f" [{screenshot_result['width']}x{screenshot_result['height']}]" if self.inline else ""
+        )
+        print(
+            f"{status} Step {self.current_step}: {description} ({step_time:.1f}s){screenshot_info}"
+        )
+
+    def _capture_screenshot(self, output_path: Path) -> bool:
+        """Capture screenshot using simctl."""
+        cmd = ["xcrun", "simctl", "io"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.extend(["screenshot", str(output_path)])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def _capture_accessibility(self, output_path: Path) -> int:
+        """Capture accessibility tree and return element count."""
+        try:
+            # Use shared utility to fetch tree
+            tree = get_accessibility_tree(self.udid, nested=True)
+
+            # Save tree
+            with open(output_path, "w") as f:
+                json.dump(tree, f, indent=2)
+
+            # Count elements using shared utility
+            return count_elements(tree)
+        except Exception:
+            return 0
+
+    def generate_report(self) -> dict[str, str]:
+        """
+        Generate markdown test report.
+
+        Returns:
+            Dictionary with paths to generated files
+        """
+        duration = time.time() - self.start_time
+        report_path = self.output_dir / "report.md"
+
+        # Generate markdown
+        with open(report_path, "w") as f:
+            f.write(f"# Test Report: {self.test_name}\n\n")
+            f.write(f"**Date:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"**Duration:** {duration:.1f} seconds\n")
+            f.write(f"**Steps:** {len(self.steps)}\n\n")
+
+            # Steps section
+            f.write("## Test Steps\n\n")
+            for step in self.steps:
+                f.write(
+                    f"### Step {step['number']}: {step['description']} ({step['timestamp']:.1f}s)\n\n"
+                )
+                f.write(f"![Screenshot](screenshots/{step['screenshot']})\n\n")
+
+                if step.get("assertion"):
+                    status = "✓" if step.get("assertion_passed") else "✗"
+                    f.write(f"**Assertion:** {step['assertion']} {status}\n\n")
+
+                if step.get("metadata"):
+                    f.write("**Metadata:**\n")
+                    for key, value in step["metadata"].items():
+                        f.write(f"- {key}: {value}\n")
+                    f.write("\n")
+
+                f.write(f"**Accessibility Elements:** {step['element_count']}\n\n")
+                f.write("---\n\n")
+
+            # Summary
+            f.write("## Summary\n\n")
+            f.write(f"- Total steps: {len(self.steps)}\n")
+            f.write(f"- Duration: {duration:.1f}s\n")
+            f.write(f"- Screenshots: {len(self.steps)}\n")
+            f.write(f"- Accessibility snapshots: {len(self.steps)}\n")
+
+        # Save metadata JSON
+        metadata_path = self.output_dir / "metadata.json"
+        with open(metadata_path, "w") as f:
+            json.dump(
+                {
+                    "test_name": self.test_name,
+                    "duration": duration,
+                    "steps": self.steps,
+                    "timestamp": datetime.now().isoformat(),
+                },
+                f,
+                indent=2,
+            )
+
+        # Token-efficient output
+        print(f"Report: {report_path}")
+
+        return {
+            "markdown_path": str(report_path),
+            "metadata_path": str(metadata_path),
+            "output_dir": str(self.output_dir),
+        }
+
+
+def main():
+    """Main entry point for command-line usage."""
+    parser = argparse.ArgumentParser(
+        description="Record test execution with screenshots and documentation"
+    )
+    parser.add_argument("--test-name", required=True, help="Name of the test being recorded")
+    parser.add_argument(
+        "--output", default="test-artifacts", help="Output directory for test artifacts"
+    )
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+    parser.add_argument(
+        "--inline",
+        action="store_true",
+        help="Return screenshots as base64 (inline mode for vision-based automation)",
+    )
+    parser.add_argument(
+        "--size",
+        choices=["full", "half", "quarter", "thumb"],
+        default="half",
+        help="Screenshot size for token optimization (default: half)",
+    )
+    parser.add_argument("--app-name", help="App name for semantic screenshot naming")
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        import sys
+
+        sys.exit(1)
+
+    # Create recorder
+    TestRecorder(
+        test_name=args.test_name,
+        output_dir=args.output,
+        udid=udid,
+        inline=args.inline,
+        screenshot_size=args.size,
+        app_name=args.app_name,
+    )
+
+    print("Test recorder initialized. Use the following methods:")
+    print('  recorder.step("description") - Record a test step')
+    print("  recorder.generate_report() - Generate final report")
+    print()
+    print("Example:")
+    print('  recorder.step("Launch app", screen_name="Splash")')
+    print(
+        '  recorder.step("Enter credentials", screen_name="Login", state="Empty", metadata={"user": "test"})'
+    )
+    print('  recorder.step("Verify login", assertion="Home screen visible")')
+    print("  recorder.generate_report()")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+Visual Diff Tool for iOS Simulator Screenshots
+
+Compares two screenshots pixel-by-pixel to detect visual changes.
+Optimized for minimal token output.
+
+Usage: python scripts/visual_diff.py baseline.png current.png [options]
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+try:
+    from PIL import Image, ImageChops, ImageDraw
+except ImportError:
+    print("Error: Pillow not installed. Run: pip3 install pillow")
+    sys.exit(1)
+
+
+class VisualDiffer:
+    """Performs visual comparison between screenshots."""
+
+    def __init__(self, threshold: float = 0.01):
+        """
+        Initialize differ with threshold.
+
+        Args:
+            threshold: Maximum acceptable difference ratio (0.01 = 1%)
+        """
+        self.threshold = threshold
+
+    def compare(self, baseline_path: str, current_path: str) -> dict:
+        """
+        Compare two images and return difference metrics.
+
+        Args:
+            baseline_path: Path to baseline image
+            current_path: Path to current image
+
+        Returns:
+            Dictionary with comparison results
+        """
+        # Load images
+        try:
+            baseline = Image.open(baseline_path)
+            current = Image.open(current_path)
+        except FileNotFoundError as e:
+            print(f"Error: Image not found - {e}")
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error: Failed to load image - {e}")
+            sys.exit(1)
+
+        # Verify dimensions match
+        if baseline.size != current.size:
+            return {
+                "error": "Image dimensions do not match",
+                "baseline_size": baseline.size,
+                "current_size": current.size,
+            }
+
+        # Convert to RGB if needed
+        if baseline.mode != "RGB":
+            baseline = baseline.convert("RGB")
+        if current.mode != "RGB":
+            current = current.convert("RGB")
+
+        # Calculate difference
+        diff = ImageChops.difference(baseline, current)
+
+        # Calculate metrics
+        total_pixels = baseline.size[0] * baseline.size[1]
+        diff_pixels = self._count_different_pixels(diff)
+        diff_percentage = (diff_pixels / total_pixels) * 100
+
+        # Determine pass/fail
+        passed = diff_percentage <= (self.threshold * 100)
+
+        return {
+            "dimensions": baseline.size,
+            "total_pixels": total_pixels,
+            "different_pixels": diff_pixels,
+            "difference_percentage": round(diff_percentage, 2),
+            "threshold_percentage": self.threshold * 100,
+            "passed": passed,
+            "verdict": "PASS" if passed else "FAIL",
+        }
+
+    def _count_different_pixels(self, diff_image: Image.Image) -> int:
+        """Count number of pixels that are different."""
+        # Convert to grayscale for easier processing
+        diff_gray = diff_image.convert("L")
+
+        # Count non-zero pixels (different)
+        pixels = diff_gray.getdata()
+        return sum(1 for pixel in pixels if pixel > 10)  # Threshold for noise
+
+    def generate_diff_image(self, baseline_path: str, current_path: str, output_path: str) -> None:
+        """Generate highlighted difference image."""
+        baseline = Image.open(baseline_path).convert("RGB")
+        current = Image.open(current_path).convert("RGB")
+
+        # Create difference image
+        diff = ImageChops.difference(baseline, current)
+
+        # Enhance differences with red overlay
+        diff_enhanced = Image.new("RGB", baseline.size)
+        for x in range(baseline.size[0]):
+            for y in range(baseline.size[1]):
+                diff_pixel = diff.getpixel((x, y))
+                if sum(diff_pixel) > 30:  # Threshold for visibility
+                    # Highlight in red
+                    diff_enhanced.putpixel((x, y), (255, 0, 0))
+                else:
+                    # Keep original
+                    diff_enhanced.putpixel((x, y), current.getpixel((x, y)))
+
+        diff_enhanced.save(output_path)
+
+    def generate_side_by_side(
+        self, baseline_path: str, current_path: str, output_path: str
+    ) -> None:
+        """Generate side-by-side comparison image."""
+        baseline = Image.open(baseline_path)
+        current = Image.open(current_path)
+
+        # Create combined image
+        width = baseline.size[0] * 2 + 10  # 10px separator
+        height = max(baseline.size[1], current.size[1])
+        combined = Image.new("RGB", (width, height), color=(128, 128, 128))
+
+        # Paste images
+        combined.paste(baseline, (0, 0))
+        combined.paste(current, (baseline.size[0] + 10, 0))
+
+        combined.save(output_path)
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Compare screenshots for visual differences")
+    parser.add_argument("baseline", help="Path to baseline screenshot")
+    parser.add_argument("current", help="Path to current screenshot")
+    parser.add_argument(
+        "--output",
+        default=".",
+        help="Output directory for diff artifacts (default: current directory)",
+    )
+    parser.add_argument(
+        "--threshold",
+        type=float,
+        default=0.01,
+        help="Acceptable difference threshold (0.01 = 1%%, default: 0.01)",
+    )
+    parser.add_argument(
+        "--details", action="store_true", help="Show detailed output (increases tokens)"
+    )
+
+    args = parser.parse_args()
+
+    # Create output directory if needed
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Initialize differ
+    differ = VisualDiffer(threshold=args.threshold)
+
+    # Perform comparison
+    result = differ.compare(args.baseline, args.current)
+
+    # Handle dimension mismatch
+    if "error" in result:
+        print(f"Error: {result['error']}")
+        print(f"Baseline: {result['baseline_size']}")
+        print(f"Current: {result['current_size']}")
+        sys.exit(1)
+
+    # Generate artifacts
+    diff_image_path = output_dir / "diff.png"
+    comparison_image_path = output_dir / "side-by-side.png"
+
+    try:
+        differ.generate_diff_image(args.baseline, args.current, str(diff_image_path))
+        differ.generate_side_by_side(args.baseline, args.current, str(comparison_image_path))
+    except Exception as e:
+        print(f"Warning: Could not generate images - {e}")
+
+    # Output results (token-optimized)
+    if args.details:
+        # Detailed output
+        report = {
+            "summary": {
+                "baseline": args.baseline,
+                "current": args.current,
+                "threshold": args.threshold,
+                "passed": result["passed"],
+            },
+            "results": result,
+            "artifacts": {
+                "diff_image": str(diff_image_path),
+                "comparison_image": str(comparison_image_path),
+            },
+        }
+        print(json.dumps(report, indent=2))
+    else:
+        # Minimal output (default)
+        print(f"Difference: {result['difference_percentage']}% ({result['verdict']})")
+        if result["different_pixels"] > 0:
+            print(f"Changed pixels: {result['different_pixels']:,}")
+        print(f"Artifacts saved to: {output_dir}/")
+
+    # Save JSON report
+    report_path = output_dir / "diff-report.json"
+    with open(report_path, "w") as f:
+        json.dump(
+            {
+                "baseline": os.path.basename(args.baseline),
+                "current": os.path.basename(args.current),
+                "results": result,
+                "artifacts": {"diff": "diff.png", "comparison": "side-by-side.png"},
+            },
+            f,
+            indent=2,
+        )
+
+    # Exit with error if test failed
+    sys.exit(0 if result["passed"] else 1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,13 @@
+"""
+Xcode build automation module.
+
+Provides structured, modular access to xcodebuild and xcresult functionality.
+"""
+
+from .builder import BuildRunner
+from .cache import XCResultCache
+from .config import Config
+from .reporter import OutputFormatter
+from .xcresult import XCResultParser
+
+__all__ = ["BuildRunner", "Config", "OutputFormatter", "XCResultCache", "XCResultParser"]
@@ -0,0 +1,381 @@
+"""
+Xcode build execution.
+
+Handles xcodebuild command construction and execution with xcresult generation.
+"""
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from .cache import XCResultCache
+from .config import Config
+
+
+class BuildRunner:
+    """
+    Execute xcodebuild commands with xcresult bundle generation.
+
+    Handles scheme auto-detection, command construction, and build/test execution.
+    """
+
+    def __init__(
+        self,
+        project_path: str | None = None,
+        workspace_path: str | None = None,
+        scheme: str | None = None,
+        configuration: str = "Debug",
+        simulator: str | None = None,
+        cache: XCResultCache | None = None,
+    ):
+        """
+        Initialize build runner.
+
+        Args:
+            project_path: Path to .xcodeproj
+            workspace_path: Path to .xcworkspace
+            scheme: Build scheme (auto-detected if not provided)
+            configuration: Build configuration (Debug/Release)
+            simulator: Simulator name
+            cache: XCResult cache (creates default if not provided)
+        """
+        self.project_path = project_path
+        self.workspace_path = workspace_path
+        self.scheme = scheme
+        self.configuration = configuration
+        self.simulator = simulator
+        self.cache = cache or XCResultCache()
+
+    def auto_detect_scheme(self) -> str | None:
+        """
+        Auto-detect build scheme from project/workspace.
+
+        Returns:
+            Detected scheme name or None
+        """
+        cmd = ["xcodebuild", "-list"]
+
+        if self.workspace_path:
+            cmd.extend(["-workspace", self.workspace_path])
+        elif self.project_path:
+            cmd.extend(["-project", self.project_path])
+        else:
+            return None
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            # Parse schemes from output
+            in_schemes_section = False
+            for line in result.stdout.split("\n"):
+                line = line.strip()
+
+                if "Schemes:" in line:
+                    in_schemes_section = True
+                    continue
+
+                if in_schemes_section and line and not line.startswith("Build"):
+                    # First scheme in list
+                    return line
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error auto-detecting scheme: {e}", file=sys.stderr)
+
+        return None
+
+    def get_simulator_destination(self) -> str:
+        """
+        Get xcodebuild destination string.
+
+        Uses config preferences with fallback to auto-detection.
+
+        Priority:
+            1. --simulator CLI flag (self.simulator)
+            2. Config preferred_simulator
+            3. Config last_used_simulator
+            4. Auto-detect first iPhone
+            5. Generic iOS Simulator
+
+        Returns:
+            Destination string for -destination flag
+        """
+        # Priority 1: CLI flag
+        if self.simulator:
+            return f"platform=iOS Simulator,name={self.simulator}"
+
+        # Priority 2-3: Config preferences
+        try:
+            # Determine project directory from project/workspace path
+            project_dir = None
+            if self.project_path:
+                project_dir = Path(self.project_path).parent
+            elif self.workspace_path:
+                project_dir = Path(self.workspace_path).parent
+
+            config = Config.load(project_dir=project_dir)
+            preferred = config.get_preferred_simulator()
+
+            if preferred:
+                # Check if preferred simulator exists
+                if self._simulator_exists(preferred):
+                    return f"platform=iOS Simulator,name={preferred}"
+                print(f"Warning: Preferred simulator '{preferred}' not available", file=sys.stderr)
+                if config.should_fallback_to_any_iphone():
+                    print("Falling back to auto-detection...", file=sys.stderr)
+                else:
+                    # Strict mode: don't fallback
+                    return f"platform=iOS Simulator,name={preferred}"
+
+        except Exception as e:
+            print(f"Warning: Could not load config: {e}", file=sys.stderr)
+
+        # Priority 4-5: Auto-detect
+        return self._auto_detect_simulator()
+
+    def _simulator_exists(self, name: str) -> bool:
+        """
+        Check if simulator with given name exists and is available.
+
+        Args:
+            name: Simulator name (e.g., "iPhone 16 Pro")
+
+        Returns:
+            True if simulator exists and is available
+        """
+        try:
+            result = subprocess.run(
+                ["xcrun", "simctl", "list", "devices", "available", "iOS"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            # Check if simulator name appears in available devices
+            return any(name in line and "(" in line for line in result.stdout.split("\n"))
+
+        except subprocess.CalledProcessError:
+            return False
+
+    def _extract_simulator_name_from_destination(self, destination: str) -> str | None:
+        """
+        Extract simulator name from destination string.
+
+        Args:
+            destination: Destination string (e.g., "platform=iOS Simulator,name=iPhone 16 Pro")
+
+        Returns:
+            Simulator name or None
+        """
+        # Pattern: name=<simulator name>
+        match = re.search(r"name=([^,]+)", destination)
+        if match:
+            return match.group(1).strip()
+        return None
+
+    def _auto_detect_simulator(self) -> str:
+        """
+        Auto-detect best available iOS simulator.
+
+        Returns:
+            Destination string for -destination flag
+        """
+        try:
+            result = subprocess.run(
+                ["xcrun", "simctl", "list", "devices", "available", "iOS"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            # Parse available simulators, prefer latest iPhone
+            # Looking for lines like: "iPhone 16 Pro (12345678-1234-1234-1234-123456789012) (Shutdown)"
+            for line in result.stdout.split("\n"):
+                if "iPhone" in line and "(" in line:
+                    # Extract device name
+                    name = line.split("(")[0].strip()
+                    if name:
+                        return f"platform=iOS Simulator,name={name}"
+
+            # Fallback to generic iOS Simulator if no iPhone found
+            return "generic/platform=iOS Simulator"
+
+        except subprocess.CalledProcessError as e:
+            print(f"Warning: Could not auto-detect simulator: {e}", file=sys.stderr)
+            return "generic/platform=iOS Simulator"
+
+    def build(self, clean: bool = False) -> tuple[bool, str, str]:
+        """
+        Build the project.
+
+        Args:
+            clean: Perform clean build
+
+        Returns:
+            Tuple of (success: bool, xcresult_id: str, stderr: str)
+        """
+        # Auto-detect scheme if needed
+        if not self.scheme:
+            self.scheme = self.auto_detect_scheme()
+            if not self.scheme:
+                print("Error: Could not auto-detect scheme. Use --scheme", file=sys.stderr)
+                return (False, "", "")
+
+        # Generate xcresult ID and path
+        xcresult_id = self.cache.generate_id()
+        xcresult_path = self.cache.get_path(xcresult_id)
+
+        # Build command
+        cmd = ["xcodebuild", "-quiet"]  # Suppress verbose output
+
+        if clean:
+            cmd.append("clean")
+
+        cmd.append("build")
+
+        if self.workspace_path:
+            cmd.extend(["-workspace", self.workspace_path])
+        elif self.project_path:
+            cmd.extend(["-project", self.project_path])
+        else:
+            print("Error: No project or workspace specified", file=sys.stderr)
+            return (False, "", "")
+
+        cmd.extend(
+            [
+                "-scheme",
+                self.scheme,
+                "-configuration",
+                self.configuration,
+                "-destination",
+                self.get_simulator_destination(),
+                "-resultBundlePath",
+                str(xcresult_path),
+            ]
+        )
+
+        # Execute build
+        try:
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, check=False  # Don't raise on non-zero exit
+            )
+
+            success = result.returncode == 0
+
+            # xcresult bundle should be created even on failure
+            if not xcresult_path.exists():
+                print("Warning: xcresult bundle was not created", file=sys.stderr)
+                return (success, "", result.stderr)
+
+            # Auto-update config with last used simulator (on success only)
+            if success:
+                try:
+                    # Determine project directory from project/workspace path
+                    project_dir = None
+                    if self.project_path:
+                        project_dir = Path(self.project_path).parent
+                    elif self.workspace_path:
+                        project_dir = Path(self.workspace_path).parent
+
+                    config = Config.load(project_dir=project_dir)
+                    destination = self.get_simulator_destination()
+                    simulator_name = self._extract_simulator_name_from_destination(destination)
+
+                    if simulator_name:
+                        config.update_last_used_simulator(simulator_name)
+                        config.save()
+
+                except Exception as e:
+                    # Don't fail build if config update fails
+                    print(f"Warning: Could not update config: {e}", file=sys.stderr)
+
+            return (success, xcresult_id, result.stderr)
+
+        except Exception as e:
+            print(f"Error executing build: {e}", file=sys.stderr)
+            return (False, "", str(e))
+
+    def test(self, test_suite: str | None = None) -> tuple[bool, str, str]:
+        """
+        Run tests.
+
+        Args:
+            test_suite: Specific test suite to run
+
+        Returns:
+            Tuple of (success: bool, xcresult_id: str, stderr: str)
+        """
+        # Auto-detect scheme if needed
+        if not self.scheme:
+            self.scheme = self.auto_detect_scheme()
+            if not self.scheme:
+                print("Error: Could not auto-detect scheme. Use --scheme", file=sys.stderr)
+                return (False, "", "")
+
+        # Generate xcresult ID and path
+        xcresult_id = self.cache.generate_id()
+        xcresult_path = self.cache.get_path(xcresult_id)
+
+        # Build command
+        cmd = ["xcodebuild", "-quiet", "test"]
+
+        if self.workspace_path:
+            cmd.extend(["-workspace", self.workspace_path])
+        elif self.project_path:
+            cmd.extend(["-project", self.project_path])
+        else:
+            print("Error: No project or workspace specified", file=sys.stderr)
+            return (False, "", "")
+
+        cmd.extend(
+            [
+                "-scheme",
+                self.scheme,
+                "-destination",
+                self.get_simulator_destination(),
+                "-resultBundlePath",
+                str(xcresult_path),
+            ]
+        )
+
+        if test_suite:
+            cmd.extend(["-only-testing", test_suite])
+
+        # Execute tests
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+
+            success = result.returncode == 0
+
+            # xcresult bundle should be created even on failure
+            if not xcresult_path.exists():
+                print("Warning: xcresult bundle was not created", file=sys.stderr)
+                return (success, "", result.stderr)
+
+            # Auto-update config with last used simulator (on success only)
+            if success:
+                try:
+                    # Determine project directory from project/workspace path
+                    project_dir = None
+                    if self.project_path:
+                        project_dir = Path(self.project_path).parent
+                    elif self.workspace_path:
+                        project_dir = Path(self.workspace_path).parent
+
+                    config = Config.load(project_dir=project_dir)
+                    destination = self.get_simulator_destination()
+                    simulator_name = self._extract_simulator_name_from_destination(destination)
+
+                    if simulator_name:
+                        config.update_last_used_simulator(simulator_name)
+                        config.save()
+
+                except Exception as e:
+                    # Don't fail test if config update fails
+                    print(f"Warning: Could not update config: {e}", file=sys.stderr)
+
+            return (success, xcresult_id, result.stderr)
+
+        except Exception as e:
+            print(f"Error executing tests: {e}", file=sys.stderr)
+            return (False, "", str(e))
@@ -0,0 +1,204 @@
+"""
+XCResult cache management.
+
+Handles storage, retrieval, and lifecycle of xcresult bundles for progressive disclosure.
+"""
+
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+
+class XCResultCache:
+    """
+    Manage xcresult bundle cache for progressive disclosure.
+
+    Stores xcresult bundles with timestamp-based IDs and provides
+    retrieval and cleanup operations.
+    """
+
+    # Default cache directory
+    DEFAULT_CACHE_DIR = Path.home() / ".ios-simulator-skill" / "xcresults"
+
+    def __init__(self, cache_dir: Path | None = None):
+        """
+        Initialize cache manager.
+
+        Args:
+            cache_dir: Custom cache directory (uses default if not specified)
+        """
+        self.cache_dir = cache_dir or self.DEFAULT_CACHE_DIR
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def generate_id(self, prefix: str = "xcresult") -> str:
+        """
+        Generate timestamped xcresult ID.
+
+        Args:
+            prefix: ID prefix (default: "xcresult")
+
+        Returns:
+            ID string like "xcresult-20251018-143052"
+        """
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        return f"{prefix}-{timestamp}"
+
+    def get_path(self, xcresult_id: str) -> Path:
+        """
+        Get full path for xcresult ID.
+
+        Args:
+            xcresult_id: XCResult ID
+
+        Returns:
+            Path to xcresult bundle
+        """
+        # Handle both with and without .xcresult extension
+        if xcresult_id.endswith(".xcresult"):
+            return self.cache_dir / xcresult_id
+        return self.cache_dir / f"{xcresult_id}.xcresult"
+
+    def exists(self, xcresult_id: str) -> bool:
+        """
+        Check if xcresult bundle exists.
+
+        Args:
+            xcresult_id: XCResult ID
+
+        Returns:
+            True if bundle exists
+        """
+        return self.get_path(xcresult_id).exists()
+
+    def save(self, source_path: Path, xcresult_id: str | None = None) -> str:
+        """
+        Save xcresult bundle to cache.
+
+        Args:
+            source_path: Source xcresult bundle path
+            xcresult_id: Optional custom ID (generates if not provided)
+
+        Returns:
+            xcresult ID
+        """
+        if not source_path.exists():
+            raise FileNotFoundError(f"Source xcresult not found: {source_path}")
+
+        # Generate ID if not provided
+        if not xcresult_id:
+            xcresult_id = self.generate_id()
+
+        # Get destination path
+        dest_path = self.get_path(xcresult_id)
+
+        # Copy xcresult bundle (it's a directory)
+        if dest_path.exists():
+            shutil.rmtree(dest_path)
+
+        shutil.copytree(source_path, dest_path)
+
+        return xcresult_id
+
+    def list(self, limit: int = 10) -> list[dict]:
+        """
+        List recent xcresult bundles.
+
+        Args:
+            limit: Maximum number to return
+
+        Returns:
+            List of xcresult metadata dicts
+        """
+        if not self.cache_dir.exists():
+            return []
+
+        results = []
+        for path in sorted(
+            self.cache_dir.glob("*.xcresult"), key=lambda p: p.stat().st_mtime, reverse=True
+        )[:limit]:
+            # Calculate bundle size
+            size_bytes = sum(f.stat().st_size for f in path.rglob("*") if f.is_file())
+
+            results.append(
+                {
+                    "id": path.stem,
+                    "path": str(path),
+                    "created": datetime.fromtimestamp(path.stat().st_mtime).isoformat(),
+                    "size_mb": round(size_bytes / (1024 * 1024), 2),
+                }
+            )
+
+        return results
+
+    def cleanup(self, keep_recent: int = 20) -> int:
+        """
+        Clean up old xcresult bundles.
+
+        Args:
+            keep_recent: Number of recent bundles to keep
+
+        Returns:
+            Number of bundles removed
+        """
+        if not self.cache_dir.exists():
+            return 0
+
+        # Get all bundles sorted by modification time
+        all_bundles = sorted(
+            self.cache_dir.glob("*.xcresult"), key=lambda p: p.stat().st_mtime, reverse=True
+        )
+
+        # Remove old bundles
+        removed = 0
+        for bundle_path in all_bundles[keep_recent:]:
+            shutil.rmtree(bundle_path)
+            removed += 1
+
+        return removed
+
+    def get_size_mb(self, xcresult_id: str) -> float:
+        """
+        Get size of xcresult bundle in MB.
+
+        Args:
+            xcresult_id: XCResult ID
+
+        Returns:
+            Size in MB
+        """
+        path = self.get_path(xcresult_id)
+        if not path.exists():
+            return 0.0
+
+        size_bytes = sum(f.stat().st_size for f in path.rglob("*") if f.is_file())
+        return round(size_bytes / (1024 * 1024), 2)
+
+    def save_stderr(self, xcresult_id: str, stderr: str) -> None:
+        """
+        Save stderr output alongside xcresult bundle.
+
+        Args:
+            xcresult_id: XCResult ID
+            stderr: stderr output from xcodebuild
+        """
+        if not stderr:
+            return
+
+        stderr_path = self.cache_dir / f"{xcresult_id}.stderr"
+        stderr_path.write_text(stderr, encoding="utf-8")
+
+    def get_stderr(self, xcresult_id: str) -> str:
+        """
+        Retrieve cached stderr output.
+
+        Args:
+            xcresult_id: XCResult ID
+
+        Returns:
+            stderr content or empty string if not found
+        """
+        stderr_path = self.cache_dir / f"{xcresult_id}.stderr"
+        if not stderr_path.exists():
+            return ""
+
+        return stderr_path.read_text(encoding="utf-8")
@@ -0,0 +1,178 @@
+"""
+Configuration management for iOS Simulator Skill.
+
+Handles loading, validation, and auto-updating of project-local config files.
+"""
+
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+class Config:
+    """
+    Project-local configuration with auto-learning.
+
+    Config file location: .claude/skills/<skill-directory-name>/config.json
+
+    The skill directory name is auto-detected from the installation location,
+    so configs work regardless of what users name the skill directory.
+
+    Auto-updates last_used_simulator after successful builds.
+    """
+
+    DEFAULT_CONFIG = {
+        "device": {
+            "preferred_simulator": None,
+            "preferred_os_version": None,
+            "fallback_to_any_iphone": True,
+            "last_used_simulator": None,
+            "last_used_at": None,
+        }
+    }
+
+    def __init__(self, data: dict[str, Any], config_path: Path):
+        """
+        Initialize config.
+
+        Args:
+            data: Config data dict
+            config_path: Path to config file
+        """
+        self.data = data
+        self.config_path = config_path
+
+    @staticmethod
+    def load(project_dir: Path | None = None) -> "Config":
+        """
+        Load config from project directory.
+
+        Args:
+            project_dir: Project root (defaults to cwd)
+
+        Returns:
+            Config instance (creates default if not found)
+
+        Note:
+            The skill directory name is auto-detected from the installation location,
+            so configs work regardless of what users name the skill directory.
+        """
+        if project_dir is None:
+            project_dir = Path.cwd()
+
+        # Auto-detect skill directory name from actual installation location
+        # This file is at: skill/scripts/xcode/config.py
+        # Navigate up to skill/ directory and use its name
+        skill_root = Path(__file__).parent.parent.parent  # xcode/ -> scripts/ -> skill/
+        skill_name = skill_root.name
+
+        config_path = project_dir / ".claude" / "skills" / skill_name / "config.json"
+
+        # Load existing config
+        if config_path.exists():
+            try:
+                with open(config_path) as f:
+                    data = json.load(f)
+
+                # Merge with defaults (in case new fields added)
+                merged = Config._merge_with_defaults(data)
+                return Config(merged, config_path)
+
+            except json.JSONDecodeError as e:
+                print(f"Warning: Invalid JSON in {config_path}: {e}", file=sys.stderr)
+                print("Using default config", file=sys.stderr)
+                return Config(Config.DEFAULT_CONFIG.copy(), config_path)
+            except Exception as e:
+                print(f"Warning: Could not load config: {e}", file=sys.stderr)
+                return Config(Config.DEFAULT_CONFIG.copy(), config_path)
+
+        # Return default config (will be created on first save)
+        return Config(Config.DEFAULT_CONFIG.copy(), config_path)
+
+    @staticmethod
+    def _merge_with_defaults(data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Merge user config with defaults.
+
+        Args:
+            data: User config data
+
+        Returns:
+            Merged config with all default fields
+        """
+        merged = Config.DEFAULT_CONFIG.copy()
+
+        # Deep merge device section
+        if "device" in data:
+            merged["device"].update(data["device"])
+
+        return merged
+
+    def save(self) -> None:
+        """
+        Save config to file atomically.
+
+        Uses temp file + rename for atomic writes.
+        Creates parent directories if needed.
+        """
+        try:
+            # Create parent directories
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Atomic write: temp file + rename
+            temp_path = self.config_path.with_suffix(".tmp")
+
+            with open(temp_path, "w") as f:
+                json.dump(self.data, f, indent=2)
+                f.write("\n")  # Trailing newline
+
+            # Atomic rename
+            temp_path.replace(self.config_path)
+
+        except Exception as e:
+            print(f"Warning: Could not save config: {e}", file=sys.stderr)
+
+    def update_last_used_simulator(self, name: str) -> None:
+        """
+        Update last used simulator and timestamp.
+
+        Args:
+            name: Simulator name (e.g., "iPhone 16 Pro")
+        """
+        self.data["device"]["last_used_simulator"] = name
+        self.data["device"]["last_used_at"] = datetime.utcnow().isoformat() + "Z"
+
+    def get_preferred_simulator(self) -> str | None:
+        """
+        Get preferred simulator.
+
+        Returns:
+            Simulator name or None
+
+        Priority:
+            1. preferred_simulator (manual preference)
+            2. last_used_simulator (auto-learned)
+            3. None (use auto-detection)
+        """
+        device = self.data.get("device", {})
+
+        # Manual preference takes priority
+        if device.get("preferred_simulator"):
+            return device["preferred_simulator"]
+
+        # Auto-learned preference
+        if device.get("last_used_simulator"):
+            return device["last_used_simulator"]
+
+        return None
+
+    def should_fallback_to_any_iphone(self) -> bool:
+        """
+        Check if fallback to any iPhone is enabled.
+
+        Returns:
+            True if should fallback, False otherwise
+        """
+        return self.data.get("device", {}).get("fallback_to_any_iphone", True)
@@ -0,0 +1,291 @@
+"""
+Build/test output formatting.
+
+Provides multiple output formats with progressive disclosure support.
+"""
+
+import json
+
+
+class OutputFormatter:
+    """
+    Format build/test results for display.
+
+    Supports ultra-minimal default output, verbose mode, and JSON output.
+    """
+
+    @staticmethod
+    def format_minimal(
+        status: str,
+        error_count: int,
+        warning_count: int,
+        xcresult_id: str,
+        test_info: dict | None = None,
+        hints: list[str] | None = None,
+    ) -> str:
+        """
+        Format ultra-minimal output (5-10 tokens).
+
+        Args:
+            status: Build status (SUCCESS/FAILED)
+            error_count: Number of errors
+            warning_count: Number of warnings
+            xcresult_id: XCResult bundle ID
+            test_info: Optional test results dict
+            hints: Optional list of actionable hints
+
+        Returns:
+            Minimal formatted string
+
+        Example:
+            Build: SUCCESS (0 errors, 3 warnings) [xcresult-20251018-143052]
+            Tests: PASS (12/12 passed, 4.2s) [xcresult-20251018-143052]
+        """
+        lines = []
+
+        if test_info:
+            # Test mode
+            total = test_info.get("total", 0)
+            passed = test_info.get("passed", 0)
+            failed = test_info.get("failed", 0)
+            duration = test_info.get("duration", 0.0)
+
+            test_status = "PASS" if failed == 0 else "FAIL"
+            lines.append(
+                f"Tests: {test_status} ({passed}/{total} passed, {duration:.1f}s) [{xcresult_id}]"
+            )
+        else:
+            # Build mode
+            lines.append(
+                f"Build: {status} ({error_count} errors, {warning_count} warnings) [{xcresult_id}]"
+            )
+
+        # Add hints if provided and build failed
+        if hints and status == "FAILED":
+            lines.append("")
+            lines.extend(hints)
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def format_errors(errors: list[dict], limit: int = 10) -> str:
+        """
+        Format error details.
+
+        Args:
+            errors: List of error dicts
+            limit: Maximum errors to show
+
+        Returns:
+            Formatted error list
+        """
+        if not errors:
+            return "No errors found."
+
+        lines = [f"Errors ({len(errors)}):"]
+        lines.append("")
+
+        for i, error in enumerate(errors[:limit], 1):
+            message = error.get("message", "Unknown error")
+            location = error.get("location", {})
+
+            # Format location
+            loc_parts = []
+            if location.get("file"):
+                file_path = location["file"].replace("file://", "")
+                loc_parts.append(file_path)
+            if location.get("line"):
+                loc_parts.append(f"line {location['line']}")
+
+            location_str = ":".join(loc_parts) if loc_parts else "unknown location"
+
+            lines.append(f"{i}. {message}")
+            lines.append(f"   Location: {location_str}")
+            lines.append("")
+
+        if len(errors) > limit:
+            lines.append(f"... and {len(errors) - limit} more errors")
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def format_warnings(warnings: list[dict], limit: int = 10) -> str:
+        """
+        Format warning details.
+
+        Args:
+            warnings: List of warning dicts
+            limit: Maximum warnings to show
+
+        Returns:
+            Formatted warning list
+        """
+        if not warnings:
+            return "No warnings found."
+
+        lines = [f"Warnings ({len(warnings)}):"]
+        lines.append("")
+
+        for i, warning in enumerate(warnings[:limit], 1):
+            message = warning.get("message", "Unknown warning")
+            location = warning.get("location", {})
+
+            # Format location
+            loc_parts = []
+            if location.get("file"):
+                file_path = location["file"].replace("file://", "")
+                loc_parts.append(file_path)
+            if location.get("line"):
+                loc_parts.append(f"line {location['line']}")
+
+            location_str = ":".join(loc_parts) if loc_parts else "unknown location"
+
+            lines.append(f"{i}. {message}")
+            lines.append(f"   Location: {location_str}")
+            lines.append("")
+
+        if len(warnings) > limit:
+            lines.append(f"... and {len(warnings) - limit} more warnings")
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def format_log(log: str, lines: int = 50) -> str:
+        """
+        Format build log (show last N lines).
+
+        Args:
+            log: Full build log
+            lines: Number of lines to show
+
+        Returns:
+            Formatted log excerpt
+        """
+        if not log:
+            return "No build log available."
+
+        log_lines = log.strip().split("\n")
+
+        if len(log_lines) <= lines:
+            return log
+
+        # Show last N lines
+        excerpt = log_lines[-lines:]
+        return f"... (showing last {lines} lines of {len(log_lines)})\n\n" + "\n".join(excerpt)
+
+    @staticmethod
+    def format_json(data: dict) -> str:
+        """
+        Format data as JSON.
+
+        Args:
+            data: Data to format
+
+        Returns:
+            Pretty-printed JSON string
+        """
+        return json.dumps(data, indent=2)
+
+    @staticmethod
+    def generate_hints(errors: list[dict]) -> list[str]:
+        """
+        Generate actionable hints based on error types.
+
+        Args:
+            errors: List of error dicts
+
+        Returns:
+            List of hint strings
+        """
+        hints = []
+        error_types: set[str] = set()
+
+        # Collect error types
+        for error in errors:
+            error_type = error.get("type", "unknown")
+            error_types.add(error_type)
+
+        # Generate hints based on error types
+        if "provisioning" in error_types:
+            hints.append("Provisioning profile issue detected:")
+            hints.append("  • Ensure you have a valid provisioning profile for iOS Simulator")
+            hints.append(
+                '  • For simulator builds, use CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO'
+            )
+            hints.append("  • Or specify simulator explicitly: --simulator 'iPhone 16 Pro'")
+
+        if "signing" in error_types:
+            hints.append("Code signing issue detected:")
+            hints.append("  • For simulator builds, code signing is not required")
+            hints.append("  • Ensure build settings target iOS Simulator, not physical device")
+            hints.append("  • Check destination: platform=iOS Simulator,name=<device>")
+
+        if not error_types or "build" in error_types:
+            # Generic hints when error type is unknown
+            if any("destination" in error.get("message", "").lower() for error in errors):
+                hints.append("Device selection issue detected:")
+                hints.append("  • List available simulators: xcrun simctl list devices available")
+                hints.append("  • Specify simulator: --simulator 'iPhone 16 Pro'")
+
+        return hints
+
+    @staticmethod
+    def format_verbose(
+        status: str,
+        error_count: int,
+        warning_count: int,
+        xcresult_id: str,
+        errors: list[dict] | None = None,
+        warnings: list[dict] | None = None,
+        test_info: dict | None = None,
+    ) -> str:
+        """
+        Format verbose output with error/warning details.
+
+        Args:
+            status: Build status
+            error_count: Error count
+            warning_count: Warning count
+            xcresult_id: XCResult ID
+            errors: Optional error list
+            warnings: Optional warning list
+            test_info: Optional test results
+
+        Returns:
+            Verbose formatted output
+        """
+        lines = []
+
+        # Header
+        if test_info:
+            total = test_info.get("total", 0)
+            passed = test_info.get("passed", 0)
+            failed = test_info.get("failed", 0)
+            duration = test_info.get("duration", 0.0)
+
+            test_status = "PASS" if failed == 0 else "FAIL"
+            lines.append(f"Tests: {test_status}")
+            lines.append(f"  Total: {total}")
+            lines.append(f"  Passed: {passed}")
+            lines.append(f"  Failed: {failed}")
+            lines.append(f"  Duration: {duration:.1f}s")
+        else:
+            lines.append(f"Build: {status}")
+
+        lines.append(f"XCResult: {xcresult_id}")
+        lines.append("")
+
+        # Errors
+        if errors and len(errors) > 0:
+            lines.append(OutputFormatter.format_errors(errors, limit=5))
+            lines.append("")
+
+        # Warnings
+        if warnings and len(warnings) > 0:
+            lines.append(OutputFormatter.format_warnings(warnings, limit=5))
+            lines.append("")
+
+        # Summary
+        lines.append(f"Summary: {error_count} errors, {warning_count} warnings")
+
+        return "\n".join(lines)
@@ -0,0 +1,404 @@
+"""
+XCResult bundle parser.
+
+Extracts structured data from xcresult bundles using xcresulttool.
+"""
+
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+
+class XCResultParser:
+    """
+    Parse xcresult bundles to extract build/test data.
+
+    Uses xcresulttool to extract structured JSON data from Apple's
+    xcresult bundle format.
+    """
+
+    def __init__(self, xcresult_path: Path, stderr: str = ""):
+        """
+        Initialize parser.
+
+        Args:
+            xcresult_path: Path to xcresult bundle
+            stderr: Optional stderr output for fallback parsing
+        """
+        self.xcresult_path = xcresult_path
+        self.stderr = stderr
+
+        if xcresult_path and not xcresult_path.exists():
+            raise FileNotFoundError(f"XCResult bundle not found: {xcresult_path}")
+
+    def get_build_results(self) -> dict | None:
+        """
+        Get build results as JSON.
+
+        Returns:
+            Parsed JSON dict or None on error
+        """
+        return self._run_xcresulttool(["get", "build-results"])
+
+    def get_test_results(self) -> dict | None:
+        """
+        Get test results summary as JSON.
+
+        Returns:
+            Parsed JSON dict or None on error
+        """
+        return self._run_xcresulttool(["get", "test-results", "summary"])
+
+    def get_build_log(self) -> str | None:
+        """
+        Get build log as plain text.
+
+        Returns:
+            Build log string or None on error
+        """
+        result = self._run_xcresulttool(["get", "log", "--type", "build"], parse_json=False)
+        return result if result else None
+
+    def count_issues(self) -> tuple[int, int]:
+        """
+        Count errors and warnings from build results.
+
+        Returns:
+            Tuple of (error_count, warning_count)
+        """
+        error_count = 0
+        warning_count = 0
+
+        build_results = self.get_build_results()
+
+        if build_results:
+            try:
+                # Try top-level errors/warnings first (newer xcresult format)
+                if "errors" in build_results and isinstance(build_results.get("errors"), list):
+                    error_count = len(build_results["errors"])
+                if "warnings" in build_results and isinstance(build_results.get("warnings"), list):
+                    warning_count = len(build_results["warnings"])
+
+                # If not found, try legacy format: actions[0].buildResult.issues
+                if error_count == 0 and warning_count == 0:
+                    actions = build_results.get("actions", {}).get("_values", [])
+                    if actions:
+                        build_result = actions[0].get("buildResult", {})
+                        issues = build_result.get("issues", {})
+
+                        # Count errors
+                        error_summaries = issues.get("errorSummaries", {}).get("_values", [])
+                        error_count = len(error_summaries)
+
+                        # Count warnings
+                        warning_summaries = issues.get("warningSummaries", {}).get("_values", [])
+                        warning_count = len(warning_summaries)
+
+            except (KeyError, IndexError, TypeError) as e:
+                print(f"Warning: Could not parse issue counts from xcresult: {e}", file=sys.stderr)
+
+        # If no errors found in xcresult but stderr available, count stderr errors
+        if error_count == 0 and self.stderr:
+            stderr_errors = self._parse_stderr_errors()
+            error_count = len(stderr_errors)
+
+        return (error_count, warning_count)
+
+    def get_errors(self) -> list[dict]:
+        """
+        Get detailed error information.
+
+        Returns:
+            List of error dicts with message, file, line info
+        """
+        build_results = self.get_build_results()
+        errors = []
+
+        # Try to get errors from xcresult
+        if build_results:
+            try:
+                # Try top-level errors first (newer xcresult format)
+                if "errors" in build_results and isinstance(build_results.get("errors"), list):
+                    for error in build_results["errors"]:
+                        errors.append(
+                            {
+                                "message": error.get("message", "Unknown error"),
+                                "type": error.get("issueType", "error"),
+                                "location": self._extract_location_from_url(error.get("sourceURL")),
+                            }
+                        )
+
+                # If not found, try legacy format: actions[0].buildResult.issues
+                if not errors:
+                    actions = build_results.get("actions", {}).get("_values", [])
+                    if actions:
+                        build_result = actions[0].get("buildResult", {})
+                        issues = build_result.get("issues", {})
+                        error_summaries = issues.get("errorSummaries", {}).get("_values", [])
+
+                        for error in error_summaries:
+                            errors.append(
+                                {
+                                    "message": error.get("message", {}).get(
+                                        "_value", "Unknown error"
+                                    ),
+                                    "type": error.get("issueType", {}).get("_value", "error"),
+                                    "location": self._extract_location(error),
+                                }
+                            )
+
+            except (KeyError, IndexError, TypeError) as e:
+                print(f"Warning: Could not parse errors from xcresult: {e}", file=sys.stderr)
+
+        # If no errors found in xcresult but stderr available, parse stderr
+        if not errors and self.stderr:
+            errors = self._parse_stderr_errors()
+
+        return errors
+
+    def get_warnings(self) -> list[dict]:
+        """
+        Get detailed warning information.
+
+        Returns:
+            List of warning dicts with message, file, line info
+        """
+        build_results = self.get_build_results()
+        if not build_results:
+            return []
+
+        warnings = []
+
+        try:
+            # Try top-level warnings first (newer xcresult format)
+            if "warnings" in build_results and isinstance(build_results.get("warnings"), list):
+                for warning in build_results["warnings"]:
+                    warnings.append(
+                        {
+                            "message": warning.get("message", "Unknown warning"),
+                            "type": warning.get("issueType", "warning"),
+                            "location": self._extract_location_from_url(warning.get("sourceURL")),
+                        }
+                    )
+
+            # If not found, try legacy format: actions[0].buildResult.issues
+            if not warnings:
+                actions = build_results.get("actions", {}).get("_values", [])
+                if not actions:
+                    return []
+
+                build_result = actions[0].get("buildResult", {})
+                issues = build_result.get("issues", {})
+                warning_summaries = issues.get("warningSummaries", {}).get("_values", [])
+
+                for warning in warning_summaries:
+                    warnings.append(
+                        {
+                            "message": warning.get("message", {}).get("_value", "Unknown warning"),
+                            "type": warning.get("issueType", {}).get("_value", "warning"),
+                            "location": self._extract_location(warning),
+                        }
+                    )
+
+        except (KeyError, IndexError, TypeError) as e:
+            print(f"Warning: Could not parse warnings: {e}", file=sys.stderr)
+
+        return warnings
+
+    def _extract_location(self, issue: dict) -> dict:
+        """
+        Extract file location from issue.
+
+        Args:
+            issue: Issue dict from xcresult
+
+        Returns:
+            Location dict with file, line, column
+        """
+        location = {"file": None, "line": None, "column": None}
+
+        try:
+            doc_location = issue.get("documentLocationInCreatingWorkspace", {})
+            location["file"] = doc_location.get("url", {}).get("_value")
+            location["line"] = doc_location.get("startingLineNumber", {}).get("_value")
+            location["column"] = doc_location.get("startingColumnNumber", {}).get("_value")
+        except (KeyError, TypeError):
+            pass
+
+        return location
+
+    def _extract_location_from_url(self, source_url: str | None) -> dict:
+        """
+        Extract file location from sourceURL (newer xcresult format).
+
+        Args:
+            source_url: Source URL like "file:///path/to/file.swift#StartingLineNumber=134&..."
+
+        Returns:
+            Location dict with file, line, column
+        """
+        location = {"file": None, "line": None, "column": None}
+
+        if not source_url:
+            return location
+
+        try:
+            # Split URL and fragment
+            if "#" in source_url:
+                file_part, fragment = source_url.split("#", 1)
+
+                # Extract file path
+                location["file"] = file_part.replace("file://", "")
+
+                # Parse fragment parameters
+                params = {}
+                for param in fragment.split("&"):
+                    if "=" in param:
+                        key, value = param.split("=", 1)
+                        params[key] = value
+
+                # Extract line and column
+                location["line"] = (
+                    int(params.get("StartingLineNumber", 0)) + 1
+                    if "StartingLineNumber" in params
+                    else None
+                )
+                location["column"] = (
+                    int(params.get("StartingColumnNumber", 0)) + 1
+                    if "StartingColumnNumber" in params
+                    else None
+                )
+            else:
+                # No fragment, just file path
+                location["file"] = source_url.replace("file://", "")
+
+        except (ValueError, AttributeError):
+            pass
+
+        return location
+
+    def _run_xcresulttool(self, args: list[str], parse_json: bool = True) -> Any | None:
+        """
+        Run xcresulttool command.
+
+        Args:
+            args: Command arguments (after 'xcresulttool')
+            parse_json: Whether to parse output as JSON
+
+        Returns:
+            Parsed JSON dict, plain text, or None on error
+        """
+        if not self.xcresult_path:
+            return None
+
+        cmd = ["xcrun", "xcresulttool"] + args + ["--path", str(self.xcresult_path)]
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            if parse_json:
+                return json.loads(result.stdout)
+            return result.stdout
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error running xcresulttool: {e}", file=sys.stderr)
+            print(f"stderr: {e.stderr}", file=sys.stderr)
+            return None
+        except json.JSONDecodeError as e:
+            print(f"Error parsing JSON from xcresulttool: {e}", file=sys.stderr)
+            return None
+
+    def _parse_stderr_errors(self) -> list[dict]:
+        """
+        Parse common errors from stderr output as fallback.
+
+        Returns:
+            List of error dicts parsed from stderr
+        """
+        errors = []
+
+        if not self.stderr:
+            return errors
+
+        # Pattern 0: Swift/Clang compilation errors (e.g., "/path/file.swift:135:59: error: message")
+        compilation_error_pattern = (
+            r"^(?P<file>[^:]+):(?P<line>\d+):(?P<column>\d+):\s*error:\s*(?P<message>.+?)$"
+        )
+        for match in re.finditer(compilation_error_pattern, self.stderr, re.MULTILINE):
+            errors.append(
+                {
+                    "message": match.group("message").strip(),
+                    "type": "compilation",
+                    "location": {
+                        "file": match.group("file"),
+                        "line": int(match.group("line")),
+                        "column": int(match.group("column")),
+                    },
+                }
+            )
+
+        # Pattern 1: xcodebuild top-level errors (e.g., "xcodebuild: error: Unable to find...")
+        xcodebuild_error_pattern = r"xcodebuild:\s*error:\s*(?P<message>.*?)(?:\n\n|\Z)"
+        for match in re.finditer(xcodebuild_error_pattern, self.stderr, re.DOTALL):
+            message = match.group("message").strip()
+            # Clean up multi-line messages
+            message = " ".join(line.strip() for line in message.split("\n") if line.strip())
+            errors.append(
+                {
+                    "message": message,
+                    "type": "build",
+                    "location": {"file": None, "line": None, "column": None},
+                }
+            )
+
+        # Pattern 2: Provisioning profile errors
+        provisioning_pattern = r"error:.*?provisioning profile.*?(?:doesn't|does not|cannot).*?(?P<message>.*?)(?:\n|$)"
+        for match in re.finditer(provisioning_pattern, self.stderr, re.IGNORECASE):
+            errors.append(
+                {
+                    "message": f"Provisioning profile error: {match.group('message').strip()}",
+                    "type": "provisioning",
+                    "location": {"file": None, "line": None, "column": None},
+                }
+            )
+
+        # Pattern 3: Code signing errors
+        signing_pattern = r"error:.*?(?:code sign|signing).*?(?P<message>.*?)(?:\n|$)"
+        for match in re.finditer(signing_pattern, self.stderr, re.IGNORECASE):
+            errors.append(
+                {
+                    "message": f"Code signing error: {match.group('message').strip()}",
+                    "type": "signing",
+                    "location": {"file": None, "line": None, "column": None},
+                }
+            )
+
+        # Pattern 4: Generic compilation errors (but not if already captured)
+        if not errors:
+            generic_error_pattern = r"^(?:\*\*\s)?(?:error|❌):\s*(?P<message>.*?)(?:\n|$)"
+            for match in re.finditer(generic_error_pattern, self.stderr, re.MULTILINE):
+                message = match.group("message").strip()
+                errors.append(
+                    {
+                        "message": message,
+                        "type": "build",
+                        "location": {"file": None, "line": None, "column": None},
+                    }
+                )
+
+        # Pattern 5: Specific "No profiles" error
+        if "No profiles for" in self.stderr:
+            no_profile_pattern = r"No profiles for '(?P<bundle_id>.*?)' were found"
+            for match in re.finditer(no_profile_pattern, self.stderr):
+                errors.append(
+                    {
+                        "message": f"No provisioning profile found for bundle ID '{match.group('bundle_id')}'",
+                        "type": "provisioning",
+                        "location": {"file": None, "line": None, "column": None},
+                    }
+                )
+
+        return errors
@@ -0,0 +1,163 @@
+name: Deploy Supabase to Production
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+    paths:
+      - 'apps/supabase/**'
+      - 'terraform/**'
+      - '.github/workflows/deploy-supabase.yml'
+
+jobs:
+  deploy-database:
+    name: Deploy Migrations & Functions
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 1
+      matrix:
+        environment:
+          - name: non-prod
+            project_ref: itbzhrvlgvdmzbnhzhyx
+          - name: prod
+            project_ref: ckjcrkjpmhqhiucifukx
+
+    env:
+      SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }}
+      SUPABASE_PROJECT_REF: ${{ matrix.environment.project_ref }}
+      ENVIRONMENT_NAME: ${{ matrix.environment.name }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Supabase CLI
+        uses: supabase/setup-cli@v1
+        with:
+          version: latest
+
+      - name: Link to ${{ matrix.environment.name }} Project
+        run: supabase link --project-ref $SUPABASE_PROJECT_REF --workdir apps
+
+      - name: Apply Database Migrations (${{ matrix.environment.name }})
+        run: supabase db push --workdir apps --include-all
+
+      - name: Sync Edge Function Secrets (${{ matrix.environment.name }})
+        env:
+          # Add secrets from GitHub Secrets
+          REVENUECAT_WEBHOOK_SECRET: ${{ secrets.REVENUECAT_WEBHOOK_SECRET }}
+          REVENUECAT_API_KEY: ${{ secrets.REVENUECAT_API_KEY }}
+          REVENUECAT_ENTITLEMENT_ID: ${{ secrets.REVENUECAT_ENTITLEMENT_ID }}
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+          ADMIN_PRIVATE_KEY_JWK: ${{ secrets.ADMIN_PRIVATE_KEY_JWK }}
+          ADMIN_KEYS_JSON: ${{ secrets.ADMIN_KEYS_JSON }}
+          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
+        run: |
+          # Sync secrets to Supabase (only if they're set in GitHub)
+          secrets_to_set=""
+
+          [ -n "$REVENUECAT_WEBHOOK_SECRET" ] && secrets_to_set="$secrets_to_set REVENUECAT_WEBHOOK_SECRET=$REVENUECAT_WEBHOOK_SECRET"
+          [ -n "$REVENUECAT_API_KEY" ] && secrets_to_set="$secrets_to_set REVENUECAT_API_KEY=$REVENUECAT_API_KEY"
+          [ -n "$REVENUECAT_ENTITLEMENT_ID" ] && secrets_to_set="$secrets_to_set REVENUECAT_ENTITLEMENT_ID=$REVENUECAT_ENTITLEMENT_ID"
+          [ -n "$OPENROUTER_API_KEY" ] && secrets_to_set="$secrets_to_set OPENROUTER_API_KEY=$OPENROUTER_API_KEY"
+          [ -n "$ADMIN_PRIVATE_KEY_JWK" ] && secrets_to_set="$secrets_to_set ADMIN_PRIVATE_KEY_JWK=$ADMIN_PRIVATE_KEY_JWK"
+          [ -n "$ADMIN_KEYS_JSON" ] && secrets_to_set="$secrets_to_set ADMIN_KEYS_JSON=$ADMIN_KEYS_JSON"
+          [ -n "$DISCORD_WEBHOOK_URL" ] && secrets_to_set="$secrets_to_set DISCORD_WEBHOOK_URL=$DISCORD_WEBHOOK_URL"
+
+          if [ -n "$secrets_to_set" ]; then
+            echo "Syncing secrets to Supabase ($ENVIRONMENT_NAME)..."
+            supabase secrets set $secrets_to_set --project-ref $SUPABASE_PROJECT_REF
+          else
+            echo "No secrets to sync"
+          fi
+
+      - name: Deploy Edge Functions (${{ matrix.environment.name }})
+        run: |
+          # Deploy all edge functions (excluding _shared directory)
+          for dir in apps/supabase/functions/*/; do
+            function_name=$(basename "$dir")
+
+            # Skip _shared directory (it's a shared module, not a function)
+            if [ "$function_name" = "_shared" ]; then
+              echo "Skipping _shared (shared module)"
+              continue
+            fi
+
+            echo "Deploying function: $function_name to $ENVIRONMENT_NAME"
+            supabase functions deploy "$function_name" --no-verify-jwt --project-ref $SUPABASE_PROJECT_REF --workdir apps
+          done
+
+      - name: Remove Deleted Functions (${{ matrix.environment.name }})
+        run: |
+          # Get list of functions deployed on Supabase (skip header lines, extract slug column)
+          deployed=$(supabase functions list --project-ref $SUPABASE_PROJECT_REF | grep -E '^[a-z]' | awk '{print $1}')
+
+          # Get list of functions in the repo (excluding _shared)
+          local_functions=$(ls -d apps/supabase/functions/*/ 2>/dev/null | xargs -I {} basename {} | grep -v '^_shared$' || true)
+
+          # Delete any deployed functions that no longer exist in the repo
+          for func in $deployed; do
+            # Skip empty or invalid function names
+            [ -z "$func" ] && continue
+            [[ "$func" =~ ^[^a-z] ]] && continue
+
+            if ! echo "$local_functions" | grep -q "^${func}$"; then
+              echo "Deleting removed function from $ENVIRONMENT_NAME: $func"
+              supabase functions delete "$func" --project-ref $SUPABASE_PROJECT_REF
+            fi
+          done
+
+  deploy-infrastructure:
+    name: Deploy Infrastructure (Terraform)
+    runs-on: ubuntu-latest
+
+    env:
+      TF_VAR_supabase_access_token: ${{ secrets.SUPABASE_ACCESS_TOKEN }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Terraform
+        uses: hashicorp/setup-terraform@v3
+        with:
+          terraform_version: "1.6"
+
+      # Non-Production Environment
+      - name: Terraform Init (Non-Prod)
+        working-directory: terraform/environments/non-prod
+        run: terraform init
+
+      - name: Terraform Format Check
+        working-directory: terraform/modules/supabase
+        run: terraform fmt -check
+
+      - name: Terraform Validate (Non-Prod)
+        working-directory: terraform/environments/non-prod
+        run: terraform validate
+
+      - name: Terraform Plan (Non-Prod)
+        working-directory: terraform/environments/non-prod
+        run: terraform plan -out=tfplan
+
+      - name: Terraform Apply (Non-Prod)
+        working-directory: terraform/environments/non-prod
+        run: terraform apply -auto-approve tfplan
+
+      # Production Environment
+      - name: Terraform Init (Prod)
+        working-directory: terraform/environments/prod
+        run: terraform init
+
+      - name: Terraform Validate (Prod)
+        working-directory: terraform/environments/prod
+        run: terraform validate
+
+      - name: Terraform Plan (Prod)
+        working-directory: terraform/environments/prod
+        run: terraform plan -out=tfplan
+
+      - name: Terraform Apply (Prod)
+        working-directory: terraform/environments/prod
+        run: terraform apply -auto-approve tfplan
@@ -17,6 +17,9 @@ build/
 .env.development.local
 .env.test.local
 .env.production.local
+apps/mobile/.env.*
+.secrets
+

 # Supabase
 .supabase/
@@ -12,7 +12,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co

 ## Project Overview

-Sauci is a couples intimacy app featuring swipeable question packs with partner matching. Users swipe on questions (yes/no/maybe), and when both partners answer positively, a "match" is created that unlocks a chat thread for that question.
+Sauci is a couples relationship app that helps partners communicate better and grow closer together. Users swipe on thoughtful questions (yes/no/maybe), and when both partners answer positively, a "match" is created that unlocks a chat thread for that topic.

 ## Commands

@@ -65,7 +65,38 @@ There are two Supabase projects configured via MCP servers:
 When using Claude Code with MCP tools:
 - Use `mcp__sauci-prod__*` tools for production database operations
 - Use `mcp__sauci-non-prod__*` tools for development/staging database operations
- **Always verify which environment you're targeting before running migrations or destructive operations**
+- **Always verify which environment you're targeting before running destructive operations**
+
+### Database Migrations - IMPORTANT
+
+**NEVER use MCP tools (`apply_migration`) for database migrations.** Always use the Supabase CLI instead.
+
+**Why:** MCP migrations are tracked in the database but do NOT create local migration files. This means:
+- Migration history is not committed to git
+- Other developers won't get the schema changes
+- `supabase db reset` won't include MCP-applied migrations
+- Changes cannot be reproduced from scratch
+
+**Correct workflow for schema changes:**
+```bash
+# 1. Create migration file locally
+supabase migration new <descriptive_name>
+
+# 2. Edit the migration file in apps/supabase/migrations/
+
+# 3. Test locally
+supabase db reset
+
+# 4. Deploy to remote (link to correct project first)
+supabase link --project-ref <project_ref>
+supabase db push
+```
+
+**MCP tools ARE appropriate for:**
+- Reading data (`execute_sql` for SELECT queries)
+- Exploring schema (`list_tables`, `list_migrations`)
+- Deploying edge functions (`deploy_edge_function`)
+- Generating types (`generate_typescript_types`)

 ## Architecture

@@ -103,6 +134,7 @@ Edge functions in `apps/supabase/functions/` handle complex operations:
 - `delete-relationship` - Deletes couple data (matches, messages, media) while keeping accounts
 - `delete-account` - Permanently deletes user account and all associated data (Apple App Store requirement)
 - `send-notification` - Push notifications for matches
+- `send-nudge-notification` - Partner nudge notifications (rate limited to once per 12 hours)
 - `revenuecat-webhook` - Subscription webhook handler
 - `sync-subscription` - Syncs RevenueCat subscription status
 - `redeem-code` - Redeems promotional codes for premium access (website only)
@@ -134,6 +166,7 @@ This approach:
 | `revenuecat-webhook` | false | Webhook signature validation |
 | `send-notification` | false | Internal trigger (no auth) |
 | `send-message-notification` | false | Internal trigger (no auth) |
+| `send-nudge-notification` | false | Manual via getUser() |

 ### Database Best Practices
 - **Always use `.maybeSingle()` instead of `.single()`** when the row might not exist. `.single()` throws an error if 0 or >1 rows are returned.
@@ -179,3 +212,87 @@ backgroundColor: 'rgba(18, 18, 18, 0.85)',
 The `BlurView` in `tabBarBackground` is unreliable and can fail during re-renders/transitions, causing a fully transparent tab bar. The solid rgba background acts as a fallback while still allowing the blur effect on top.

 **Location:** `apps/mobile/app/(app)/_layout.tsx` - `tabBarStyle`
+
+## Infrastructure as Code (Terraform)
+
+Supabase project configuration is managed via Terraform in the `terraform/` directory. This includes auth settings, OAuth providers, email templates, SMTP config, rate limits, and more.
+
+**Directory structure:**
+```
+terraform/
+├── modules/
+│   └── supabase/           # Shared configuration module
+│       ├── main.tf
+│       ├── variables.tf
+│       ├── outputs.tf
+│       └── templates/      # Email templates
+└── environments/
+    ├── prod/               # Production (ckjcrkjpmhqhiucifukx)
+    └── non-prod/           # Non-production (itbzhrvlgvdmzbnhzhyx)
+```
+
+**When to update Terraform:**
+- Changing auth settings (OAuth providers, JWT expiry, MFA settings)
+- Modifying email templates or subjects
+- Updating rate limits or security settings
+- Changing SMTP configuration
+- Modifying storage or API settings
+
+**Workflow (always test in non-prod first):**
+```bash
+# 1. Apply to non-prod first
+cd terraform/environments/non-prod
+export TF_VAR_supabase_access_token=sbp_xxxxx
+terraform plan
+terraform apply
+
+# 2. Verify changes work in non-prod
+
+# 3. Apply to prod
+cd terraform/environments/prod
+terraform plan
+terraform apply
+```
+
+**Important:** After making Terraform changes, remind the user to:
+1. Commit the updated `terraform/` files
+2. The GitHub Action will auto-apply on merge to master (non-prod first, then prod)
+
+**Do NOT use Terraform for:**
+- Database schema changes (use migrations)
+- Edge function deployment (use CLI or MCP)
+- Storage bucket creation (use migrations)
+
+## Edge Function Secrets
+
+Edge functions use secrets stored in Supabase. These are synced from GitHub Secrets during CI/CD deployment.
+
+**Current secrets:**
+| Secret | Used By | Description |
+|--------|---------|-------------|
+| `REVENUECAT_WEBHOOK_SECRET` | revenuecat-webhook | Webhook signature validation |
+| `REVENUECAT_API_KEY` | sync-subscription | RevenueCat API access |
+| `REVENUECAT_ENTITLEMENT_ID` | sync-subscription | Entitlement identifier |
+| `OPENROUTER_API_KEY` | classify-message | AI classification API |
+| `ADMIN_PRIVATE_KEY_JWK` | admin-decrypt-* | E2EE admin decryption |
+| `ADMIN_KEYS_JSON` | admin-decrypt-*, migrate-e2ee | Multiple admin keys |
+| `DISCORD_WEBHOOK_URL` | send-discord-notification | Discord notifications |
+
+**Auto-provided by Supabase (don't set):**
+- `SUPABASE_URL`
+- `SUPABASE_ANON_KEY`
+- `SUPABASE_SERVICE_ROLE_KEY`
+
+**When adding a new edge function that needs secrets:**
+1. Add the secret to the edge function code: `Deno.env.get("SECRET_NAME")`
+2. Update `.github/workflows/deploy-supabase.yml` to include the new secret in the sync step
+3. Update `apps/supabase/functions/.secrets.example` with the new secret
+4. **Remind the user** to add the secret to GitHub Secrets (Settings → Secrets → Actions)
+5. Update this table in CLAUDE.md
+
+**Local development:**
+```bash
+cp apps/supabase/functions/.secrets.example apps/supabase/functions/.secrets
+# Fill in values
+supabase functions serve --env-file apps/supabase/functions/.secrets
+```
@@ -25,7 +25,7 @@
        "@radix-ui/react-switch": "^1.0.3",
        "@radix-ui/react-tabs": "^1.0.4",
        "@radix-ui/react-tooltip": "^1.0.7",
-        "@sauci/shared": "workspace:*",
+        "@sauci/shared": "file:../../packages/shared",
        "@supabase/supabase-js": "^2.39.0",
        "class-variance-authority": "^0.7.0",
        "clsx": "^2.1.0",
@@ -60,6 +60,14 @@ function App() {
                                </ProtectedRoute>
                            }
                        />
+                        <Route
+                            path="/categories/:categoryId/dare-packs"
+                            element={
+                                <ProtectedRoute requiredPermission={PERMISSION_KEYS.MANAGE_PACKS}>
+                                    <DarePacksPage />
+                                </ProtectedRoute>
+                            }
+                        />
                        <Route
                            path="/packs/:packId/questions"
                            element={
@@ -114,7 +114,7 @@ export function AiGeneratorDialog({
                        context={context}
                        config={generation.config}
                        onCountChange={generation.setCount}
-                        onToneChange={generation.setTone}
+                        onExplicitChange={generation.setExplicit}
                        onCrudeLangChange={generation.setCrudeLang}
                        onInspirationChange={generation.setInspiration}
                    />
@@ -1,9 +1,7 @@
-import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
 import { Textarea } from '@/components/ui/textarea';
 import { Switch } from '@/components/ui/switch';
-import { TONE_LEVELS, type ToneLevel } from '@/lib/openai';
 import type { GeneratorType, GeneratorContext, GenerationConfig } from './hooks/useAiGeneration';

 // =============================================================================
@@ -15,7 +13,7 @@ interface GenerationFormProps {
    context?: GeneratorContext;
    config: GenerationConfig;
    onCountChange: (count: number) => void;
-    onToneChange: (tone: ToneLevel) => void;
+    onExplicitChange: (isExplicit: boolean) => void;
    onCrudeLangChange: (crudeLang: boolean) => void;
    onInspirationChange: (inspiration: string) => void;
 }
@@ -29,12 +27,10 @@ export function GenerationForm({
    context,
    config,
    onCountChange,
-    onToneChange,
+    onExplicitChange,
    onCrudeLangChange,
    onInspirationChange,
 }: GenerationFormProps) {
-    const isExplicit = config.tone >= 4;
-
    return (
        <div className="space-y-4">
            {/* Question Count (questions only) */}
@@ -53,42 +49,15 @@ export function GenerationForm({
                </div>
            )}

-            {/* Intimacy Level Selector (questions only) */}
-            {type === 'questions' && (
-                <div className="space-y-2">
-                    <Label>Intimacy Level</Label>
-                    <div className="flex flex-wrap gap-2">
-                        {TONE_LEVELS.map((t) => (
-                            <Button
-                                key={t.level}
-                                type="button"
-                                variant={config.tone === t.level ? 'default' : 'outline'}
-                                size="sm"
-                                onClick={() => onToneChange(t.level as ToneLevel)}
-                                className={config.tone === t.level ? 'ring-2 ring-offset-1' : ''}
-                                title={t.description}
-                            >
-                                {t.level}. {t.label}
-                            </Button>
-                        ))}
-                    </div>
-                    <p className="text-xs text-muted-foreground">
-                        {TONE_LEVELS.find(t => t.level === config.tone)?.description}
-                    </p>
-                </div>
-            )}
-
-            {/* Wild/Explicit Toggle (for other generators) */}
-            {(type === 'category-ideas' || type === 'category-pack-ideas' || type === 'pack') && (
+            {/* Explicit Toggle */}
            <div className="flex items-center space-x-2">
                <Switch
                    id="explicit-mode"
-                        checked={isExplicit}
-                        onCheckedChange={(checked: boolean) => onToneChange(checked ? 5 : 3)}
+                    checked={config.isExplicit}
+                    onCheckedChange={onExplicitChange}
                />
-                    <Label htmlFor="explicit-mode">Include Wild/Adult Ideas</Label>
+                <Label htmlFor="explicit-mode">Explicit Content</Label>
            </div>
-            )}

            {/* Crude Language Override Toggle */}
            <div className="flex items-center space-x-2">
@@ -10,7 +10,6 @@ import {
    Bot,
 } from 'lucide-react';
 import {
-    INTENSITY_LEVELS,
    type GeneratedQuestion,
    type QuestionReview,
    type CouncilGenerationResult,
@@ -199,16 +198,6 @@ function QuestionItem({
                        )}
                    </div>
                    <div className="flex items-center gap-2 flex-wrap">
-                        {/* Intensity Badge */}
-                        <span
-                            className={`inline-block text-xs px-2 py-0.5 rounded text-white ${
-                                INTENSITY_LEVELS[question.intensity - 1]?.color || 'bg-muted'
-                            }`}
-                            title={INTENSITY_LEVELS[question.intensity - 1]?.description}
-                        >
-                            {question.intensity} - {INTENSITY_LEVELS[question.intensity - 1]?.label || 'Unknown'}
-                        </span>
-
                        {/* Source Generator Badge (cherry-pick mode) */}
                        {selectionMode === 'cherry_pick' && question.sourceGeneratorModel && (
                            <span className="inline-flex items-center gap-1 text-xs px-2 py-0.5 rounded bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400">
@@ -228,7 +217,7 @@ function QuestionItem({
                                            : 'bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400'
                                }`}
                                title={review.scores
-                                    ? `Scores: ${review.scores.guidelineCompliance}/${review.scores.creativity}/${review.scores.clarity}/${review.scores.intensityAccuracy}`
+                                    ? `Scores: ${review.scores.guidelineCompliance}/${review.scores.creativity}/${review.scores.clarity}`
                                    : ''
                                }
                            >
@@ -91,15 +91,6 @@ export function ReviewSummary({
                        </p>
                    )}

-                    {/* Intensity distribution for cherry-pick */}
-                    {selectionMode === 'cherry_pick' && cherryPickResult && Object.keys(cherryPickResult.intensityDistribution).length > 0 && (
-                        <p>
-                            Intensity distribution: {Object.entries(cherryPickResult.intensityDistribution)
-                                .sort(([a], [b]) => Number(a) - Number(b))
-                                .map(([level, count]) => `L${level}:${count}`)
-                                .join(', ')}
-                        </p>
-                    )}
                </div>
            )}
        </div>
@@ -10,7 +10,6 @@ import {
    type GeneratedQuestion,
    type GeneratedCategoryIdea,
    type GeneratedPackIdea,
-    type ToneLevel,
    type QuestionReview,
    type CouncilGenerationResult,
    type GenerationCandidate,
@@ -38,7 +37,7 @@ export interface GeneratorContext {

 export interface GenerationConfig {
    count: number;
-    tone: ToneLevel;
+    isExplicit: boolean;
    crudeLang: boolean;
    inspiration: string;
 }
@@ -77,7 +76,7 @@ export function useAiGeneration(
    // Config state
    const [config, setConfig] = useState<GenerationConfig>({
        count: 10,
-        tone: context?.isExplicit ? 5 : 2,
+        isExplicit: Boolean(context?.isExplicit),
        crudeLang: false,
        inspiration: '',
    });
@@ -118,14 +117,12 @@ export function useAiGeneration(
    // Council config
    const councilConfig = getCouncilConfig();

-    // Update tone when context changes
+    // Update explicit flag when context changes
    useEffect(() => {
-        if (type === 'questions') {
        setConfig(prev => ({
            ...prev,
-                tone: context?.isExplicit ? 5 : 2,
+            isExplicit: Boolean(context?.isExplicit),
        }));
-        }
    }, [context?.isExplicit, type]);

    // Config setters
@@ -133,8 +130,8 @@ export function useAiGeneration(
        setConfig(prev => ({ ...prev, count }));
    }, []);

-    const setTone = useCallback((tone: ToneLevel) => {
-        setConfig(prev => ({ ...prev, tone }));
+    const setExplicit = useCallback((isExplicit: boolean) => {
+        setConfig(prev => ({ ...prev, isExplicit }));
    }, []);

    const setCrudeLang = useCallback((crudeLang: boolean) => {
@@ -219,7 +216,7 @@ export function useAiGeneration(
        setFilter('all');
        setSourceModel(null);

-        const isExplicit = config.tone >= 4;
+        const isExplicit = config.isExplicit;

        try {
            if (type === 'pack') {
@@ -253,7 +250,7 @@ export function useAiGeneration(
                    context.packName,
                    config.count,
                    undefined,
-                    config.tone,
+                    isExplicit ? 5 : 2,
                    context.packDescription || undefined,
                    context.existingQuestions,
                    config.crudeLang,
@@ -369,7 +366,7 @@ export function useAiGeneration(
        // Config
        config,
        setCount,
-        setTone,
+        setExplicit,
        setCrudeLang,
        setInspiration,

@@ -45,6 +45,8 @@ export interface PackFormData {
    is_public: boolean;
    is_explicit: boolean;
    category_id: string;
+    scheduled_release_at?: string | null;  // Optional for backwards compatibility
+    skip_notification?: boolean;  // If true, sets release_notified=true to skip notifications
 }

 export interface PackFormDialogProps {
@@ -200,10 +202,64 @@ export function PackFormDialog({
                        </div>
                        <Switch
                            checked={formData.is_public}
-                            onCheckedChange={(checked) => setField('is_public', checked)}
+                            onCheckedChange={(checked) => {
+                                const next = {
+                                    ...formData,
+                                    is_public: checked,
+                                    ...(checked ? { scheduled_release_at: null } : {}),
+                                };
+                                onFormChange(next);
+                            }}
                        />
                    </div>

+                    {/* Scheduled Release - only show when not public */}
+                    {!formData.is_public && (
+                        <div className="space-y-4 p-3 rounded-md bg-muted/50 border border-dashed">
+                            <div className="space-y-2">
+                                <Label htmlFor="scheduled_release_at">Scheduled Release</Label>
+                                <p className="text-sm text-muted-foreground">
+                                    Automatically make this pack public at a specific time. Users will be notified when it becomes available.
+                                </p>
+                                <Input
+                                    id="scheduled_release_at"
+                                    type="datetime-local"
+                                    value={formData.scheduled_release_at ? new Date(formData.scheduled_release_at).toISOString().slice(0, 16) : ''}
+                                    onChange={(e) => {
+                                        const value = e.target.value;
+                                        setField('scheduled_release_at', value ? new Date(value).toISOString() : null);
+                                    }}
+                                    className="w-full"
+                                />
+                                {formData.scheduled_release_at && (
+                                    <Button
+                                        type="button"
+                                        variant="ghost"
+                                        size="sm"
+                                        onClick={() => setField('scheduled_release_at', null)}
+                                        className="mt-1"
+                                    >
+                                        Clear scheduled release
+                                    </Button>
+                                )}
+                            </div>
+
+                            {/* Skip Notification Toggle */}
+                            <div className="flex items-center justify-between pt-2 border-t">
+                                <div className="space-y-0.5">
+                                    <Label>Skip release notification</Label>
+                                    <p className="text-sm text-muted-foreground">
+                                        Release without notifying users
+                                    </p>
+                                </div>
+                                <Switch
+                                    checked={formData.skip_notification ?? false}
+                                    onCheckedChange={(checked) => setField('skip_notification', checked)}
+                                />
+                            </div>
+                        </div>
+                    )}
+
                    {/* Explicit Toggle */}
                    <div className="flex items-center justify-between">
                        <div className="space-y-0.5">
@@ -26,6 +26,16 @@ import { supabase } from '@/config';
 import { auditedSupabase } from '@/hooks/useAuditedSupabase';
 import { toast } from 'sonner';

+type QuestionType = 'swipe' | 'text_answer' | 'audio' | 'photo' | 'who_likely';
+
+const QUESTION_TYPE_LABELS: Record<QuestionType, string> = {
+    swipe: 'Swipe',
+    text_answer: 'Text Answer',
+    audio: 'Audio',
+    photo: 'Photo',
+    who_likely: 'Who Is More Likely',
+};
+
 interface Question {
    id: string;
    text: string;
@@ -34,6 +44,7 @@ interface Question {
    allowed_couple_genders: string[] | null;
    target_user_genders: string[] | null;
    required_props?: string[] | null;
+    question_type?: QuestionType | null;
 }

 interface ReviewQuestionsDialogProps {
@@ -601,6 +612,11 @@ export function ReviewQuestionsDialog({ open, onOpenChange, questions, isExplici
                                                        {/* Question Column */}
                                                        <TableCell className="align-top py-3">
                                                            <div className="text-sm font-medium">{suggestion.question.text}</div>
+                                                            <div className="mt-1">
+                                                                <Badge variant="outline" className="text-[10px] uppercase tracking-wide text-muted-foreground">
+                                                                    {QUESTION_TYPE_LABELS[suggestion.question.question_type ?? 'swipe']}
+                                                                </Badge>
+                                                            </div>
                                                            {suggestion.question.partner_text && (
                                                                <div className="text-xs text-muted-foreground mt-1.5 italic">
                                                                    Partner: {suggestion.question.partner_text}
@@ -20,6 +20,7 @@ export const PERMISSION_KEYS = {
    VIEW_RESPONSES: 'view_responses',
    VIEW_ACTIVITY: 'view_activity',
    MANAGE_FEEDBACK: 'manage_feedback',
+    GIFT_PREMIUM: 'gift_premium',
    // System permissions
    MANAGE_CODES: 'manage_codes',
    MANAGE_ADMINS: 'manage_admins',
@@ -42,6 +43,7 @@ export const PERMISSION_METADATA: Record<PermissionKey, { label: string; descrip
    [PERMISSION_KEYS.VIEW_RESPONSES]: { label: 'Can view responses', description: 'View user question responses', group: 'users' },
    [PERMISSION_KEYS.VIEW_ACTIVITY]: { label: 'Can view activity', description: 'View user activity feed (responses, matches, messages, signups)', group: 'users' },
    [PERMISSION_KEYS.MANAGE_FEEDBACK]: { label: 'Can manage feedback', description: 'View and respond to user feedback', group: 'users' },
+    [PERMISSION_KEYS.GIFT_PREMIUM]: { label: 'Can gift premium', description: 'Manually upgrade users to premium status', group: 'users' },
    [PERMISSION_KEYS.MANAGE_CODES]: { label: 'Can manage redemption codes', description: 'Create and view redemption codes', group: 'system' },
    [PERMISSION_KEYS.MANAGE_ADMINS]: { label: 'Can manage admins', description: 'Add/remove admin users and change permissions', group: 'system' },
    [PERMISSION_KEYS.MANAGE_AI_CONFIG]: { label: 'Can manage AI settings', description: 'Configure AI models, API keys, and council mode', group: 'system' },
@@ -5,6 +5,7 @@ export interface AppConfig {
    id: string;
    answer_gap_threshold: number;
    daily_response_limit: number;
+    couple_intensity_gate_enabled: boolean | null;
    updated_at: string | null;
    updated_by: string | null;
 }
@@ -4,6 +4,7 @@ import { useAuth, PERMISSION_KEYS } from '@/contexts/AuthContext';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
+import { Switch } from '@/components/ui/switch';
 import { Skeleton } from '@/components/ui/skeleton';
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
 import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert';
@@ -29,6 +30,7 @@ export function AppSettingsPage() {
            setFormData({
                answer_gap_threshold: config.answer_gap_threshold ?? 10,
                daily_response_limit: config.daily_response_limit ?? 0,
+                couple_intensity_gate_enabled: config.couple_intensity_gate_enabled ?? false,
            });
            setHasChanges(false);
        }
@@ -61,6 +63,7 @@ export function AppSettingsPage() {
            setFormData({
                answer_gap_threshold: config.answer_gap_threshold ?? 10,
                daily_response_limit: config.daily_response_limit ?? 0,
+                couple_intensity_gate_enabled: config.couple_intensity_gate_enabled ?? false,
            });
            setHasChanges(false);
        }
@@ -157,6 +160,19 @@ export function AppSettingsPage() {
                    </CardDescription>
                </CardHeader>
                <CardContent className="space-y-4">
+                    <div className="flex items-center justify-between">
+                        <div className="space-y-0.5">
+                            <Label>Couple Comfort Zone Gate</Label>
+                            <p className="text-sm text-muted-foreground">
+                                When enabled, both recommended questions and answer-gap blocking use the lower of the two partners' comfort zones.
+                            </p>
+                        </div>
+                        <Switch
+                            checked={Boolean(formData.couple_intensity_gate_enabled)}
+                            onCheckedChange={(checked) => handleChange('couple_intensity_gate_enabled', checked)}
+                        />
+                    </div>
+
                    <div className="space-y-2">
                        <Label htmlFor="threshold">Answer Gap Threshold</Label>
                        <Input
@@ -49,6 +49,7 @@ interface ResponseActivity {
        id: string;
        text: string;
        pack: {
+            id: string;
            name: string;
        } | null;
    } | null;
@@ -155,7 +156,7 @@ export function UserActivityPage() {
                    profile:profiles!responses_user_id_fkey(id, name, email),
                    question:questions(
                        id, text,
-                        pack:question_packs(name)
+                        pack:question_packs(id, name)
                    )
                `, { count: 'exact' })
                .order('created_at', { ascending: false })
@@ -317,18 +318,22 @@ export function UserActivityPage() {
    const fetchSignups = useCallback(async () => {
        setLoading(prev => ({ ...prev, signups: true }));
        try {
-            const from = (signupsPage - 1) * signupsPageSize;
-            const to = from + signupsPageSize - 1;
-
-            const { data, error, count } = await supabase
-                .from('profiles')
-                .select('id, name, email, avatar_url, created_at, onboarding_completed, couple_id', { count: 'exact' })
-                .order('created_at', { ascending: false })
-                .range(from, to);
+            // Use RPC to get profiles with auth info (includes email from auth.users)
+            const { data: allData, error } = await supabase
+                .rpc('get_profiles_with_auth_info');

            if (error) throw error;
-            setSignups(data || []);
-            setSignupsTotal(count || 0);
+
+            // Sort by created_at descending and apply pagination
+            const sorted = (allData || []).sort((a: SignupActivity, b: SignupActivity) =>
+                new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+            );
+
+            const from = (signupsPage - 1) * signupsPageSize;
+            const to = from + signupsPageSize;
+
+            setSignups(sorted.slice(from, to));
+            setSignupsTotal(sorted.length);
        } catch (error) {
            console.error('Failed to load signups:', error);
            toast.error("Failed to load signups");
@@ -502,14 +507,31 @@ export function UserActivityPage() {
                                        <TableRow key={item.id}>
                                            <TableCell>{renderUserLink(item.profile)}</TableCell>
                                            <TableCell className="max-w-[300px]">
+                                                {item.question?.pack?.id ? (
+                                                    <Link
+                                                        to={`/packs/${item.question.pack.id}/questions`}
+                                                        className="truncate block text-primary hover:underline"
+                                                    >
+                                                        {item.question?.text || 'Unknown question'}
+                                                    </Link>
+                                                ) : (
                                                    <span className="truncate block">
                                                        {item.question?.text || 'Unknown question'}
                                                    </span>
+                                                )}
                                            </TableCell>
                                            <TableCell>
+                                                {item.question?.pack?.id ? (
+                                                    <Link to={`/packs/${item.question.pack.id}/questions`}>
+                                                        <Badge variant="outline" className="hover:bg-primary/10 cursor-pointer">
+                                                            {item.question.pack.name}
+                                                        </Badge>
+                                                    </Link>
+                                                ) : (
                                                    <Badge variant="outline">
                                                        {item.question?.pack?.name || 'Unknown'}
                                                    </Badge>
+                                                )}
                                            </TableCell>
                                            <TableCell>{renderAnswerBadge(item.answer)}</TableCell>
                                            <TableCell className="text-muted-foreground text-sm whitespace-nowrap">
@@ -56,7 +56,8 @@ interface Category {
    sort_order: number | null;
    created_at: string | null;
    is_public: boolean;
-    pack_count?: number;
+    question_pack_count?: number;
+    dare_pack_count?: number;
 }

 interface CategoryFormData {
@@ -134,9 +135,14 @@ function SortableCategoryCard({ category, onEdit, onDelete, onToggleVisibility }
                </div>

                <div className="flex items-center justify-between mt-auto">
+                    <div className="flex flex-wrap gap-2">
                        <Badge variant="secondary" className="font-normal">
-                        {category.pack_count} pack{category.pack_count !== 1 ? 's' : ''}
+                            {category.question_pack_count} question pack{category.question_pack_count !== 1 ? 's' : ''}
                        </Badge>
+                        <Badge variant="secondary" className="font-normal">
+                            {category.dare_pack_count} dare pack{category.dare_pack_count !== 1 ? 's' : ''}
+                        </Badge>
+                    </div>

                    <div className="flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity">
                        <Button
@@ -158,11 +164,18 @@ function SortableCategoryCard({ category, onEdit, onDelete, onToggleVisibility }
                    </div>
                </div>

+                <div className="grid gap-2">
                    <Link to={`/categories/${category.id}/packs`}>
                        <Button variant="outline" className="w-full">
-                        View Packs
+                            View Question Packs
                        </Button>
                    </Link>
+                    <Link to={`/categories/${category.id}/dare-packs`}>
+                        <Button variant="outline" className="w-full">
+                            View Dare Packs
+                        </Button>
+                    </Link>
+                </div>
            </CardContent>
        </Card>
    );
@@ -213,17 +226,30 @@ export function CategoriesPage() {
            setTotalCount(count || 0);

            const categoryIds = (cats || []).map(c => c.id);
-            const packCounts: Record<string, number> = {};
+            const questionPackCounts: Record<string, number> = {};
+            const darePackCounts: Record<string, number> = {};

            if (categoryIds.length > 0) {
-                const { data: packs } = await supabase
+                const [{ data: packs }, { data: darePacks }] = await Promise.all([
+                    supabase
                        .from('question_packs')
                        .select('category_id')
-                    .in('category_id', categoryIds);
+                        .in('category_id', categoryIds),
+                    supabase
+                        .from('dare_packs')
+                        .select('category_id')
+                        .in('category_id', categoryIds),
+                ]);

                packs?.forEach(p => {
                    if (p.category_id) {
-                        packCounts[p.category_id] = (packCounts[p.category_id] || 0) + 1;
+                        questionPackCounts[p.category_id] = (questionPackCounts[p.category_id] || 0) + 1;
+                    }
+                });
+
+                darePacks?.forEach(p => {
+                    if (p.category_id) {
+                        darePackCounts[p.category_id] = (darePackCounts[p.category_id] || 0) + 1;
                    }
                });
            }
@@ -231,7 +257,8 @@ export function CategoriesPage() {
            setCategories(
                (cats || []).map(c => ({
                    ...c,
-                    pack_count: packCounts[c.id] || 0,
+                    question_pack_count: questionPackCounts[c.id] || 0,
+                    dare_pack_count: darePackCounts[c.id] || 0,
                }))
            );
        } catch (error) {
@@ -1,5 +1,5 @@
 import { useEffect, useState, useCallback } from 'react';
-import { Link } from 'react-router-dom';
+import { Link, useParams } from 'react-router-dom';
 import { supabase } from '@/config';
 import { auditedSupabase } from '@/hooks/useAuditedSupabase';
 import { useEntityForm } from '@/hooks/useEntityForm';
@@ -39,6 +39,7 @@ import { toast } from 'sonner';
 interface Category {
    id: string;
    name: string;
+    icon?: string | null;
 }

 interface DarePack {
@@ -73,9 +74,12 @@ interface DarePackFormData {
 // =============================================================================

 export function DarePacksPage() {
+    const { categoryId } = useParams<{ categoryId: string }>();
+
    // Data state
    const [darePacks, setDarePacks] = useState<DarePack[]>([]);
    const [categories, setCategories] = useState<Category[]>([]);
+    const [category, setCategory] = useState<Category | null>(null);
    const [loading, setLoading] = useState(true);
    const [page, setPage] = useState(1);
    const [pageSize, setPageSize] = useState(12);
@@ -90,7 +94,7 @@ export function DarePacksPage() {
            is_premium: false,
            is_public: false,
            is_explicit: false,
-            category_id: '',
+            category_id: categoryId ?? '',
        },
        (pack) => ({
            name: pack.name,
@@ -113,13 +117,31 @@ export function DarePacksPage() {
            const from = (page - 1) * pageSize;
            const to = from + pageSize - 1;

+            // Fetch category info
+            if (categoryId) {
+                const { data: categoryData } = await supabase
+                    .from('categories')
+                    .select('id, name, icon')
+                    .eq('id', categoryId)
+                    .single();
+                setCategory(categoryData || null);
+            } else {
+                setCategory(null);
+            }
+
            // Fetch dare packs
-            const { data: packData, error, count } = await supabase
+            let query = supabase
                .from('dare_packs')
                .select('*', { count: 'exact' })
                .order('sort_order', { ascending: true })
                .range(from, to);

+            if (categoryId) {
+                query = query.eq('category_id', categoryId);
+            }
+
+            const { data: packData, error, count } = await query;
+
            if (error) throw error;

            setTotalCount(count || 0);
@@ -159,12 +181,16 @@ export function DarePacksPage() {
        } finally {
            setLoading(false);
        }
-    }, [page, pageSize]);
+    }, [page, pageSize, categoryId]);

    useEffect(() => {
        fetchData();
    }, [fetchData]);

+    useEffect(() => {
+        setPage(1);
+    }, [categoryId]);
+
    useEffect(() => {
        const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
        if (page > totalPages) {
@@ -305,16 +331,27 @@ export function DarePacksPage() {
            <div className="flex items-center justify-between">
                <div>
                    <h1 className="text-3xl font-bold tracking-tight flex items-center gap-2">
+                        {category ? (
+                            <>
+                                <IconPreview value={category.icon} fallback="flame-outline" className="text-3xl" />
+                                {category.name}
+                            </>
+                        ) : (
+                            <>
                                <Zap className="h-8 w-8 text-orange-500" />
                                Dare Packs
+                            </>
+                        )}
                    </h1>
                    <p className="text-muted-foreground">
-                        Manage dare packs that users can send to their partners
+                        {category
+                            ? `Manage dare packs in the ${category.name} category`
+                            : 'Manage dare packs that users can send to their partners'}
                    </p>
                </div>
                <Dialog open={form.dialogOpen} onOpenChange={form.setDialogOpen}>
                    <DialogTrigger asChild>
-                        <Button onClick={form.openCreate}>
+                        <Button onClick={() => form.openCreateWith({ category_id: categoryId ?? '' })}>
                            <Plus className="mr-2 h-4 w-4" />
                            Add Dare Pack
                        </Button>
@@ -37,7 +37,6 @@ import { Plus, Pencil, Trash2, Zap, Loader2, Clock } from 'lucide-react';
 import { Checkbox } from '@/components/ui/checkbox';
 import { toast } from 'sonner';
 import { IconPreview } from '@/components/ui/icon-picker';
-import { INTENSITY_LEVELS } from '@/lib/openai';

 // =============================================================================
 // Types
@@ -71,8 +70,7 @@ const DURATION_OPTIONS = [
    { value: '168', label: '1 week' },
 ];

-// Helper to get intensity info by level (1-indexed)
-const getIntensity = (level: number) => INTENSITY_LEVELS[level - 1] || INTENSITY_LEVELS[0];
+const getDefaultIntensity = (isExplicit?: boolean) => (isExplicit ? 4 : 2);

 // Format duration for display
 const formatDuration = (hours: number | null): string => {
@@ -107,7 +105,7 @@ export function DaresPage() {
        suggested_duration_hours: string;
    }>({
        text: '',
-        intensity: 1,
+        intensity: getDefaultIntensity(),
        suggested_duration_hours: '',
    });

@@ -169,7 +167,7 @@ export function DaresPage() {

    const openCreateDialog = () => {
        setEditingDare(null);
-        setFormData({ text: '', intensity: 1, suggested_duration_hours: '' });
+        setFormData({ text: '', intensity: getDefaultIntensity(pack?.is_explicit), suggested_duration_hours: '' });
        setDialogOpen(true);
    };

@@ -343,25 +341,6 @@ export function DaresPage() {
                                />
                            </div>

-                            <div className="space-y-2">
-                                <Label>Intensity Level</Label>
-                                <div className="flex gap-2 flex-wrap">
-                                    {INTENSITY_LEVELS.map((intensity) => (
-                                        <Button
-                                            key={intensity.level}
-                                            type="button"
-                                            variant={formData.intensity === intensity.level ? 'default' : 'outline'}
-                                            size="sm"
-                                            onClick={() => setFormData(d => ({ ...d, intensity: intensity.level }))}
-                                            className={formData.intensity === intensity.level ? intensity.color : ''}
-                                            title={intensity.description}
-                                        >
-                                            {intensity.level} - {intensity.label}
-                                        </Button>
-                                    ))}
-                                </div>
-                            </div>
-
                            <div className="space-y-2">
                                <Label>Suggested Duration</Label>
                                <Select
@@ -467,7 +446,6 @@ export function DaresPage() {
                                </TableHead>
                                <TableHead className="w-12">#</TableHead>
                                <TableHead>Dare</TableHead>
-                                <TableHead className="w-24">Intensity</TableHead>
                                <TableHead className="w-24">Duration</TableHead>
                                <TableHead className="w-24">Actions</TableHead>
                            </TableRow>
@@ -491,14 +469,6 @@ export function DaresPage() {
                                    <TableCell>
                                        <span className="line-clamp-2">{dare.text}</span>
                                    </TableCell>
-                                    <TableCell>
-                                        <Badge
-                                            className={`${getIntensity(dare.intensity).color} text-white`}
-                                            title={getIntensity(dare.intensity).description}
-                                        >
-                                            {getIntensity(dare.intensity).label}
-                                        </Badge>
-                                    </TableCell>
                                    <TableCell>
                                        {dare.suggested_duration_hours ? (
                                            <Badge variant="outline" className="text-xs">
@@ -8,7 +8,7 @@ import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/com
 import { Badge } from '@/components/ui/badge';
 import { Skeleton } from '@/components/ui/skeleton';
 import { PaginationControls } from '@/components/ui/pagination';
-import { Plus, MessageCircle, Pencil, Trash2, Sparkles, Crown, Eye, EyeOff, Flame, Heart, Tags, ChevronUp, ChevronDown } from 'lucide-react';
+import { Plus, MessageCircle, Pencil, Trash2, Sparkles, Crown, Eye, EyeOff, Flame, Heart, Tags, ChevronUp, ChevronDown, Clock, BellOff } from 'lucide-react';
 import { toast } from 'sonner';
 import { AiGeneratorDialog } from '@/components/ai/AiGeneratorDialog';
 import { ExtractTopicsDialog } from '@/components/content/ExtractTopicsDialog';
@@ -41,6 +41,8 @@ interface QuestionPack {
    sort_order: number | null;
    category_id: string | null;
    created_at: string | null;
+    scheduled_release_at?: string | null;  // Optional for backwards compatibility
+    release_notified?: boolean;  // True if notifications have been sent or should be skipped
    question_count?: number;
    topics?: Topic[];
 }
@@ -76,6 +78,8 @@ export function PacksPage() {
            is_public: false,
            is_explicit: false,
            category_id: categoryId ?? '',
+            scheduled_release_at: null,
+            skip_notification: false,
        },
        (pack) => ({
            name: pack.name,
@@ -85,6 +89,8 @@ export function PacksPage() {
            is_public: pack.is_public,
            is_explicit: pack.is_explicit,
            category_id: pack.category_id || '',
+            scheduled_release_at: pack.scheduled_release_at,
+            skip_notification: false,  // Always start unchecked when editing
        })
    );

@@ -223,6 +229,13 @@ export function PacksPage() {
            let packId: string;

            if (form.editingItem) {
+                // Determine release_notified value
+                // If skip_notification is checked, set release_notified=true to prevent notifications
+                // Otherwise, reset to false when scheduling a new release
+                const releaseNotifiedValue = form.formData.skip_notification
+                    ? true
+                    : (form.formData.scheduled_release_at ? false : undefined);
+
                const { error } = await auditedSupabase.update('question_packs', form.editingItem.id, {
                    name: form.formData.name,
                    description: form.formData.description || null,
@@ -231,6 +244,12 @@ export function PacksPage() {
                    is_public: form.formData.is_public,
                    is_explicit: form.formData.is_explicit,
                    category_id: form.formData.category_id || null,
+                    // Only include scheduled_release_at if the field exists in form data (backwards compatible)
+                    ...('scheduled_release_at' in form.formData && {
+                        scheduled_release_at: form.formData.scheduled_release_at,
+                        // Set release_notified based on skip_notification toggle
+                        ...(releaseNotifiedValue !== undefined && { release_notified: releaseNotifiedValue }),
+                    }),
                });
                if (error) throw error;
                packId = form.editingItem.id;
@@ -246,6 +265,12 @@ export function PacksPage() {
                        is_explicit: form.formData.is_explicit,
                        category_id: form.formData.category_id || null,
                        sort_order: totalCount,
+                        // Only include scheduled_release_at if the field exists in form data (backwards compatible)
+                        ...('scheduled_release_at' in form.formData && {
+                            scheduled_release_at: form.formData.scheduled_release_at,
+                            // If skip_notification is checked, set release_notified=true
+                            ...(form.formData.skip_notification && { release_notified: true }),
+                        }),
                    })
                    .select('id')
                    .single();
@@ -305,6 +330,8 @@ export function PacksPage() {
                is_public: false,
                is_explicit: false,
                category_id: categoryId ?? '',
+                scheduled_release_at: null,
+                skip_notification: false,
            });
            setAiDialogOpen(false);
            setSelectedTopicIds(new Set());
@@ -497,6 +524,18 @@ export function PacksPage() {
                                                <Eye className="h-3 w-3 mr-1" />
                                                Published
                                            </Badge>
+                                        ) : pack.scheduled_release_at ? (
+                                            <>
+                                                <Badge variant="outline" className="border-blue-500 text-blue-400" title={`Releases: ${new Date(pack.scheduled_release_at).toLocaleString()}`}>
+                                                    <Clock className="h-3 w-3 mr-1" />
+                                                    Scheduled
+                                                </Badge>
+                                                {pack.release_notified && (
+                                                    <Badge variant="outline" className="border-gray-500 text-gray-400" title="Notifications skipped">
+                                                        <BellOff className="h-3 w-3" />
+                                                    </Badge>
+                                                )}
+                                            </>
                                        ) : (
                                            <Badge variant="secondary">
                                                <EyeOff className="h-3 w-3 mr-1" />
@@ -7,12 +7,15 @@ import { Button } from '@/components/ui/button';
 import { Bar, BarChart, ResponsiveContainer, XAxis, YAxis, Tooltip, Cell, Pie, PieChart as RechartsPieChart } from 'recharts';
 import { Crown, MessageCircle, PieChart, Sparkles, Tag, Eye, EyeOff } from 'lucide-react';

+type QuestionType = 'swipe' | 'text_answer' | 'audio' | 'photo' | 'who_likely';
+
 interface QuestionRow {
    id: string;
    pack_id: string;
    intensity: number | null;
    partner_text: string | null;
    inverse_of?: string | null;
+    question_type?: QuestionType | null;
 }

 interface PackRow {
@@ -62,6 +65,14 @@ type SegmentKey = 'all' | 'premium' | 'free';
 const intensityPalette = ['#22c55e', '#84cc16', '#facc15', '#f97316', '#ef4444'];
 const intensityLabels = ['Gentle', 'Warm', 'Playful', 'Steamy', 'Intense'];

+const QUESTION_TYPE_CONFIG: Record<QuestionType, { label: string; color: string }> = {
+    swipe: { label: 'Swipe', color: '#38bdf8' },
+    text_answer: { label: 'Text', color: '#f59e0b' },
+    audio: { label: 'Audio', color: '#a78bfa' },
+    photo: { label: 'Photo', color: '#f472b6' },
+    who_likely: { label: 'Who Likely', color: '#22c55e' },
+};
+
 const formatPercent = (count: number, total: number) => (total > 0 ? Math.round((count / total) * 100) : 0);

 const getCategoryName = (category?: PackRow['category']) => {
@@ -89,6 +100,7 @@ export function QuestionAnalyticsPage() {
        taggedQuestions: 0,
    });
    const [premiumBreakdown, setPremiumBreakdown] = useState<ChartDatum[]>([]);
+    const [questionTypeBreakdown, setQuestionTypeBreakdown] = useState<ChartDatum[]>([]);
    const [intensityBreakdown, setIntensityBreakdown] = useState<Record<SegmentKey, ChartDatum[]>>({
        all: [],
        premium: [],
@@ -125,7 +137,7 @@ export function QuestionAnalyticsPage() {
                const to = from + pageSize - 1;
                const { data, error } = await supabase
                    .from('questions')
-                    .select('id, pack_id, intensity, partner_text, inverse_of')
+                    .select('id, pack_id, intensity, partner_text, inverse_of, question_type')
                    .range(from, to);

                if (error) throw error;
@@ -210,6 +222,13 @@ export function QuestionAnalyticsPage() {
                    free: { ...emptyIntensityCounts },
                };
                const untaggedCounts: Record<SegmentKey, number> = { all: 0, premium: 0, free: 0 };
+                const questionTypeCounts: Record<QuestionType, number> = {
+                    swipe: 0,
+                    text_answer: 0,
+                    audio: 0,
+                    photo: 0,
+                    who_likely: 0,
+                };
                const categoryCountsBySegment: Record<SegmentKey, Map<string, BreakdownItem>> = {
                    all: new Map(),
                    premium: new Map(),
@@ -233,6 +252,9 @@ export function QuestionAnalyticsPage() {
                    const segmentKey: SegmentKey = isPremium ? 'premium' : 'free';
                    const categoryName = getCategoryName(pack?.category);
                    const categoryId = pack?.category_id || 'uncategorized';
+                    const questionType = question.question_type ?? 'swipe';
+
+                    questionTypeCounts[questionType] = (questionTypeCounts[questionType] || 0) + 1;

                    if (isPremium) {
                        premiumCount += 1;
@@ -302,6 +324,13 @@ export function QuestionAnalyticsPage() {
                    { name: 'Premium', value: premiumCount, color: '#f59e0b' },
                    { name: 'Free', value: freeCount, color: '#22c55e' },
                ];
+                const questionTypeData: ChartDatum[] = (Object.entries(QUESTION_TYPE_CONFIG) as Array<
+                    [QuestionType, { label: string; color: string }]
+                >).map(([key, config]) => ({
+                    name: config.label,
+                    value: questionTypeCounts[key],
+                    color: config.color,
+                }));

                const buildIntensityData = (key: SegmentKey) => intensityLabels.map((label, index) => ({
                    name: label,
@@ -355,6 +384,7 @@ export function QuestionAnalyticsPage() {
                    taggedQuestions: taggedCount,
                });
                setPremiumBreakdown(premiumData);
+                setQuestionTypeBreakdown(questionTypeData);
                setIntensityBreakdown(intensityData);
                setTopicBreakdown(topicData);
                setCategoryBreakdown(categoryData);
@@ -645,6 +675,58 @@ export function QuestionAnalyticsPage() {
                </Card>
            </div>

+            <Card>
+                <CardHeader>
+                    <CardTitle>Question Types</CardTitle>
+                    <CardDescription>
+                        Distribution of questions by answer format
+                    </CardDescription>
+                </CardHeader>
+                <CardContent>
+                    {loading ? (
+                        <Skeleton className="h-[240px] w-full" />
+                    ) : stats.totalQuestions === 0 ? (
+                        <div className="flex items-center justify-center h-[240px] text-muted-foreground">
+                            No question data available yet
+                        </div>
+                    ) : (
+                        <div className="h-[240px]">
+                            <ResponsiveContainer width="100%" height="100%">
+                                <BarChart data={questionTypeBreakdown}>
+                                    <XAxis
+                                        dataKey="name"
+                                        stroke="hsl(var(--muted-foreground))"
+                                        fontSize={11}
+                                        tickLine={false}
+                                        axisLine={false}
+                                    />
+                                    <YAxis
+                                        stroke="hsl(var(--muted-foreground))"
+                                        fontSize={11}
+                                        tickLine={false}
+                                        axisLine={false}
+                                        tickFormatter={(value) => `${value}`}
+                                    />
+                                    <Tooltip
+                                        cursor={{ fill: 'rgba(255,255,255,0.03)' }}
+                                        contentStyle={{
+                                            borderRadius: '8px',
+                                            border: '1px solid #e2e8f0',
+                                            boxShadow: '0 4px 6px -1px rgb(0 0 0 / 0.1)',
+                                        }}
+                                    />
+                                    <Bar dataKey="value" radius={[6, 6, 0, 0]}>
+                                        {questionTypeBreakdown.map((entry, index) => (
+                                            <Cell key={`cell-${index}`} fill={entry.color} />
+                                        ))}
+                                    </Bar>
+                                </BarChart>
+                            </ResponsiveContainer>
+                        </div>
+                    )}
+                </CardContent>
+            </Card>
+
            <Card>
                <CardHeader className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
                    <div>
@@ -42,6 +42,7 @@ import { toast } from 'sonner';
 import { AiGeneratorDialog } from '@/components/ai/AiGeneratorDialog';
 import { AIPolishButton } from '@/components/ai/AIPolishButton';
 import { ReviewQuestionsDialog } from '@/components/content/ReviewQuestionsDialog';
+import { IconPreview } from '@/components/ui/icon-picker';

 interface QuestionPack {
    id: string;
@@ -51,6 +52,12 @@ interface QuestionPack {
    is_explicit: boolean;
 }

+type QuestionType = 'swipe' | 'text_answer' | 'audio' | 'photo' | 'who_likely';
+
+interface QuestionConfig {
+    max_duration_seconds?: number;
+}
+
 interface Question {
    id: string;
    pack_id: string;
@@ -62,12 +69,34 @@ interface Question {
    required_props?: string[] | null;
    inverse_of?: string | null;
    created_at: string | null;
+    question_type?: QuestionType | null;
+    config?: QuestionConfig | null;
 }

-import { INTENSITY_LEVELS } from '@/lib/openai';
+const DEFAULT_AUDIO_DURATION = 60;
+const getDefaultIntensity = (isExplicit?: boolean) => (isExplicit ? 4 : 2);

-// Helper to get intensity info by level (1-indexed)
-const getIntensity = (level: number) => INTENSITY_LEVELS[level - 1] || INTENSITY_LEVELS[0];
+const QUESTION_TYPE_OPTIONS: Array<{ value: QuestionType; label: string }> = [
+    { value: 'swipe', label: 'Swipe' },
+    { value: 'text_answer', label: 'Text Answer' },
+    { value: 'audio', label: 'Audio' },
+    { value: 'photo', label: 'Photo' },
+    { value: 'who_likely', label: 'Who Is More Likely' },
+];
+
+const getQuestionTypeLabel = (type?: QuestionType | null) => {
+    const resolved = type ?? 'swipe';
+    return QUESTION_TYPE_OPTIONS.find(option => option.value === resolved)?.label ?? 'Swipe';
+};
+
+const getConfigSummary = (question: Question) => {
+    if (question.question_type === 'audio') {
+        const duration = question.config?.max_duration_seconds ?? DEFAULT_AUDIO_DURATION;
+        return `${duration}s max`;
+    }
+
+    return null;
+};

 export function QuestionsPage() {
    const { packId } = useParams<{ packId: string }>();
@@ -89,6 +118,7 @@ export function QuestionsPage() {
    const [page, setPage] = useState(1);
    const [pageSize, setPageSize] = useState(25);
    const [totalCount, setTotalCount] = useState(0);
+    const [questionTypeFilter, setQuestionTypeFilter] = useState<QuestionType | 'all'>('all');

    // Form state
    const [formData, setFormData] = useState<{
@@ -99,14 +129,18 @@ export function QuestionsPage() {
        target_user_genders: string[];
        required_props: string;
        inverse_of: string;
+        question_type: QuestionType;
+        max_duration_seconds: string;
    }>({
        text: '',
        partner_text: '',
-        intensity: 1,
+        intensity: getDefaultIntensity(),
        allowed_couple_genders: [],
        target_user_genders: [],
        required_props: '',
        inverse_of: '',
+        question_type: 'swipe',
+        max_duration_seconds: String(DEFAULT_AUDIO_DURATION),
    });

    // All questions in pack for inverse_of dropdown (loaded once)
@@ -125,12 +159,18 @@ export function QuestionsPage() {
                .select('id, name, description, icon, is_explicit')
                .eq('id', packId)
                .single();
-            const questionsPromise = supabase
+            let questionsQuery = supabase
                .from('questions')
                .select('*', { count: 'exact' })
                .eq('pack_id', packId)
                .order('created_at', { ascending: true })
                .range(from, to);
+
+            if (questionTypeFilter !== 'all') {
+                questionsQuery = questionsQuery.eq('question_type', questionTypeFilter);
+            }
+
+            const questionsPromise = questionsQuery;
            const allPackPromise = supabase
                .from('questions')
                .select('id, text, inverse_of')
@@ -161,7 +201,7 @@ export function QuestionsPage() {
        } finally {
            setLoading(false);
        }
-    }, [packId, page, pageSize]);
+    }, [packId, page, pageSize, questionTypeFilter]);

    // Real-time subscription for questions in this pack
    const { status: realtimeStatus } = useRealtimeSubscription<Question>({
@@ -202,6 +242,11 @@ export function QuestionsPage() {
        setReviewOpen(false);
    }, [packId]);

+    useEffect(() => {
+        setPage(1);
+        setSelectedIds(new Set());
+    }, [questionTypeFilter]);
+
    useEffect(() => {
        setSelectedIds(new Set());
    }, [page, pageSize]);
@@ -227,11 +272,13 @@ export function QuestionsPage() {
        setFormData({
            text: '',
            partner_text: '',
-            intensity: 1,
+            intensity: getDefaultIntensity(pack?.is_explicit),
            allowed_couple_genders: [],
            target_user_genders: [],
            required_props: '',
            inverse_of: '',
+            question_type: 'swipe',
+            max_duration_seconds: String(DEFAULT_AUDIO_DURATION),
        });
        await fetchAllPackQuestions();
        setDialogOpen(true);
@@ -247,6 +294,8 @@ export function QuestionsPage() {
            target_user_genders: question.target_user_genders || [],
            required_props: question.required_props?.join(', ') ?? '',
            inverse_of: question.inverse_of || '',
+            question_type: question.question_type ?? 'swipe',
+            max_duration_seconds: String(question.config?.max_duration_seconds ?? DEFAULT_AUDIO_DURATION),
        });
        await fetchAllPackQuestions();
        setDialogOpen(true);
@@ -263,6 +312,13 @@ export function QuestionsPage() {
            .map(value => value.trim())
            .filter(Boolean);
        const requiredPropsValue = requiredProps.length > 0 ? requiredProps : null;
+        const parsedMaxDuration = Number(formData.max_duration_seconds);
+        const maxDuration = Number.isFinite(parsedMaxDuration) && parsedMaxDuration > 0
+            ? parsedMaxDuration
+            : DEFAULT_AUDIO_DURATION;
+        const configValue = formData.question_type === 'audio'
+            ? { max_duration_seconds: maxDuration }
+            : null;

        setSaving(true);
        try {
@@ -275,6 +331,8 @@ export function QuestionsPage() {
                    target_user_genders: formData.target_user_genders.length > 0 ? formData.target_user_genders : null,
                    required_props: requiredPropsValue,
                    inverse_of: formData.inverse_of || null,
+                    question_type: formData.question_type,
+                    config: configValue,
                });

                if (error) throw error;
@@ -289,6 +347,8 @@ export function QuestionsPage() {
                    target_user_genders: formData.target_user_genders.length > 0 ? formData.target_user_genders : null,
                    required_props: requiredPropsValue,
                    inverse_of: formData.inverse_of || null,
+                    question_type: formData.question_type,
+                    config: configValue,
                });

                if (error) throw error;
@@ -323,6 +383,9 @@ export function QuestionsPage() {
    };

    const handleAiGenerated = (generatedQuestions: Array<{ text: string; partner_text?: string; intensity: number; inverse_pair_id?: string | null }>) => {
+        const generatedQuestionType: QuestionType = 'swipe';
+        const defaultIntensity = getDefaultIntensity(pack?.is_explicit);
+
        // Bulk insert AI-generated questions with inverse_of linking
        const insertQuestions = async () => {
            try {
@@ -348,8 +411,10 @@ export function QuestionsPage() {
                            pack_id: packId,
                            text: q.text,
                            partner_text: q.partner_text || null,
-                            intensity: q.intensity,
+                            intensity: defaultIntensity,
                            inverse_of: null,
+                            question_type: generatedQuestionType,
+                            config: null,
                        }))
                    );
                    if (standaloneError) throw standaloneError;
@@ -366,8 +431,10 @@ export function QuestionsPage() {
                                pack_id: packId,
                                text: primary.text,
                                partner_text: primary.partner_text || null,
-                                intensity: primary.intensity,
+                                intensity: defaultIntensity,
                                inverse_of: null,
+                                question_type: generatedQuestionType,
+                                config: null,
                            }]
                        );
                        if (primaryError) throw primaryError;
@@ -382,8 +449,10 @@ export function QuestionsPage() {
                                    pack_id: packId,
                                    text: inverse.text,
                                    partner_text: inverse.partner_text || null,
-                                    intensity: inverse.intensity,
+                                    intensity: defaultIntensity,
                                    inverse_of: primaryId,
+                                    question_type: generatedQuestionType,
+                                    config: null,
                                }]
                            );
                            if (inverseError) throw inverseError;
@@ -398,8 +467,10 @@ export function QuestionsPage() {
                                    pack_id: packId,
                                    text: extra.text,
                                    partner_text: extra.partner_text || null,
-                                    intensity: extra.intensity,
+                                    intensity: defaultIntensity,
                                    inverse_of: null,
+                                    question_type: generatedQuestionType,
+                                    config: null,
                                }]
                            );
                            if (extraError) throw extraError;
@@ -412,9 +483,12 @@ export function QuestionsPage() {
                            pack_id: packId,
                            text: pair[0].text,
                            partner_text: pair[0].partner_text || null,
-                                intensity: pair[0].intensity,
+                            intensity: defaultIntensity,
                            inverse_of: null,
+                            question_type: generatedQuestionType,
+                            config: null,
                        }]
+
                        );
                        if (error) throw error;
                    }
@@ -439,7 +513,7 @@ export function QuestionsPage() {
        try {
            const { data, error } = await supabase
                .from('questions')
-                .select('id, pack_id, text, partner_text, intensity, allowed_couple_genders, target_user_genders, required_props, created_at')
+                .select('id, pack_id, text, partner_text, intensity, allowed_couple_genders, target_user_genders, required_props, question_type, created_at')
                .eq('pack_id', packId)
                .order('created_at', { ascending: true });

@@ -525,7 +599,7 @@ export function QuestionsPage() {
                        <h1 className="text-3xl font-bold tracking-tight flex items-center gap-2">
                            {pack && (
                                <>
-                                    <span className="text-3xl">{pack.icon}</span>
+                                    <IconPreview value={pack.icon} fallback="heart-outline" className="text-3xl" />
                                    {pack.name}
                                </>
                            )}
@@ -588,6 +662,45 @@ export function QuestionsPage() {
                                    />
                                </div>

+                                <div className="space-y-2">
+                                    <Label htmlFor="question_type">Question Type</Label>
+                                    <Select
+                                        value={formData.question_type}
+                                        onValueChange={(value) => setFormData(d => ({ ...d, question_type: value as QuestionType }))}
+                                    >
+                                        <SelectTrigger id="question_type">
+                                            <SelectValue placeholder="Select type" />
+                                        </SelectTrigger>
+                                        <SelectContent>
+                                            {QUESTION_TYPE_OPTIONS.map(option => (
+                                                <SelectItem key={option.value} value={option.value}>
+                                                    {option.label}
+                                                </SelectItem>
+                                            ))}
+                                        </SelectContent>
+                                    </Select>
+                                    <p className="text-xs text-muted-foreground">
+                                        Select how users will answer this question in the app.
+                                    </p>
+                                </div>
+
+                                {formData.question_type === 'audio' && (
+                                    <div className="space-y-2">
+                                        <Label htmlFor="max_duration_seconds">Max Duration (seconds)</Label>
+                                        <Input
+                                            id="max_duration_seconds"
+                                            type="number"
+                                            min={1}
+                                            value={formData.max_duration_seconds}
+                                            onChange={(e) => setFormData(d => ({ ...d, max_duration_seconds: e.target.value }))}
+                                            placeholder="60"
+                                        />
+                                        <p className="text-xs text-muted-foreground">
+                                            Audio responses will be limited to this duration.
+                                        </p>
+                                    </div>
+                                )}
+
                                <div className="space-y-2">
                                    <div className="flex items-center justify-between">
                                        <div className="flex items-center gap-2">
@@ -616,25 +729,6 @@ export function QuestionsPage() {
                                    </p>
                                </div>

-                                <div className="space-y-2">
-                                    <Label>Intensity Level</Label>
-                                    <div className="flex gap-2">
-                                        {INTENSITY_LEVELS.map((intensity) => (
-                                            <Button
-                                                key={intensity.level}
-                                                type="button"
-                                                variant={formData.intensity === intensity.level ? 'default' : 'outline'}
-                                                size="sm"
-                                                onClick={() => setFormData(d => ({ ...d, intensity: intensity.level }))}
-                                                className={formData.intensity === intensity.level ? intensity.color : ''}
-                                                title={intensity.description}
-                                            >
-                                                {intensity.level} - {intensity.label}
-                                            </Button>
-                                        ))}
-                                    </div>
-                                </div>
-
                                <div className="space-y-2">
                                    <Label htmlFor="required_props">Required Props (optional)</Label>
                                    <Input
@@ -771,6 +865,26 @@ export function QuestionsPage() {
                </div>
            </div>

+            <div className="flex flex-wrap items-center gap-3">
+                <Label className="text-sm text-muted-foreground">Question Type</Label>
+                <Select
+                    value={questionTypeFilter}
+                    onValueChange={(value) => setQuestionTypeFilter(value as QuestionType | 'all')}
+                >
+                    <SelectTrigger className="w-56">
+                        <SelectValue placeholder="All types" />
+                    </SelectTrigger>
+                    <SelectContent>
+                        <SelectItem value="all">All types</SelectItem>
+                        {QUESTION_TYPE_OPTIONS.map(option => (
+                            <SelectItem key={option.value} value={option.value}>
+                                {option.label}
+                            </SelectItem>
+                        ))}
+                    </SelectContent>
+                </Select>
+            </div>
+
            {/* Bulk Action Bar */}
            {selectedIds.size > 0 && (
                <div className="flex items-center justify-between bg-muted/50 border rounded-lg px-4 py-3">
@@ -885,11 +999,11 @@ export function QuestionsPage() {
                                    </TableHead>
                                    <TableHead className="w-12">#</TableHead>
                                    <TableHead>Question</TableHead>
+                                    <TableHead className="w-28">Type</TableHead>
                                    <TableHead className="w-20">Inverse</TableHead>
                                    <TableHead className="w-32">Partner Text</TableHead>
                                    <TableHead className="w-24">Couples</TableHead>
                                    <TableHead className="w-24">Initiator</TableHead>
-                                    <TableHead className="w-24">Intensity</TableHead>
                                    <TableHead className="w-24">Actions</TableHead>
                                </TableRow>
                            </TableHeader>
@@ -912,6 +1026,18 @@ export function QuestionsPage() {
                                        <TableCell>
                                            <span className="line-clamp-2">{question.text}</span>
                                        </TableCell>
+                                        <TableCell>
+                                            <div className="space-y-1">
+                                                <Badge variant="secondary" className="text-[10px] uppercase tracking-wide">
+                                                    {getQuestionTypeLabel(question.question_type)}
+                                                </Badge>
+                                                {getConfigSummary(question) && (
+                                                    <p className="text-[10px] text-muted-foreground">
+                                                        {getConfigSummary(question)}
+                                                    </p>
+                                                )}
+                                            </div>
+                                        </TableCell>
                                        <TableCell>
                                            {question.inverse_of ? (
                                                <div className="flex items-center gap-2">
@@ -975,14 +1101,6 @@ export function QuestionsPage() {
                                                <span className="text-muted-foreground text-xs">Any</span>
                                            )}
                                        </TableCell>
-                                        <TableCell>
-                                            <Badge
-                                                className={`${getIntensity(question.intensity).color} text-white`}
-                                                title={getIntensity(question.intensity).description}
-                                            >
-                                                {getIntensity(question.intensity).label}
-                                            </Badge>
-                                        </TableCell>
                                        <TableCell>
                                            <div className="flex gap-1">
                                                <Button
@@ -1,7 +1,6 @@
 import { useState, useEffect, useCallback } from 'react';
 import { useParams, Link } from 'react-router-dom';
 import { supabase, supabaseConfig } from '@/config';
-import { auditedSupabase } from '@/hooks/useAuditedSupabase';
 import { useRealtimeSubscription } from '@/hooks/useRealtimeSubscription';
 import { RealtimeStatusIndicator } from '@/components/RealtimeStatusIndicator';
 import { useAuth, PERMISSION_KEYS } from '@/contexts/AuthContext';
@@ -38,14 +37,17 @@ import {
    SelectTrigger,
    SelectValue,
 } from '@/components/ui/select';
-import { Crown, Users, MessageCircle, ChevronRight, ThumbsUp, ThumbsDown, Minus, Gift, Image, Video as VideoIcon, Target, User, Eye, EyeOff, CheckCircle } from 'lucide-react';
+import { Crown, Users, MessageCircle, ChevronRight, ThumbsUp, ThumbsDown, Minus, Gift, Image, Video as VideoIcon, Target, User, Eye, EyeOff, CheckCircle, Package, Heart, Sparkles, Flame, Trophy, Calendar } from 'lucide-react';
 import { format } from 'date-fns';
+import { IconPreview } from '@/components/ui/icon-picker';

 type UsageReason = 'improve_communication' | 'spice_up_intimacy' | 'deeper_connection' | 'have_fun' | 'strengthen_relationship';
 type Gender = 'male' | 'female' | 'non-binary' | 'prefer-not-to-say';

 // ... (interfaces and constants are the same)

+type IntensityLevel = 1 | 2 | 3 | 4 | 5;
+
 interface Profile {
    id: string;
    name: string | null;
@@ -58,6 +60,7 @@ interface Profile {
    usage_reason: UsageReason | null;
    show_explicit_content: boolean | null;
    onboarding_completed: boolean | null;
+    max_intensity: IntensityLevel | null;
 }

 const usageReasonLabels: Record<UsageReason, { label: string; icon: string }> = {
@@ -75,6 +78,14 @@ const genderLabels: Record<Gender, string> = {
    'prefer-not-to-say': 'Prefer not to say',
 };

+const intensityLabels: Record<IntensityLevel, { label: string; emoji: string }> = {
+    1: { label: 'Gentle', emoji: '💭' },
+    2: { label: 'Warm', emoji: '💕' },
+    3: { label: 'Playful', emoji: '😏' },
+    4: { label: 'Steamy', emoji: '🔥' },
+    5: { label: 'Intense', emoji: '🌶️' },
+};
+
 interface Partner {
    id: string;
    name: string | null;
@@ -88,6 +99,7 @@ interface Response {
        id: string;
        text: string;
        pack: {
+            id: string;
            name: string;
        };
    };
@@ -105,6 +117,41 @@ interface Match {
    message_count?: number;
 }

+interface EnabledPack {
+    pack_id: string;
+    enabled: boolean;
+    created_at: string | null;
+    pack: {
+        id: string;
+        name: string;
+        description: string | null;
+        icon: string | null;
+        is_premium: boolean;
+        is_explicit: boolean;
+        category: {
+            id: string;
+            name: string;
+        } | null;
+    };
+}
+
+interface FeatureInterest {
+    id: string;
+    feature_name: string;
+    created_at: string;
+}
+
+interface CoupleStreak {
+    id: string;
+    couple_id: string;
+    current_streak: number;
+    longest_streak: number;
+    last_active_date: string | null;
+    last_milestone_celebrated: number | null;
+    created_at: string;
+    updated_at: string;
+}
+
 const answerIcons = {
    yes: <ThumbsUp className="h-4 w-4 text-green-500" />,
    no: <ThumbsDown className="h-4 w-4 text-red-500" />,
@@ -238,6 +285,9 @@ export function UserDetailPage() {
    const [responses, setResponses] = useState<Response[]>([]);
    const [matches, setMatches] = useState<Match[]>([]);
    const [mediaMessages, setMediaMessages] = useState<any[]>([]);
+    const [enabledPacks, setEnabledPacks] = useState<EnabledPack[]>([]);
+    const [featureInterests, setFeatureInterests] = useState<FeatureInterest[]>([]);
+    const [streak, setStreak] = useState<CoupleStreak | null>(null);
    const [responsesPage, setResponsesPage] = useState(1);
    const [responsesPageSize, setResponsesPageSize] = useState(10);
    const [responsesTotal, setResponsesTotal] = useState(0);
@@ -282,17 +332,13 @@ export function UserDetailPage() {
                }
                expiresAt = date.toISOString();
            }
-            const { error } = await auditedSupabase.insert('subscriptions', {
-                user_id: userId,
-                revenuecat_app_user_id: 'admin_grant',
-                product_id: 'admin_premium',
-                status: 'active',
-                store: 'manual',
-                purchased_at: new Date().toISOString(),
-                expires_at: expiresAt,
+            // Use RPC function which handles permissions internally
+            const { error } = await supabase.rpc('admin_gift_premium', {
+                target_user_id: userId,
+                expires_at_param: expiresAt,
            });
            if (error) throw error;
-            const { data: updatedProfile } = await supabase.from('profiles').select('*').eq('id', userId).single();
+            const { data: updatedProfile } = await supabase.rpc('get_profile_with_auth_info', { user_id: userId }).single<Profile>();
            if (updatedProfile) setProfile(updatedProfile);
            setUpgradeOpen(false);
            alert('User upgraded to premium successfully!');
@@ -308,14 +354,31 @@ export function UserDetailPage() {
        if (!userId) return;
        setLoading(true);
        try {
-            const { data: profileData } = await supabase.from('profiles').select('*').eq('id', userId).single();
+            const { data: profileData } = await supabase.rpc('get_profile_with_auth_info', { user_id: userId }).single<Profile>();
            setProfile(profileData);

+            // Fetch feature interests for the user
+            const { data: featureInterestsData } = await supabase
+                .from('feature_interests')
+                .select('id, feature_name, created_at')
+                .eq('user_id', userId)
+                .order('created_at', { ascending: false });
+            setFeatureInterests((featureInterestsData || []) as FeatureInterest[]);
+
            if (profileData?.couple_id) {
                const { data: partnerData } = await supabase.from('profiles').select('id, name').eq('couple_id', profileData.couple_id).neq('id', userId).single();
                setPartner(partnerData);
+
+                // Fetch streak data
+                const { data: streakData } = await supabase
+                    .from('couple_streaks')
+                    .select('*')
+                    .eq('couple_id', profileData.couple_id)
+                    .maybeSingle();
+                setStreak(streakData);
            } else {
                setPartner(null);
+                setStreak(null);
            }

            const responsesFrom = (responsesPage - 1) * responsesPageSize;
@@ -323,7 +386,7 @@ export function UserDetailPage() {

            const { data: responseData, count: responsesCount, error: responsesError } = await supabase
                .from('responses')
-                .select('id, answer, created_at, question:questions(id, text, pack:question_packs(name))', { count: 'exact' })
+                .select('id, answer, created_at, question:questions(id, text, pack:question_packs(id, name))', { count: 'exact' })
                .eq('user_id', userId)
                .order('created_at', { ascending: false })
                .range(responsesFrom, responsesTo);
@@ -388,11 +451,39 @@ export function UserDetailPage() {
                    setMediaMessages([]);
                    setMediaTotal(0);
                }
+            // Fetch enabled packs for the couple
+                const { data: enabledPacksData, error: packsError } = await supabase
+                    .from('couple_packs')
+                    .select(`
+                        pack_id,
+                        enabled,
+                        created_at,
+                        pack:question_packs(
+                            id,
+                            name,
+                            description,
+                            icon,
+                            is_premium,
+                            is_explicit,
+                            category:categories(id, name)
+                        )
+                    `)
+                    .eq('couple_id', profileData.couple_id)
+                    .eq('enabled', true)
+                    .order('created_at', { ascending: false });
+
+                if (packsError) {
+                    console.error("Error fetching enabled packs:", packsError);
+                    setEnabledPacks([]);
+                } else {
+                    setEnabledPacks((enabledPacksData || []) as unknown as EnabledPack[]);
+                }
            } else {
                setMatches([]);
                setMatchesTotal(0);
                setMediaMessages([]);
                setMediaTotal(0);
+                setEnabledPacks([]);
            }
        } catch (error) {
            console.error('Failed to load user data:', error);
@@ -446,30 +537,117 @@ export function UserDetailPage() {
                        <h1 className="text-2xl font-bold">{profile.name || 'Unnamed User'}</h1>
                        <RealtimeStatusIndicator status={profileStatus === 'SUBSCRIBED' && responsesStatus === 'SUBSCRIBED' ? 'SUBSCRIBED' : profileStatus} showLabel />
                        {profile.is_premium && <Badge className="bg-amber-500"><Crown className="h-3 w-3 mr-1" />Premium</Badge>}
-                        {!profile.is_premium && <Dialog open={upgradeOpen} onOpenChange={setUpgradeOpen}><DialogTrigger asChild><Button size="sm" variant="outline" className="ml-2 gap-1 h-7"><Gift className="h-3.5 w-3.5" />Gift Premium</Button></DialogTrigger><DialogContent><DialogHeader><DialogTitle>Gift Premium Access</DialogTitle><DialogDescription>Manually upgrade this user to premium status.</DialogDescription></DialogHeader><div className="grid gap-4 py-4"><div className="grid gap-2"><Label htmlFor="expiry-type">Duration</Label><Select value={expiryType} onValueChange={setExpiryType}><SelectTrigger id="expiry-type"><SelectValue placeholder="Select duration" /></SelectTrigger><SelectContent><SelectItem value="forever">Lifetime (No Expiry)</SelectItem><SelectItem value="1_month">1 Month</SelectItem><SelectItem value="1_year">1 Year</SelectItem><SelectItem value="custom">Custom Date</SelectItem></SelectContent></Select></div>{expiryType === 'custom' && (<div className="grid gap-2"><Label htmlFor="custom-date">Expiry Date</Label><Input id="custom-date" type="datetime-local" value={customDate} onChange={(e) => setCustomDate(e.target.value)} /></div>)}</div><DialogFooter><Button variant="outline" onClick={() => setUpgradeOpen(false)}>Cancel</Button><Button onClick={handleUpgrade} disabled={upgrading}>{upgrading ? 'Upgrading...' : 'Confirm Upgrade'}</Button></DialogFooter></DialogContent></Dialog>}
+                        {!profile.is_premium && hasPermission(PERMISSION_KEYS.GIFT_PREMIUM) && <Dialog open={upgradeOpen} onOpenChange={setUpgradeOpen}><DialogTrigger asChild><Button size="sm" variant="outline" className="ml-2 gap-1 h-7"><Gift className="h-3.5 w-3.5" />Gift Premium</Button></DialogTrigger><DialogContent><DialogHeader><DialogTitle>Gift Premium Access</DialogTitle><DialogDescription>Manually upgrade this user to premium status.</DialogDescription></DialogHeader><div className="grid gap-4 py-4"><div className="grid gap-2"><Label htmlFor="expiry-type">Duration</Label><Select value={expiryType} onValueChange={setExpiryType}><SelectTrigger id="expiry-type"><SelectValue placeholder="Select duration" /></SelectTrigger><SelectContent><SelectItem value="forever">Lifetime (No Expiry)</SelectItem><SelectItem value="1_month">1 Month</SelectItem><SelectItem value="1_year">1 Year</SelectItem><SelectItem value="custom">Custom Date</SelectItem></SelectContent></Select></div>{expiryType === 'custom' && (<div className="grid gap-2"><Label htmlFor="custom-date">Expiry Date</Label><Input id="custom-date" type="datetime-local" value={customDate} onChange={(e) => setCustomDate(e.target.value)} /></div>)}</div><DialogFooter><Button variant="outline" onClick={() => setUpgradeOpen(false)}>Cancel</Button><Button onClick={handleUpgrade} disabled={upgrading}>{upgrading ? 'Upgrading...' : 'Confirm Upgrade'}</Button></DialogFooter></DialogContent></Dialog>}
+                    </div>
+                    <div className="text-muted-foreground mb-4 flex items-center gap-2">
+                        {profile.email ? (
+                            <span>{profile.email}</span>
+                        ) : (
+                            <Badge variant="secondary" className="bg-slate-100 text-slate-500 hover:bg-slate-200">Guest</Badge>
+                        )}
+                        {!profile.email && (
+                            <span className="text-xs">Not recoverable unless saved in-app</span>
+                        )}
                    </div>
-                    <p className="text-muted-foreground mb-4">{profile.email || 'No email'}</p>
                    <div className="flex gap-6 text-sm">
                        <div><span className="text-muted-foreground">Joined: </span><span>{profile.created_at ? format(new Date(profile.created_at), 'MMMM d, yyyy') : '—'}</span></div>
-                        {partner ? <div className="flex items-center gap-1"><Users className="h-4 w-4 text-muted-foreground" /><span className="text-muted-foreground">Paired with: </span><Link to={`/users/${partner.id}`} className="text-primary hover:underline">{partner.name || 'Unnamed Partner'}</Link></div> : <div className="text-muted-foreground">Not paired</div>}
+                        {partner ? <div className="flex items-center gap-1"><Users className="h-4 w-4 text-muted-foreground" /><span className="text-muted-foreground">Paired with: </span><Link to={`/users/${partner.id}`} className="text-primary hover:underline">{partner.name || 'Unnamed Partner'}</Link></div> : profile.couple_id ? <div className="text-amber-600 dark:text-amber-400 flex items-center gap-1"><Users className="h-4 w-4" />Waiting for partner</div> : <div className="text-muted-foreground">Not paired</div>}
                    </div>
                </div>
            </div></CardContent></Card>
            {/* Onboarding Details */}
-            <Card><CardHeader className="pb-3"><CardTitle className="text-lg flex items-center gap-2"><CheckCircle className="h-5 w-5 text-primary" />Onboarding Details</CardTitle><CardDescription>Information collected during user onboarding</CardDescription></CardHeader><CardContent><div className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
+            <Card><CardHeader className="pb-3"><CardTitle className="text-lg flex items-center gap-2"><CheckCircle className="h-5 w-5 text-primary" />Onboarding Details</CardTitle><CardDescription>Information collected during user onboarding</CardDescription></CardHeader><CardContent><div className="grid gap-4 md:grid-cols-2 lg:grid-cols-5">
                <div className="flex items-start gap-3"><div className="p-2 rounded-lg bg-blue-100 dark:bg-blue-900"><User className="h-4 w-4 text-blue-600 dark:text-blue-400" /></div><div><p className="text-sm font-medium text-muted-foreground">Gender</p><p className="font-medium">{profile.gender ? genderLabels[profile.gender] : 'Not set'}</p></div></div>
                <div className="flex items-start gap-3"><div className="p-2 rounded-lg bg-purple-100 dark:bg-purple-900"><Target className="h-4 w-4 text-purple-600 dark:text-purple-400" /></div><div><p className="text-sm font-medium text-muted-foreground">Why using Sauci</p><p className="font-medium">{profile.usage_reason ? usageReasonLabels[profile.usage_reason]?.label : 'Not set'}</p></div></div>
+                <div className="flex items-start gap-3"><div className="p-2 rounded-lg bg-pink-100 dark:bg-pink-900"><Heart className="h-4 w-4 text-pink-600 dark:text-pink-400" /></div><div><p className="text-sm font-medium text-muted-foreground">Comfort Zone</p><p className="font-medium">{profile.max_intensity ? `${intensityLabels[profile.max_intensity].emoji} ${intensityLabels[profile.max_intensity].label} (${profile.max_intensity})` : 'Not set'}</p></div></div>
                <div className="flex items-start gap-3"><div className={`p-2 rounded-lg ${profile.show_explicit_content ? 'bg-amber-100 dark:bg-amber-900' : 'bg-gray-100 dark:bg-gray-800'}`}>{profile.show_explicit_content ? <Eye className="h-4 w-4 text-amber-600 dark:text-amber-400" /> : <EyeOff className="h-4 w-4 text-gray-500 dark:text-gray-400" />}</div><div><p className="text-sm font-medium text-muted-foreground">Explicit Content</p><p className="font-medium">{profile.show_explicit_content === null ? 'Not set' : profile.show_explicit_content ? 'Enabled' : 'Disabled'}</p></div></div>
                <div className="flex items-start gap-3"><div className={`p-2 rounded-lg ${profile.onboarding_completed ? 'bg-green-100 dark:bg-green-900' : 'bg-red-100 dark:bg-red-900'}`}><CheckCircle className={`h-4 w-4 ${profile.onboarding_completed ? 'text-green-600 dark:text-green-400' : 'text-red-500 dark:text-red-400'}`} /></div><div><p className="text-sm font-medium text-muted-foreground">Onboarding</p><p className="font-medium">{profile.onboarding_completed ? 'Completed' : 'Not completed'}</p></div></div>
            </div></CardContent></Card>
+            {/* Streak Info */}
+            {profile.couple_id && streak && (
+                <Card>
+                    <CardHeader className="pb-3">
+                        <CardTitle className="text-lg flex items-center gap-2">
+                            <Flame className="h-5 w-5 text-orange-500" />
+                            Couple Streak
+                        </CardTitle>
+                        <CardDescription>Activity streak for this couple</CardDescription>
+                    </CardHeader>
+                    <CardContent>
+                        <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
+                            <div className="flex items-start gap-3">
+                                <div className="p-2 rounded-lg bg-orange-100 dark:bg-orange-900">
+                                    <Flame className="h-4 w-4 text-orange-600 dark:text-orange-400" />
+                                </div>
+                                <div>
+                                    <p className="text-sm font-medium text-muted-foreground">Current Streak</p>
+                                    <p className="font-medium text-xl">{streak.current_streak} day{streak.current_streak !== 1 ? 's' : ''}</p>
+                                </div>
+                            </div>
+                            <div className="flex items-start gap-3">
+                                <div className="p-2 rounded-lg bg-yellow-100 dark:bg-yellow-900">
+                                    <Trophy className="h-4 w-4 text-yellow-600 dark:text-yellow-400" />
+                                </div>
+                                <div>
+                                    <p className="text-sm font-medium text-muted-foreground">Longest Streak</p>
+                                    <p className="font-medium text-xl">{streak.longest_streak} day{streak.longest_streak !== 1 ? 's' : ''}</p>
+                                </div>
+                            </div>
+                            <div className="flex items-start gap-3">
+                                <div className="p-2 rounded-lg bg-blue-100 dark:bg-blue-900">
+                                    <Calendar className="h-4 w-4 text-blue-600 dark:text-blue-400" />
+                                </div>
+                                <div>
+                                    <p className="text-sm font-medium text-muted-foreground">Last Active</p>
+                                    <p className="font-medium">{streak.last_active_date ? format(new Date(streak.last_active_date), 'MMM d, yyyy') : 'Never'}</p>
+                                </div>
+                            </div>
+                            <div className="flex items-start gap-3">
+                                <div className="p-2 rounded-lg bg-purple-100 dark:bg-purple-900">
+                                    <Sparkles className="h-4 w-4 text-purple-600 dark:text-purple-400" />
+                                </div>
+                                <div>
+                                    <p className="text-sm font-medium text-muted-foreground">Last Milestone</p>
+                                    <p className="font-medium">{streak.last_milestone_celebrated ? `${streak.last_milestone_celebrated} days` : 'None yet'}</p>
+                                </div>
+                            </div>
+                        </div>
+                    </CardContent>
+                </Card>
+            )}
+            {/* Feature Opt-Ins */}
+            {featureInterests.length > 0 && (
+                <Card>
+                    <CardHeader className="pb-3">
+                        <CardTitle className="text-lg flex items-center gap-2">
+                            <Sparkles className="h-5 w-5 text-primary" />
+                            Feature Opt-Ins
+                        </CardTitle>
+                        <CardDescription>Features the user has expressed interest in</CardDescription>
+                    </CardHeader>
+                    <CardContent>
+                        <div className="flex flex-wrap gap-2">
+                            {featureInterests.map((interest) => (
+                                <Badge key={interest.id} variant="secondary" className="capitalize">
+                                    {interest.feature_name}
+                                    <span className="ml-1 text-xs text-muted-foreground">
+                                        ({format(new Date(interest.created_at), 'MMM d')})
+                                    </span>
+                                </Badge>
+                            ))}
+                        </div>
+                    </CardContent>
+                </Card>
+            )}
            {/* Tabs */}
            <Tabs defaultValue={canViewResponses ? "responses" : canViewMatches ? "matches" : canViewMedia ? "media" : "responses"}>
                <TabsList>
                    {canViewResponses && <TabsTrigger value="responses">Responses ({responsesTotal})</TabsTrigger>}
                    {canViewMatches && <TabsTrigger value="matches" disabled={!profile.couple_id}>Matches ({matchesTotal})</TabsTrigger>}
                    {canViewMedia && <TabsTrigger value="media">Media ({mediaTotal})</TabsTrigger>}
+                    <TabsTrigger value="packs" disabled={!profile.couple_id}>Enabled Packs ({enabledPacks.length})</TabsTrigger>
                </TabsList>
-                {canViewResponses && <TabsContent value="responses" className="mt-4">{responses.length === 0 ? <Card className="flex flex-col items-center justify-center py-12"><p className="text-muted-foreground">No responses yet</p></Card> : <div className="space-y-4"><div className="rounded-md border"><Table><TableHeader><TableRow><TableHead>Question</TableHead><TableHead>Pack</TableHead><TableHead className="w-24">Answer</TableHead><TableHead className="w-32">Date</TableHead></TableRow></TableHeader><TableBody>{responses.map((r) => (<TableRow key={r.id}><TableCell className="max-w-md"><span className="line-clamp-2">{r.question.text}</span></TableCell><TableCell className="text-muted-foreground">{r.question.pack?.name || '—'}</TableCell><TableCell><div className="flex items-center gap-2">{answerIcons[r.answer]}<span className="capitalize">{r.answer}</span></div></TableCell><TableCell className="text-muted-foreground text-sm">{r.created_at ? format(new Date(r.created_at), 'MMM d, yyyy') : '—'}</TableCell></TableRow>))}</TableBody></Table></div><PaginationControls page={responsesPage} pageSize={responsesPageSize} totalCount={responsesTotal} onPageChange={setResponsesPage} onPageSizeChange={(size) => { setResponsesPage(1); setResponsesPageSize(size); }} /></div>}</TabsContent>}
+                {canViewResponses && <TabsContent value="responses" className="mt-4">{responses.length === 0 ? <Card className="flex flex-col items-center justify-center py-12"><p className="text-muted-foreground">No responses yet</p></Card> : <div className="space-y-4"><div className="rounded-md border"><Table><TableHeader><TableRow><TableHead>Question</TableHead><TableHead>Pack</TableHead><TableHead className="w-24">Answer</TableHead><TableHead className="w-32">Date</TableHead></TableRow></TableHeader><TableBody>{responses.map((r) => (<TableRow key={r.id}><TableCell className="max-w-md">{r.question.pack?.id ? (<Link to={`/packs/${r.question.pack.id}/questions`} className="line-clamp-2 text-primary hover:underline cursor-pointer">{r.question.text}</Link>) : (<span className="line-clamp-2">{r.question.text}</span>)}</TableCell><TableCell>{r.question.pack?.id ? (<Link to={`/packs/${r.question.pack.id}/questions`} className="text-primary hover:underline">{r.question.pack.name}</Link>) : (<span className="text-muted-foreground">{r.question.pack?.name || '—'}</span>)}</TableCell><TableCell><div className="flex items-center gap-2">{answerIcons[r.answer]}<span className="capitalize">{r.answer}</span></div></TableCell><TableCell className="text-muted-foreground text-sm">{r.created_at ? format(new Date(r.created_at), 'MMM d, yyyy') : '—'}</TableCell></TableRow>))}</TableBody></Table></div><PaginationControls page={responsesPage} pageSize={responsesPageSize} totalCount={responsesTotal} onPageChange={setResponsesPage} onPageSizeChange={(size) => { setResponsesPage(1); setResponsesPageSize(size); }} /></div>}</TabsContent>}
                {canViewMatches && <TabsContent value="matches" className="mt-4">{matches.length === 0 ? <Card className="flex flex-col items-center justify-center py-12"><p className="text-muted-foreground">No matches yet</p></Card> : <div className="space-y-4"><div className="grid gap-4 md:grid-cols-2">{matches.map((match) => (<Card key={match.id} className="hover:shadow-md transition-shadow"><CardHeader className="pb-2"><div className="flex items-start justify-between"><Badge variant="secondary">{matchTypeLabels[match.match_type]}</Badge>{match.is_new && <Badge variant="default" className="text-xs">New</Badge>}</div><CardDescription className="line-clamp-2 mt-2">{match.question?.text || 'Unknown question'}</CardDescription></CardHeader><CardContent><div className="flex items-center justify-between"><div className="flex items-center gap-1 text-sm text-muted-foreground"><MessageCircle className="h-4 w-4" />{match.message_count} message{match.message_count !== 1 ? 's' : ''}</div>{canViewChats && <Link to={`/users/${userId}/matches/${match.id}`}><Button variant="ghost" size="sm">View Chat<ChevronRight className="ml-1 h-4 w-4" /></Button></Link>}</div></CardContent></Card>))}</div><PaginationControls page={matchesPage} pageSize={matchesPageSize} totalCount={matchesTotal} onPageChange={setMatchesPage} onPageSizeChange={(size) => { setMatchesPage(1); setMatchesPageSize(size); }} /></div>}</TabsContent>}
                {canViewMedia && <TabsContent value="media" className="mt-4">{mediaMessages.length === 0 ? <Card className="flex flex-col items-center justify-center py-12"><Image className="h-12 w-12 text-muted-foreground mb-4" /><p className="text-muted-foreground">No media uploaded</p></Card> : <div className="space-y-4"><div className="grid gap-4 grid-cols-2 md:grid-cols-3 lg:grid-cols-4">{mediaMessages.map((message) => (<Card key={message.id} className="overflow-hidden"><div className="aspect-square bg-muted relative">
                    {message.media_type === 'video' ? (
@@ -478,6 +656,59 @@ export function UserDetailPage() {
                        <AdminDecryptedImage messageId={message.id} alt={`Media from ${message.created_at}`} />
                    )}
                </div><CardContent className="p-3"><div className="flex items-center justify-between text-sm"><div className="truncate text-muted-foreground">{message.media_type === 'video' ? 'Video' : 'Image'}</div>{canViewChats && message.match_id && <Link to={`/users/${userId}/matches/${message.match_id}`} className="text-primary hover:underline text-xs">View Chat</Link>}</div><div className="text-xs text-muted-foreground mt-1">{message.created_at ? format(new Date(message.created_at), 'MMM d, yyyy') : '—'}</div></CardContent></Card>))}</div><PaginationControls page={mediaPage} pageSize={mediaPageSize} totalCount={mediaTotal} onPageChange={setMediaPage} onPageSizeChange={(size) => { setMediaPage(1); setMediaPageSize(size); }} /></div>}</TabsContent>}
+                <TabsContent value="packs" className="mt-4">
+                    {enabledPacks.length === 0 ? (
+                        <Card className="flex flex-col items-center justify-center py-12">
+                            <Package className="h-12 w-12 text-muted-foreground mb-4" />
+                            <p className="text-muted-foreground">No packs enabled</p>
+                        </Card>
+                    ) : (
+                        <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
+                            {enabledPacks.map((ep) => (
+                                <Link key={ep.pack_id} to={`/packs/${ep.pack.id}/questions`}>
+                                    <Card className="hover:shadow-md transition-shadow cursor-pointer">
+                                        <CardHeader className="pb-2">
+                                            <div className="flex items-start justify-between">
+                                                <div className="flex items-center gap-2">
+                                                    <IconPreview value={ep.pack.icon} fallback="heart-outline" className="text-2xl" />
+                                                    <CardTitle className="text-base">{ep.pack.name}</CardTitle>
+                                                </div>
+                                                <div className="flex gap-1">
+                                                    {ep.pack.is_premium && (
+                                                        <Badge className="bg-amber-500 text-xs">
+                                                            <Crown className="h-3 w-3 mr-1" />
+                                                            Premium
+                                                        </Badge>
+                                                    )}
+                                                    {ep.pack.is_explicit && (
+                                                        <Badge variant="destructive" className="text-xs">
+                                                            18+
+                                                        </Badge>
+                                                    )}
+                                                </div>
+                                            </div>
+                                            {ep.pack.description && (
+                                                <CardDescription className="line-clamp-2 mt-2">
+                                                    {ep.pack.description}
+                                                </CardDescription>
+                                            )}
+                                        </CardHeader>
+                                        <CardContent>
+                                            <div className="flex items-center justify-between text-sm">
+                                                <span className="text-muted-foreground">
+                                                    {ep.pack.category?.name || 'Uncategorized'}
+                                                </span>
+                                                <span className="text-muted-foreground text-xs">
+                                                    Enabled {ep.created_at ? format(new Date(ep.created_at), 'MMM d, yyyy') : '—'}
+                                                </span>
+                                            </div>
+                                        </CardContent>
+                                    </Card>
+                                </Link>
+                            ))}
+                        </div>
+                    )}
+                </TabsContent>
            </Tabs>
        </div>
    );
@@ -17,7 +17,7 @@ import {
    TableHeader,
    TableRow,
 } from '@/components/ui/table';
-import { Search, Crown, Users, ChevronRight, HardDrive, MailWarning } from 'lucide-react';
+import { Search, Crown, Users, ChevronRight, HardDrive, MailWarning, Hourglass } from 'lucide-react';
 import { format } from 'date-fns';

 interface Profile {
@@ -32,6 +32,7 @@ interface Profile {
    email_confirmed_at: string | null;
    storage_bytes?: number;
    partner_is_premium?: boolean;
+    partner_count?: number;
 }

 function formatBytes(bytes: number): string {
@@ -87,11 +88,13 @@ export function UsersPage() {
                }
            });

-            // Merge storage data and partner premium status with profiles
+            // Merge storage data, partner premium status, and partner count with profiles
            const profilesWithExtras = profilesData.map(profile => {
-                // Check if partner has premium
+                // Check if partner has premium and count partners in couple
                let partnerIsPremium = false;
+                let partnerCount = 0;
                if (profile.couple_id && couplePartners[profile.couple_id]) {
+                    partnerCount = couplePartners[profile.couple_id].length;
                    const partner = couplePartners[profile.couple_id].find(p => p.id !== profile.id);
                    partnerIsPremium = partner?.is_premium || false;
                }
@@ -99,6 +102,7 @@ export function UsersPage() {
                    ...profile,
                    storage_bytes: storageMap[profile.id] || 0,
                    partner_is_premium: partnerIsPremium,
+                    partner_count: partnerCount,
                };
            });

@@ -128,7 +132,10 @@ export function UsersPage() {
        }, []),
            insertToast: {
            enabled: true,
-            message: (payload) => `New user registered: ${payload.name || payload.email || 'Unknown'}`,
+            message: (payload) => {
+                const label = payload.name || payload.email || 'Guest';
+                return payload.email ? `New user registered: ${label}` : `New guest user: ${label}`;
+            },
            type: 'success',
        },
        debounceMs: 1000, // Debounce to avoid excessive refetches
@@ -191,7 +198,15 @@ export function UsersPage() {
                        <RealtimeStatusIndicator status={realtimeStatus} showLabel />
                    </div>
                    <p className="text-muted-foreground text-sm">
-                        {profiles.length} registered user{profiles.length !== 1 ? 's' : ''}
+                        {profiles.length} account{profiles.length !== 1 ? 's' : ''}
+                        {(() => {
+                            const guestCount = profiles.filter(p => !p.email).length;
+                            const savedCount = profiles.length - guestCount;
+                            if (guestCount === 0) return null;
+                            return (
+                                <span> • {savedCount} saved • {guestCount} guest</span>
+                            );
+                        })()}
                    </p>
                </div>
                <div className="relative w-full sm:w-64">
@@ -245,12 +260,20 @@ export function UsersPage() {
                                    </TableCell>
                                    <TableCell className="text-muted-foreground">
                                        <div className="flex items-center gap-1.5">
-                                            {profile.email || '—'}
-                                            {profile.email && !profile.email_confirmed_at && (
+                                            {profile.email ? (
+                                                <>
+                                                    {profile.email}
+                                                    {!profile.email_confirmed_at && (
                                                        <span title="Email not verified">
                                                            <MailWarning className="h-3.5 w-3.5 text-amber-500" />
                                                        </span>
                                                    )}
+                                                </>
+                                            ) : (
+                                                <Badge variant="secondary" className="bg-slate-100 text-slate-500 hover:bg-slate-200">
+                                                    Guest
+                                                </Badge>
+                                            )}
                                        </div>
                                    </TableCell>
                                    <TableCell>
@@ -272,10 +295,17 @@ export function UsersPage() {
                                    </TableCell>
                                    <TableCell>
                                        {profile.couple_id ? (
-                                            <Badge variant="secondary">
+                                            profile.partner_count && profile.partner_count >= 2 ? (
+                                                <Badge variant="secondary" className="bg-green-100 text-green-700 hover:bg-green-200">
                                                    <Users className="h-3 w-3 mr-1" />
                                                    Paired
                                                </Badge>
+                                            ) : (
+                                                <Badge variant="secondary" className="bg-amber-100 text-amber-700 hover:bg-amber-200">
+                                                    <Hourglass className="h-3 w-3 mr-1" />
+                                                    Pairing
+                                                </Badge>
+                                            )
                                        ) : (
                                            <span className="text-muted-foreground text-sm">—</span>
                                        )}
@@ -9,6 +9,18 @@ export default defineConfig({
            '@': path.resolve(__dirname, './src'),
        },
    },
+    optimizeDeps: {
+        include: ['react-icons/io5'],
+    },
+    build: {
+        rollupOptions: {
+            output: {
+                manualChunks: {
+                    'react-icons': ['react-icons/io5'],
+                },
+            },
+        },
+    },
    server: {
        host: true,
        port: 3001,
@@ -0,0 +1,39 @@
+---
+name: web-design-guidelines
+description: Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".
+metadata:
+  author: vercel
+  version: "1.0.0"
+  argument-hint: <file-or-pattern>
+---
+
+# Web Interface Guidelines
+
+Review files for compliance with Web Interface Guidelines.
+
+## How It Works
+
+1. Fetch the latest guidelines from the source URL below
+2. Read the specified files (or prompt user for files/pattern)
+3. Check against all rules in the fetched guidelines
+4. Output findings in the terse `file:line` format
+
+## Guidelines Source
+
+Fetch fresh guidelines before each review:
+
+```
+https://raw.githubusercontent.com/vercel-labs/web-interface-guidelines/main/command.md
+```
+
+Use WebFetch to retrieve the latest rules. The fetched content contains all the rules and output format instructions.
+
+## Usage
+
+When a user provides a file or pattern argument:
+1. Fetch guidelines from the source URL above
+2. Read the specified files
+3. Apply all rules from the fetched guidelines
+4. Output findings using the format specified in the guidelines
+
+If no files specified, ask the user which files to review.
@@ -0,0 +1,39 @@
+---
+name: web-design-guidelines
+description: Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".
+metadata:
+  author: vercel
+  version: "1.0.0"
+  argument-hint: <file-or-pattern>
+---
+
+# Web Interface Guidelines
+
+Review files for compliance with Web Interface Guidelines.
+
+## How It Works
+
+1. Fetch the latest guidelines from the source URL below
+2. Read the specified files (or prompt user for files/pattern)
+3. Check against all rules in the fetched guidelines
+4. Output findings in the terse `file:line` format
+
+## Guidelines Source
+
+Fetch fresh guidelines before each review:
+
+```
+https://raw.githubusercontent.com/vercel-labs/web-interface-guidelines/main/command.md
+```
+
+Use WebFetch to retrieve the latest rules. The fetched content contains all the rules and output format instructions.
+
+## Usage
+
+When a user provides a file or pattern argument:
+1. Fetch guidelines from the source URL above
+2. Read the specified files
+3. Apply all rules from the fetched guidelines
+4. Output findings using the format specified in the guidelines
+
+If no files specified, ask the user which files to review.
@@ -0,0 +1,5 @@
+// https://docs.expo.dev/guides/using-eslint/
+module.exports = {
+  extends: 'expo',
+  ignorePatterns: ['/dist/*'],
+};
@@ -0,0 +1,39 @@
+---
+name: web-design-guidelines
+description: Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".
+metadata:
+  author: vercel
+  version: "1.0.0"
+  argument-hint: <file-or-pattern>
+---
+
+# Web Interface Guidelines
+
+Review files for compliance with Web Interface Guidelines.
+
+## How It Works
+
+1. Fetch the latest guidelines from the source URL below
+2. Read the specified files (or prompt user for files/pattern)
+3. Check against all rules in the fetched guidelines
+4. Output findings in the terse `file:line` format
+
+## Guidelines Source
+
+Fetch fresh guidelines before each review:
+
+```
+https://raw.githubusercontent.com/vercel-labs/web-interface-guidelines/main/command.md
+```
+
+Use WebFetch to retrieve the latest rules. The fetched content contains all the rules and output format instructions.
+
+## Usage
+
+When a user provides a file or pattern argument:
+1. Fetch guidelines from the source URL above
+2. Read the specified files
+3. Apply all rules from the fetched guidelines
+4. Output findings using the format specified in the guidelines
+
+If no files specified, ask the user which files to review.
@@ -6,3 +6,6 @@ expo-env.d.ts
 # @end expo-cli
 *.aab
 *.ipa
+*.apk
+*.jks
+*.keystore
@@ -1,20 +1,20 @@
 # Sauci Design System

-A boutique, premium design framework for the Sauci couples intimacy app.
+A boutique, premium design framework for the Sauci couples relationship app.

 ## Brand Identity

-**Aesthetic:** Boutique lingerie store meets modern dating app. Think Ann Summers sophistication - sensual but tasteful, premium but accessible, intimate but playful.
+**Aesthetic:** Premium couples app with a warm, sophisticated feel. Think modern wellness meets connection - supportive but not clinical, premium but accessible, personal but playful.

-**Mood:** Romantic, luxurious, warm, inviting, confident
+**Mood:** Warm, supportive, confident, inviting, growth-oriented

 **Key Principles:**

- Glass-morphism for depth and elegance
- Dark backgrounds with warm accents
+- Dark, velvety backgrounds with subtle gradient atmosphere
+- Solid, high-contrast surfaces (no glass or blur effects)
 - Primary gradient (rose → purple) as the core brand signature
 - Gold reserved for premium/dares features only
- Gradients for visual interest and brand recognition
+- Soft glows and shadows for depth, not transparency

 ---

@@ -26,12 +26,12 @@ The core brand identity. Used for primary actions, key UI elements, and brand re

 | Name | Hex | RGB | Usage |
 |------|-----|-----|-------|
-| **Primary** | `#e94560` | 233, 69, 96 | Primary buttons, active states, key accents |
-| **Primary Dark** | `#c73a52` | 199, 58, 82 | Pressed states, darker variants |
+| **Primary** | `#e1306c` | 225, 48, 108 | Primary buttons, active states, key accents |
+| **Primary Dark** | `#c12055` | 193, 32, 85 | Pressed states, darker variants |
 | **Secondary** | `#9b59b6` | 155, 89, 182 | Secondary accents, gradient endpoints |
 | **Secondary Dark** | `#8e44ad` | 142, 68, 173 | Pressed states, darker variants |

-**Primary Gradient:** `#e94560 → #9b59b6` (Rose to Purple)
+**Primary Gradient:** `#e1306c → #9b59b6` (Rose to Purple)
 - Direction: Left to right (horizontal) or top to bottom (vertical)
 - Use for: Primary buttons, match celebrations, brand moments

@@ -53,10 +53,10 @@ Each core feature has a designated accent color for consistency and recognition.

 | Feature | Primary Color | Hex | Gradient |
 |---------|---------------|-----|----------|
-| **Swipe/Match** | Primary | `#e94560` | Primary gradient (rose → purple) |
+| **Swipe/Match** | Primary | `#e1306c` | Primary gradient (rose → purple) |
 | **Quiz** | Rose | `#E8A4AE` | `#E8A4AE → #D4919B` |
 | **Dares** | Gold | `#D4AF37` | `#D4AF37 → #B8860B` |
-| **Chat** | Primary | `#e94560` | Primary gradient |
+| **Chat** | Primary | `#e1306c` | Primary gradient |
 | **Profile** | Secondary | `#9b59b6` | Secondary gradient |

 **Usage Rules:**
@@ -71,22 +71,31 @@ Dark, rich backgrounds that make content pop.

 | Name | Hex | RGBA | Usage |
 |------|-----|------|-------|
-| **Background** | `#0d0d1a` | 13, 13, 26 | Primary app background |
-| **Background Light** | `#1a1a2e` | 26, 26, 46 | Cards, elevated surfaces |
-| **Surface** | — | `rgba(22, 33, 62, 0.6)` | Glass overlays |
-| **Surface Solid** | `#16213e` | 22, 33, 62 | Non-transparent surfaces |
+| **Background** | `#0e0e11` | 14, 14, 17 | Primary app background |
+| **Background Light** | `#17171c` | 23, 23, 28 | Cards, elevated surfaces |
+| **Surface** | `#17171c` | 23, 23, 28 | Primary surface color |
+| **Surface Solid** | `#17171c` | 23, 23, 28 | Opaque surfaces |
+| **Border** | `#303036` | 48, 48, 54 | Dividers, outlines, input borders |

-### 5. Glass/Surface Colors
+### 5. Tile/Category Colors (Home Screen)

-For the glass-morphism effect that defines the UI.
+Discovery/Home tiles use vibrant, solid colors for quick recognition.

-| Name | RGBA | Usage |
-|------|------|-------|
-| **Glass Background** | `rgba(22, 33, 62, 0.4)` | Standard glass cards |
-| **Glass Background Heavy** | `rgba(22, 33, 62, 0.6)` | Emphasized glass cards |
-| **Glass Border** | `rgba(255, 255, 255, 0.08)` | Subtle borders |
-| **Glass Border Light** | `rgba(255, 255, 255, 0.12)` | Prominent borders |
-| **Glass Highlight** | `rgba(255, 255, 255, 0.05)` | Top edge shine |
+| Token | Hex |
+|-------|-----|
+| **teal** | `#14B8A6` |
+| **purple** | `#8B5CF6` |
+| **orange** | `#F97316` |
+| **coral** | `#F87171` |
+| **emerald** | `#10B981` |
+| **indigo** | `#6366F1` |
+| **rose** | `#EC4899` |
+| **amber** | `#F59E0B` |
+
+**Usage Rules:**
+- Tiles are solid fills with a subtle dark overlay for depth
+- Category colors are consistent across the app
+- Avoid gradients on tiles unless it is a premium moment

 ### 6. Text Colors

@@ -127,9 +136,9 @@ Consistent across all swipe interactions:
 ### Brand Gradients

 ```
-Primary:         #e94560 → #9b59b6  (Rose to Purple)
-Primary Subtle:  rgba(233, 69, 96, 0.8) → rgba(155, 89, 182, 0.8)
-Primary Reverse: #9b59b6 → #e94560  (Purple to Rose)
+Primary:         #e1306c → #9b59b6  (Rose to Purple)
+Primary Subtle:  rgba(225, 48, 108, 0.8) → rgba(155, 89, 182, 0.8)
+Primary Reverse: #9b59b6 → #e1306c  (Purple to Rose)
 ```

 ### Premium Gradients
@@ -142,8 +151,8 @@ Premium Rose:  #E8A4AE → #D4919B
 ### Background Gradients

 ```
-Background:         #1a1a2e → #0d0d1a  (Light to Dark)
-Background Reverse: #0d0d1a → #1a1a2e  (Dark to Light)
+Background:         #0e0e11 → #1f1417 → #0e0e11
+Background Reverse: #0e0e11 → #1f1417 → #0e0e11
 ```

 ### Boutique Card Gradients
@@ -168,7 +177,7 @@ Boutique Amethyst: rgba(142, 68, 173, 0.4) → rgba(44, 62, 80, 0.4)
 | Variant | Background | Text | Border |
 |---------|------------|------|--------|
 | **Primary** | Primary gradient | White | None |
-| **Secondary** | Glass background | White | Glass border |
+| **Secondary** | Surface | White | Border |
 | **Ghost** | Transparent | Primary | None |
 | **Danger** | Error gradient | White | None |
 | **Feature** | Feature color gradient | White | None |
@@ -177,18 +186,18 @@ Boutique Amethyst: rgba(142, 68, 173, 0.4) → rgba(44, 62, 80, 0.4)

 | Variant | Background | Border | Use Case |
 |---------|------------|--------|----------|
-| **Glass** | Glass background | Glass border | Standard content |
-| **Glass Elevated** | Glass background heavy | Glass border light | Emphasized content |
-| **Solid** | Background light | Glass border | Non-blur contexts |
+| **Solid** | Surface | Border | Standard content |
+| **Raised** | Surface | Border | Emphasized content + shadow |
+| **Tinted** | Category color | None | Home tiles, feature promos |

 ### Inputs

 | State | Border Color | Background |
 |-------|--------------|------------|
-| **Default** | Glass border | Glass background |
-| **Focused** | Primary | Glass background |
-| **Error** | Error | Glass background |
-| **Disabled** | Glass border | Glass background (opacity 0.5) |
+| **Default** | Border | Surface |
+| **Focused** | Primary | Surface |
+| **Error** | Error | Surface |
+| **Disabled** | Border | Surface (opacity 0.6) |

 ---

@@ -196,9 +205,9 @@ Boutique Amethyst: rgba(142, 68, 173, 0.4) → rgba(44, 62, 80, 0.4)

 | Element | Color |
 |---------|-------|
-| **Background** | `rgba(13, 13, 26, 0.92)` with blur |
-| **Top Border** | `rgba(233, 69, 96, 0.2)` (primary tint) |
-| **Active Icon** | Primary `#e94560` |
+| **Background** | `#0e0e11` |
+| **Top Border** | `rgba(225, 48, 108, 0.2)` (primary tint) |
+| **Active Icon** | Primary `#e1306c` |
 | **Inactive Icon** | Text secondary |
 | **Badge** | Rose `#E8A4AE` |

@@ -208,10 +217,10 @@ The main "play" button uses the primary brand gradient for maximum brand presenc

 | Element | Color |
 |---------|-------|
-| **Glow** | Primary glow `rgba(233, 69, 96, 0.3)` |
-| **Border** | `rgba(233, 69, 96, 0.4)` |
+| **Glow** | Primary glow `rgba(225, 48, 108, 0.3)` |
+| **Border** | `rgba(225, 48, 108, 0.4)` |
 | **Highlight** | Primary → Secondary gradient |
-| **Icon** | Primary `#e94560` |
+| **Icon** | Primary `#e1306c` |

 ## Radial Menu

@@ -219,9 +228,9 @@ Feature-specific colors for quick action items:

 | Item | Variant | Color |
 |------|---------|-------|
-| **Match** | Primary | `#e94560` (core feature) |
+| **Match** | Primary | `#e1306c` (core feature) |
 | **Dares** | Gold | `#D4AF37` (premium/adventure) |
-| **Quiz** | Rose | `#E8A4AE` (intimacy) |
+| **Quiz** | Rose | `#E8A4AE` (connection) |

 ---

@@ -231,7 +240,7 @@ Feature-specific colors for quick action items:

 | Feature | Icon Name | Ionicons | Description |
 |---------|-----------|----------|-------------|
-| **Swipe/Match** | `flame` | 🔥 | Fire/passion - the core swiping experience |
+| **Swipe/Match** | `flame` | 🔥 | Fire/energy - the core swiping experience |
 | **Dares** | `flash` | ⚡ | Lightning bolt - adventure, excitement, energy |
 | **Quiz** | `help-circle` | ❓ | Question mark - discovery, questions about each other |
 | **Matches** (tab) | `heart` | ❤️ | Love heart - connections made between partners |
@@ -278,17 +287,17 @@ Feature-specific colors for quick action items:

 | Style | Size | Weight | Line Height | Usage |
 |-------|------|--------|-------------|-------|
-| `largeTitle` | 34px | Bold | 41px | Screen titles |
+| `largeTitle` | 32px | Bold | 40px | Screen titles |
 | `title1` | 28px | Bold | 34px | Section headers |
-| `title2` | 22px | Bold | 28px | Card titles |
-| `title3` | 20px | SemiBold | 25px | Subsection headers |
+| `title2` | 24px | Bold | 30px | Card titles |
+| `title3` | 20px | SemiBold | 26px | Subsection headers |
 | `headline` | 17px | SemiBold | 22px | Emphasized body |
-| `body` | 17px | Regular | 22px | Body text |
-| `callout` | 16px | Regular | 21px | Secondary body |
-| `subhead` | 15px | Regular | 20px | Supporting text |
+| `body` | 16px | Regular | 22px | Body text |
+| `callout` | 15px | Regular | 20px | Secondary body |
+| `subhead` | 14px | Regular | 20px | Supporting text |
 | `footnote` | 13px | Regular | 18px | Captions |
 | `caption1` | 12px | Regular | 16px | Small labels |
-| `caption2` | 11px | Regular | 13px | Tiny text |
+| `caption2` | 11px | Regular | 14px | Tiny text |

 ---

@@ -308,14 +317,14 @@ Feature-specific colors for quick action items:
 ## Platform Considerations

 ### iOS
- Use BlurView for glass effects
+- Favor solid surfaces and shadows for depth
 - Haptic feedback on interactions
 - Native-feeling animations

 ### Android
- Fallback to solid semi-transparent backgrounds
- Reduced blur intensity for performance
- Adjusted shadow rendering
+- Match iOS surface colors and shadows
+- Avoid blur and heavy transparency for performance
+- Adjust shadow rendering as needed

 ---

@@ -324,7 +333,7 @@ Feature-specific colors for quick action items:
 ### Do
 - Use the primary gradient for main CTAs
 - Apply feature colors consistently within a feature
- Use glass effects for depth and hierarchy
+- Use solid surfaces with soft shadows for depth
 - Keep text high-contrast (white on dark)
 - Use gold/rose for premium moments

@@ -332,8 +341,8 @@ Feature-specific colors for quick action items:
 - Mix feature colors within a single screen
 - Use more than 2-3 accent colors per screen
 - Apply the primary gradient to everything
+- Use glass, blur, or frosted effects
 - Use pure black (#000000) for backgrounds
- Forget to include the glow effect on premium elements

 ---

@@ -17,7 +17,7 @@
 	<key>IS_ADS_ENABLED</key>
 	<false></false>
 	<key>IS_ANALYTICS_ENABLED</key>
-	<false></false>
+	<true></true>
 	<key>IS_APPINVITE_ENABLED</key>
 	<true></true>
 	<key>IS_GCM_ENABLED</key>
@@ -8,8 +8,8 @@ This is an Expo React Native app using:
 - **Routing**: expo-router with file-based routing in `app/` directory
 - **State**: Zustand stores in `src/store/index.ts`
 - **Backend**: Supabase client in `src/lib/supabase.ts`
- **UI**: Glass-morphism themed components in `src/components/ui/`
- **Theme**: Centralized theme in `src/theme/index.ts`
+
+Design guidance lives in `apps/mobile/DESIGN.md`.

 ## Directory Structure

@@ -19,27 +19,18 @@ app/                    # Expo Router routes
  (app)/                # Protected app screens (tabs)
 src/
  components/           # Reusable components
-    ui/                 # Base UI components (GlassCard, GlassButton, etc.)
+    ui/
  lib/                  # Utilities (supabase, analytics, revenuecat)
  store/                # Zustand stores (index.ts)
-  theme/                # Theme constants (colors, gradients, spacing, etc.)
+  theme/
  types/                # TypeScript types
 ```

 ## Critical Rules

-### Tab Bar - NEVER CHANGE
+### File Size

-**NEVER set `backgroundColor: 'transparent'` on the tab bar.**
-
-Always use:
-```typescript
-backgroundColor: 'rgba(18, 18, 18, 0.85)',
-```
-
-The BlurView in `tabBarBackground` is unreliable. The solid rgba background acts as a fallback.
-
-Location: `app/(app)/_layout.tsx` - `tabBarStyle`
+- Keep files small: aim for 200-300 lines max per file.

 ### State Management

@@ -53,24 +44,6 @@ Location: `app/(app)/_layout.tsx` - `tabBarStyle`
 - `.single()` throws an error if 0 or >1 rows are returned
 - Check for null before performing operations

-### UI Components
-
-Use existing UI primitives from `src/components/ui/`:
- `GlassCard` - Glass-morphism card container
- `GlassButton` - Glass-styled button
- `GlassInput` - Glass-styled input field
- `GradientBackground` - Screen background gradient
- `ShimmerEffect` - Loading shimmer animation
-
-### Theme Usage
-
-Import from `src/theme/index.ts`:
-```typescript
-import { colors, gradients, spacing, radius, typography, shadows } from '@/theme';
-```
-
-**DO NOT hardcode colors**. Always use theme values.
-
 ### Response Handling

 - Responses use UPSERT with `onConflict: "user_id,question_id"`
@@ -94,9 +67,7 @@ import { colors, gradients, spacing, radius, typography, shadows } from '@/theme

 ## Forbidden Actions

-1. **DO NOT** change tab bar background to transparent
-2. **DO NOT** use `.single()` for queries that might return 0 rows
-3. **DO NOT** hardcode colors - use theme values
-4. **DO NOT** create new stores without integrating with auth sign-out cleanup
-5. **DO NOT** bypass RevenueCat availability checks
-6. **DO NOT** add navigation logic outside of expo-router
+1. **DO NOT** use `.single()` for queries that might return 0 rows
+2. **DO NOT** create new stores without integrating with auth sign-out cleanup
+3. **DO NOT** bypass RevenueCat availability checks
+4. **DO NOT** add navigation logic outside of expo-router
@@ -93,8 +93,8 @@ android {
        applicationId 'com.sauci.app'
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 21
-        versionName "1.0.0"
+        versionCode 34
+        versionName "1.0.2"
    }
    signingConfigs {
        debug {
@@ -13,6 +13,14 @@
        }
      },
      "oauth_client": [
+        {
+          "client_id": "764866133492-03k7q0mq6nqrv0phunncqjn85cgj6sep.apps.googleusercontent.com",
+          "client_type": 1,
+          "android_info": {
+            "package_name": "com.sauci.app",
+            "certificate_hash": "f06026c754b046f280feac438a6910bd9a62b459"
+          }
+        },
        {
          "client_id": "764866133492-4g566mrb8tm5uti4ejub6oogcvnln7kc.apps.googleusercontent.com",
          "client_type": 1,
@@ -12,3 +12,7 @@
 -keep class com.facebook.react.turbomodule.** { *; }

 # Add any project specific keep options here:
+
+# @generated begin expo-build-properties - expo prebuild (DO NOT MODIFY)
+-keep class com.facebook.hermes.unicode.** { *; }
+# @generated end expo-build-properties
@@ -18,7 +18,7 @@ buildscript {
        classpath 'com.google.gms:google-services:4.4.1'
        classpath('com.android.tools.build:gradle')
        classpath('com.facebook.react:react-native-gradle-plugin')
-        classpath('org.jetbrains.kotlin:kotlin-gradle-plugin')
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
    }
 }

@@ -56,4 +56,5 @@ EX_DEV_CLIENT_NETWORK_INSPECTOR=true
 expo.useLegacyPackaging=false

 android.targetSdkVersion=35
+android.kotlinVersion=1.9.25
 android.extraMavenRepos=[]
@@ -2,7 +2,7 @@
  "expo": {
    "name": "Sauci",
    "slug": "sauci",
-    "version": "1.0.0",
+    "version": "1.0.2",
    "orientation": "portrait",
    "icon": "./assets/icon.png",
    "scheme": "app.sauci",
@@ -16,8 +16,9 @@
    "ios": {
      "supportsTablet": false,
      "bundleIdentifier": "com.sauci.app",
-      "buildNumber": "25",
+      "buildNumber": "31",
      "usesAppleSignIn": true,
+      "googleServicesFile": "./GoogleService-Info.plist",
      "infoPlist": {
        "UIBackgroundModes": [
          "remote-notification"
@@ -176,7 +177,7 @@
        "backgroundColor": "#1a1a2e"
      },
      "package": "com.sauci.app",
-      "versionCode": 21,
+      "versionCode": 34,
      "googleServicesFile": "./google-services.json",
      "permissions": [
        "RECEIVE_BOOT_COMPLETED",
@@ -192,11 +193,21 @@
      "favicon": "./assets/favicon.png"
    },
    "plugins": [
+      "@react-native-firebase/app",
      [
        "expo-build-properties",
        {
          "android": {
-            "targetSdkVersion": 35
+            "targetSdkVersion": 35,
+            "kotlinVersion": "1.9.25",
+            "extraProguardRules": "-keep class com.facebook.hermes.unicode.** { *; }",
+            "useLegacyPackaging": false,
+            "manifestPlaceholders": {
+              "firebaseAnalyticsWithoutAdId": "true"
+            }
+          },
+          "ios": {
+            "useFrameworks": "static"
          }
        }
      ],
@@ -231,7 +242,8 @@
        {
          "iosUrlScheme": "com.googleusercontent.apps.861972684340-0u2as8i5equfhmhmvjihottkf0ig7237"
        }
-      ]
+      ],
+      "./plugins/withKotlinVersion.js"
    ],
    "experiments": {
      "typedRoutes": true
@@ -1,18 +1,18 @@
 import { Tabs, useRouter, useSegments } from "expo-router";
 import { Ionicons } from "@expo/vector-icons";
-import { View, ActivityIndicator, StyleSheet, Platform, Text, Pressable, Animated, AppState, AppStateStatus } from "react-native";
+import { View, ActivityIndicator, StyleSheet, Platform, Text, Pressable, Animated, AppState } from "react-native";
 import { BlurView } from "expo-blur";
-import { LinearGradient } from "expo-linear-gradient";
 import { useEffect, useState, useCallback, useRef } from "react";
-import { useAuthStore, useMatchStore, useMessageStore, useSubscriptionStore, usePacksStore } from "../../src/store";
-import { colors, gradients, blur, radius, spacing, typography, shadows } from "../../src/theme";
+import { useAuthStore, useMatchStore, useMessageStore, useSubscriptionStore, usePacksStore, useStreakStore } from "../../src/store";
+import { colors, radius, spacing, typography, shadows } from "../../src/theme";
 import { supabase } from "../../src/lib/supabase";
 import { isBiometricEnabled } from "../../src/lib/biometricAuth";
 import { checkAndRegisterPushToken } from "../../src/lib/notifications";
+import { syncBadgeCount } from "../../src/lib/badge";
 import { BiometricLockScreen } from "../../src/components/BiometricLockScreen";
-import { MatchNotificationModal, MatchNotificationData } from "../../src/components/MatchNotificationModal";
 import { Events } from "../../src/lib/analytics";
-import type { MatchWithQuestion, AnswerType } from "../../src/types";
+import { needsOnboarding } from "../../src/constants/onboarding";
+import type { MatchWithQuestion } from "../../src/types";
 import type { Database } from "../../src/types/supabase";

 type Message = Database["public"]["Tables"]["messages"]["Row"];
@@ -43,178 +43,47 @@ function TabBarBackground() {
    // The solid rgba background in tabBarStyle provides the visual effect on Android
    if (Platform.OS === 'ios') {
        return (
+            <>
                <BlurView
-                intensity={100}
+                    intensity={80}
                    tint="dark"
                    style={StyleSheet.absoluteFill}
                />
+                <View style={[StyleSheet.absoluteFill, { backgroundColor: 'rgba(14, 14, 17, 0.85)' }]} />
+            </>
        );
    }
    return null;
 }

-interface PlayTabButtonProps {
-    children?: React.ReactNode;
-    onPress?: (e: any) => void;
-    accessibilityState?: { selected?: boolean };
-    isMenuOpen?: boolean;
-    onToggleMenu?: () => void;
-}
-
-interface RadialMenuItem {
-    id: string;
-    icon: keyof typeof Ionicons.glyphMap;
-    label: string;
-    angle: number; // degrees from top (0 = top, -45 = left, 45 = right)
-    variant: 'primary' | 'gold' | 'rose' | 'muted';
-}
-
-// Brand color palette for navigation
-const NAV_COLORS = {
-    // Primary brand colors (from logo)
-    primary: colors.primary,
-    primaryRgba: 'rgba(233, 69, 96, ',
-    secondary: colors.secondary,
-    secondaryRgba: 'rgba(155, 89, 182, ',
-    // Feature-specific colors
-    gold: colors.premium.gold,
-    goldRgba: 'rgba(212, 175, 55, ',
-    rose: colors.premium.rose,
-    roseRgba: 'rgba(232, 164, 174, ',
-    dark: '#0d0d1a',
-};
-
-const RADIAL_MENU_ITEMS: RadialMenuItem[] = [
-    { id: 'dares', icon: 'flash', label: 'Dares', angle: -50, variant: 'gold' },
-    { id: 'match', icon: 'flame', label: 'Match', angle: 0, variant: 'primary' },
-    { id: 'quiz', icon: 'help-circle', label: 'Quiz', angle: 50, variant: 'rose' },
-];
-
-const RADIAL_DISTANCE = 100; // Distance from center button
-
-// Store for sharing state between PlayTabButton and AppLayout
-let globalMenuToggle: (() => void) | null = null;
-let globalMenuOpen = false;
-
-function PlayTabButton({ accessibilityState }: PlayTabButtonProps) {
-    const isSelected = accessibilityState?.selected;
-    const [, forceUpdate] = useState({});
-
-    // Subscribe to global state changes
-    useEffect(() => {
-        const interval = setInterval(() => {
-            forceUpdate({});
-        }, 50);
-        return () => clearInterval(interval);
-    }, []);
-
-    return (
-        <View style={styles.playButtonContainer}>
-            {/* Outer glow effect - primary brand */}
-            <View style={[styles.playButtonGlow, isSelected && styles.playButtonGlowActive]} />
-
-            {/* Main circle button - premium dark with primary gradient border */}
-            <Pressable onPress={() => globalMenuToggle?.()}>
-                <Animated.View style={styles.playButtonCircle}>
-                    <View style={styles.playButtonInner}>
-                        {/* Silk highlight at top - primary gradient */}
-                        <LinearGradient
-                            colors={[`${NAV_COLORS.primaryRgba}0.2)`, `${NAV_COLORS.secondaryRgba}0.1)`, 'transparent']}
-                            style={styles.playButtonHighlight}
-                            start={{ x: 0, y: 0 }}
-                            end={{ x: 1, y: 1 }}
-                        />
-                        <Ionicons
-                            name={globalMenuOpen ? "close" : "flame"}
-                            size={28}
-                            color={globalMenuOpen ? colors.textSecondary : NAV_COLORS.primary}
-                        />
-                    </View>
-                </Animated.View>
-            </Pressable>
-        </View>
-    );
-}
-
 export default function AppLayout() {
    const router = useRouter();
    const segments = useSegments();
-    const { isAuthenticated, isLoading, user, signOut } = useAuthStore();
-    const { matches, newMatchesCount, addMatch, updateMatchUnreadCount } = useMatchStore();
+    const { isAuthenticated, isLoading, user, signOut, updateLastActive } = useAuthStore();
+    const { matches, newMatchesCount, addMatch, updateMatchUnreadCount, pendingQuestions, fetchPendingQuestions } = useMatchStore();
    const { unreadCount, lastMessage, fetchUnreadCount, addMessage, clearLastMessage } = useMessageStore();
    const { fetchEnabledPacks } = usePacksStore();
    const { initializeRevenueCat } = useSubscriptionStore();
-    const [matchNotification, setMatchNotification] = useState<MatchNotificationData | null>(null);
+    const { fetchStreak } = useStreakStore();
    const messageToastAnim = useRef(new Animated.Value(-100)).current;
    const messageTimeoutRef = useRef<NodeJS.Timeout | null>(null);
    const [isLocked, setIsLocked] = useState(false);
    const hasCheckedInitialBiometric = useRef(false);
    const wentToBackgroundAt = useRef<number | null>(null);

-    // Radial menu state
-    const [isRadialMenuOpen, setIsRadialMenuOpen] = useState(false);
-    const radialMenuAnim = useRef(new Animated.Value(0)).current;
-
-    const toggleRadialMenu = useCallback(() => {
-        const toValue = isRadialMenuOpen ? 0 : 1;
-        setIsRadialMenuOpen(!isRadialMenuOpen);
-        globalMenuOpen = !isRadialMenuOpen;
-
-        Animated.spring(radialMenuAnim, {
-            toValue,
-            useNativeDriver: true,
-            tension: 100,
-            friction: 8,
-        }).start();
-    }, [isRadialMenuOpen, radialMenuAnim]);
-
-    const closeRadialMenu = useCallback(() => {
-        setIsRadialMenuOpen(false);
-        globalMenuOpen = false;
-        Animated.timing(radialMenuAnim, {
-            toValue: 0,
-            duration: 150,
-            useNativeDriver: true,
-        }).start();
-    }, [radialMenuAnim]);
-
-    const handleRadialMenuItemPress = useCallback((itemId: string) => {
-        closeRadialMenu();
-
-        // Navigate based on item
-        switch (itemId) {
-            case 'match':
-                router.push('/(app)/swipe');
-                break;
-            case 'dares':
-                router.push('/(app)/dares');
-                break;
-            case 'quiz':
-                router.push('/(app)/quiz');
-                break;
-        }
-    }, [router, closeRadialMenu]);
-
-    // Register global menu toggle for PlayTabButton
-    useEffect(() => {
-        globalMenuToggle = toggleRadialMenu;
-        return () => {
-            globalMenuToggle = null;
-        };
-    }, [toggleRadialMenu]);
-
    // Check if we're on screens that should hide the tab bar
    const segmentStrings = segments as string[];
    const isOnOnboarding = segmentStrings.includes("onboarding");
    const isOnPairing = segmentStrings.includes("pairing");
    const isOnChat = segmentStrings.includes("chat");
-    const shouldHideTabBar = isOnOnboarding || isOnPairing || isOnChat;
+    const isOnSettingsSubscreen = segmentStrings.includes("settings") && segmentStrings.length > 2;
+    const shouldHideTabBar = isOnOnboarding || isOnPairing || isOnChat || isOnSettingsSubscreen;

-    // Redirect to login when not authenticated, or to onboarding if not completed
+    // Redirect to login when not authenticated, or to onboarding if not completed/outdated
    useEffect(() => {
        if (!isLoading && !isAuthenticated) {
            router.replace("/(auth)/login");
-        } else if (!isLoading && isAuthenticated && user && !user.onboarding_completed && !isOnOnboarding) {
+        } else if (!isLoading && isAuthenticated && user && needsOnboarding(user.onboarding_completed, user.onboarding_version) && !isOnOnboarding) {
            router.replace("/(app)/onboarding");
        }
    }, [isLoading, isAuthenticated, user, router, isOnOnboarding]);
@@ -232,17 +101,22 @@ export default function AppLayout() {
        // Check immediately
        checkSession();

+        // Update last active timestamp on mount
+        updateLastActive();
+
        // Check when app comes to foreground
        const subscription = AppState.addEventListener('change', (nextAppState) => {
            if (nextAppState === 'active') {
                checkSession();
+                // Update last active timestamp when app comes to foreground
+                updateLastActive();
            }
        });

        return () => {
            subscription.remove();
        };
-    }, [signOut]);
+    }, [signOut, updateLastActive]);

    // Handle biometric lock when app goes to background/foreground
    useEffect(() => {
@@ -301,6 +175,25 @@ export default function AppLayout() {
        }
    }, [user?.id, fetchUnreadCount]);

+    // Fetch streak data when user is in a couple
+    useEffect(() => {
+        if (user?.couple_id) {
+            fetchStreak();
+        }
+    }, [user?.couple_id, fetchStreak]);
+
+    // Fetch pending questions (Your Turn) when user is in a couple
+    useEffect(() => {
+        if (user?.couple_id) {
+            fetchPendingQuestions();
+        }
+    }, [user?.couple_id, fetchPendingQuestions]);
+
+    // Sync app icon badge count whenever matches, messages, or pending questions change
+    useEffect(() => {
+        syncBadgeCount(newMatchesCount + pendingQuestions.length, unreadCount);
+    }, [newMatchesCount, unreadCount, pendingQuestions.length]);
+
    // Initialize RevenueCat for subscription management (iOS and Android only)
    useEffect(() => {
        if (user?.id && Platform.OS !== "web") {
@@ -347,7 +240,7 @@ export default function AppLayout() {
        };
    }, [user?.id, user?.couple_id]);

-    // Subscribe to realtime match notifications
+    // Subscribe to realtime match notifications (for badge updates and analytics)
    useEffect(() => {
        if (!user?.couple_id) return;

@@ -372,7 +265,7 @@ export default function AppLayout() {
                        .eq("id", payload.new.id)
                        .single();

-                    if (matchWithQuestion) {
+                    if (matchWithQuestion && matchWithQuestion.question) {
                        // Track milestone events before adding (so count is accurate)
                        const currentMatchCount = matches.length;
                        if (currentMatchCount === 0) {
@@ -381,42 +274,12 @@ export default function AppLayout() {
                            Events.milestoneMatch(currentMatchCount + 1);
                        }

-                        // Add to store
+                        // Add to store (updates badge count via newMatchesCount)
                        addMatch(matchWithQuestion);
                        Events.matchCreated(matchWithQuestion.match_type || "unknown");

-                        // Fetch individual responses to show what each person said
-                        const { data: responses } = await supabase
-                            .from("responses")
-                            .select("user_id, answer")
-                            .eq("question_id", matchWithQuestion.question_id)
-                            .eq("couple_id", user.couple_id);
-
-                        let userResponse: AnswerType | undefined;
-                        let partnerResponse: AnswerType | undefined;
-
-                        if (responses && responses.length >= 2) {
-                            for (const r of responses) {
-                                if (r.user_id === user.id) {
-                                    userResponse = r.answer as AnswerType;
-                                } else {
-                                    partnerResponse = r.answer as AnswerType;
-                                }
-                            }
-                        }
-
-                        // Get partner name from auth store
-                        const { partner } = useAuthStore.getState();
-
-                        // Show notification with response data
-                        setMatchNotification({
-                            id: matchWithQuestion.id,
-                            match_type: matchWithQuestion.match_type,
-                            question: matchWithQuestion.question,
-                            userResponse,
-                            partnerResponse,
-                            partnerName: partner?.name,
-                        });
+                        // Note: No modal popup - user will see badge on matches tab
+                        // Confetti animation is shown inline on swipe screen when user creates match
                    }
                }
            )
@@ -541,18 +404,6 @@ export default function AppLayout() {
        };
    }, [lastMessage]);

-    const dismissNotification = useCallback(() => {
-        setMatchNotification(null);
-    }, []);
-
-    const handleMatchChat = useCallback(() => {
-        if (matchNotification) {
-            const matchId = matchNotification.id;
-            setMatchNotification(null);
-            router.push(`/(app)/chat/${matchId}`);
-        }
-    }, [matchNotification, router]);
-
    const dismissMessageToast = useCallback(() => {
        Animated.timing(messageToastAnim, {
            toValue: -100,
@@ -571,7 +422,7 @@ export default function AppLayout() {
    }, [lastMessage, dismissMessageToast, router]);

    // Show loading state while checking authentication or redirecting to onboarding
-    if (isLoading || !isAuthenticated || (user && !user.onboarding_completed && !isOnOnboarding)) {
+    if (isLoading || !isAuthenticated || (user && needsOnboarding(user.onboarding_completed, user.onboarding_version) && !isOnOnboarding)) {
        return (
            <View style={styles.loadingContainer}>
                <ActivityIndicator size="large" color={colors.primary} />
@@ -587,7 +438,7 @@ export default function AppLayout() {
                    tabBarBackground: () => <TabBarBackground />,
                    tabBarStyle: shouldHideTabBar ? { display: 'none' } : {
                        position: 'absolute',
-                        backgroundColor: 'rgba(13, 13, 26, 0.92)',
+                        backgroundColor: 'rgba(14, 14, 17, 0.85)',
                        borderTopColor: 'rgba(233, 69, 96, 0.2)', // primary brand color
                        borderTopWidth: 1,
                        paddingTop: 8,
@@ -613,20 +464,10 @@ export default function AppLayout() {
                        ),
                    }}
                />
-                <Tabs.Screen
-                    name="packs"
-                    options={{
-                        title: "Packs",
-                        tabBarIcon: ({ color, size }) => (
-                            <Ionicons name="layers" size={size} color={color} />
-                        ),
-                    }}
-                />
                <Tabs.Screen
                    name="swipe"
                    options={{
-                        title: "",
-                        tabBarButton: (props) => <PlayTabButton {...props} />,
+                        href: null, // Hide from tab bar - accessed from home screen
                    }}
                />
                <Tabs.Screen
@@ -636,7 +477,7 @@ export default function AppLayout() {
                        tabBarIcon: ({ color, size }) => (
                            <Ionicons name="heart" size={size} color={color} />
                        ),
-                        tabBarBadge: (newMatchesCount + unreadCount) > 0 ? (newMatchesCount + unreadCount) : undefined,
+                        tabBarBadge: (newMatchesCount + unreadCount + pendingQuestions.length) > 0 ? (newMatchesCount + unreadCount + pendingQuestions.length) : undefined,
                        tabBarBadgeStyle: {
                            backgroundColor: colors.premium.rose,
                            fontSize: 9,
@@ -692,130 +533,14 @@ export default function AppLayout() {
                        href: null, // Hide from tab bar
                    }}
                />
+                <Tabs.Screen
+                    name="settings"
+                    options={{
+                        href: null, // Hide from tab bar
+                    }}
+                />
            </Tabs>

-            {/* Radial Menu Overlay */}
-            {isRadialMenuOpen && (
-                <Pressable
-                    style={radialStyles.overlay}
-                    onPress={closeRadialMenu}
-                />
-            )}
-
-            {/* Radial Menu Items - positioned above the center button */}
-            <Animated.View
-                style={[
-                    radialStyles.menuContainer,
-                    { opacity: radialMenuAnim },
-                ]}
-                pointerEvents={isRadialMenuOpen ? 'auto' : 'none'}
-            >
-                {RADIAL_MENU_ITEMS.map((item) => {
-                    // Convert angle to radians and calculate position
-                    const angleRad = (item.angle - 90) * (Math.PI / 180); // -90 to make 0 = top
-                    const translateX = Math.cos(angleRad) * RADIAL_DISTANCE;
-                    const translateY = Math.sin(angleRad) * RADIAL_DISTANCE;
-
-                    const itemScale = radialMenuAnim.interpolate({
-                        inputRange: [0, 1],
-                        outputRange: [0.3, 1],
-                    });
-
-                    const itemTranslateX = radialMenuAnim.interpolate({
-                        inputRange: [0, 1],
-                        outputRange: [0, translateX],
-                    });
-
-                    const itemTranslateY = radialMenuAnim.interpolate({
-                        inputRange: [0, 1],
-                        outputRange: [0, translateY],
-                    });
-
-                    // Brand and feature variant colors
-                    const getVariantStyles = () => {
-                        switch (item.variant) {
-                            case 'primary':
-                                return {
-                                    bg: `${NAV_COLORS.primaryRgba}0.15)`,
-                                    border: `${NAV_COLORS.primaryRgba}0.35)`,
-                                    icon: NAV_COLORS.primary,
-                                    label: NAV_COLORS.primary,
-                                };
-                            case 'gold':
-                                return {
-                                    bg: `${NAV_COLORS.goldRgba}0.15)`,
-                                    border: `${NAV_COLORS.goldRgba}0.35)`,
-                                    icon: NAV_COLORS.gold,
-                                    label: NAV_COLORS.gold,
-                                };
-                            case 'rose':
-                                return {
-                                    bg: `${NAV_COLORS.roseRgba}0.15)`,
-                                    border: `${NAV_COLORS.roseRgba}0.35)`,
-                                    icon: NAV_COLORS.rose,
-                                    label: NAV_COLORS.rose,
-                                };
-                            case 'muted':
-                            default:
-                                return {
-                                    bg: 'rgba(255, 255, 255, 0.08)',
-                                    border: 'rgba(255, 255, 255, 0.15)',
-                                    icon: colors.textSecondary,
-                                    label: colors.textSecondary,
-                                };
-                        }
-                    };
-
-                    const variantStyles = getVariantStyles();
-
-                    return (
-                        <Animated.View
-                            key={item.id}
-                            style={[
-                                radialStyles.menuItem,
-                                {
-                                    transform: [
-                                        { translateX: itemTranslateX },
-                                        { translateY: itemTranslateY },
-                                        { scale: itemScale },
-                                    ],
-                                },
-                            ]}
-                        >
-                            <Pressable
-                                onPress={() => handleRadialMenuItemPress(item.id)}
-                                style={radialStyles.menuItemButton}
-                            >
-                                <View style={[
-                                    radialStyles.menuItemCircle,
-                                    {
-                                        backgroundColor: variantStyles.bg,
-                                        borderColor: variantStyles.border,
-                                    },
-                                ]}>
-                                    <Ionicons
-                                        name={item.icon}
-                                        size={22}
-                                        color={variantStyles.icon}
-                                    />
-                                </View>
-                                <Text style={[radialStyles.menuItemLabel, { color: variantStyles.label }]}>
-                                    {item.label}
-                                </Text>
-                            </Pressable>
-                        </Animated.View>
-                    );
-                })}
-            </Animated.View>
-
-            {/* Match Notification Modal - Premium styling with response details */}
-            <MatchNotificationModal
-                visible={!!matchNotification}
-                match={matchNotification}
-                onDismiss={dismissNotification}
-                onChat={handleMatchChat}
-            />
-
            {/* Message Toast Notification */}
            {lastMessage && (
                <Animated.View
@@ -897,98 +622,4 @@ const styles = StyleSheet.create({
        color: colors.textSecondary,
        marginTop: 2,
    },
-    // Play button styles - Premium boutique
-    playButtonContainer: {
-        flex: 1,
-        alignItems: 'center',
-        justifyContent: 'center',
-        marginTop: -28,
-    },
-    playButtonGlow: {
-        position: 'absolute',
-        width: 76,
-        height: 76,
-        borderRadius: 38,
-        backgroundColor: colors.primaryGlow,
-        opacity: 0.4,
-    },
-    playButtonGlowActive: {
-        opacity: 0.7,
-        ...shadows.glow(colors.primary),
-    },
-    playButtonCircle: {
-        width: 64,
-        height: 64,
-        borderRadius: 32,
-        overflow: 'hidden',
-        borderWidth: 1.5,
-        borderColor: 'rgba(233, 69, 96, 0.4)', // primary brand
-        ...shadows.lg,
-    },
-    playButtonInner: {
-        flex: 1,
-        backgroundColor: '#0d0d1a',
-        alignItems: 'center',
-        justifyContent: 'center',
-    },
-    playButtonHighlight: {
-        position: 'absolute',
-        top: 0,
-        left: 0,
-        right: 0,
-        height: '50%',
-    },
-    playButtonGradient: {
-        flex: 1,
-        alignItems: 'center',
-        justifyContent: 'center',
-    },
-});
-
-// Radial menu styles - Premium boutique
-const TAB_BAR_HEIGHT = Platform.OS === 'ios' ? 88 : 64;
-
-const radialStyles = StyleSheet.create({
-    overlay: {
-        ...StyleSheet.absoluteFillObject,
-        backgroundColor: 'rgba(13, 13, 26, 0.85)',
-        zIndex: 998,
-    },
-    menuContainer: {
-        position: 'absolute',
-        bottom: TAB_BAR_HEIGHT + 30, // Position above tab bar, centered on button
-        left: 0,
-        right: 0,
-        alignItems: 'center',
-        zIndex: 999,
-    },
-    menuItem: {
-        position: 'absolute',
-        alignItems: 'center',
-    },
-    menuItemButton: {
-        alignItems: 'center',
-    },
-    menuItemCircle: {
-        width: 56,
-        height: 56,
-        borderRadius: 28,
-        backgroundColor: 'rgba(22, 33, 62, 0.9)',
-        justifyContent: 'center',
-        alignItems: 'center',
-        ...shadows.md,
-        borderWidth: 1.5,
-        borderColor: 'rgba(255, 255, 255, 0.15)',
-    },
-    menuItemLabel: {
-        ...typography.caption2,
-        color: colors.text,
-        marginTop: 8,
-        fontWeight: '500',
-        letterSpacing: 1,
-        textTransform: 'uppercase',
-        textShadowColor: 'rgba(0, 0, 0, 0.5)',
-        textShadowOffset: { width: 0, height: 1 },
-        textShadowRadius: 2,
-    },
 });
@@ -163,14 +163,35 @@ const styles = StyleSheet.create({
        opacity: 0.6,
    },
    badge: {
-        backgroundColor: 'rgba(212, 175, 55, 0.1)',
+        backgroundColor: colors.backgroundLight,
        paddingHorizontal: spacing.lg,
        paddingVertical: spacing.sm,
        borderRadius: radius.full,
        borderWidth: 1,
-        borderColor: 'rgba(212, 175, 55, 0.2)',
+        borderColor: colors.border,
        marginBottom: spacing.xl,
    },
+    interestButton: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'center',
+        backgroundColor: colors.backgroundLight,
+        paddingHorizontal: spacing.lg,
+        paddingVertical: spacing.sm + 2,
+        borderRadius: radius.full,
+        borderWidth: 1,
+        borderColor: colors.border,
+        gap: spacing.sm,
+    },
+    interestButtonActive: {
+        backgroundColor: colors.background,
+        borderColor: colors.primary,
+    },
+    interestButtonText: {
+        ...typography.subhead,
+        fontWeight: '600',
+        color: ACCENT_COLOR,
+    },
    badgeText: {
        ...typography.caption2,
        fontWeight: '600',
@@ -208,25 +229,4 @@ const styles = StyleSheet.create({
        marginTop: spacing.xl,
        minHeight: 44,
    },
-    interestButton: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        justifyContent: 'center',
-        backgroundColor: 'rgba(212, 175, 55, 0.1)',
-        paddingHorizontal: spacing.lg,
-        paddingVertical: spacing.sm + 2,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: 'rgba(212, 175, 55, 0.2)',
-        gap: spacing.sm,
-    },
-    interestButtonActive: {
-        backgroundColor: 'rgba(212, 175, 55, 0.15)',
-        borderColor: 'rgba(212, 175, 55, 0.3)',
-    },
-    interestButtonText: {
-        ...typography.subhead,
-        fontWeight: '600',
-        color: ACCENT_COLOR,
-    },
 });
@@ -1,337 +1,167 @@
-import { useEffect, useCallback } from "react";
-import { View, Text, StyleSheet, TouchableOpacity, ScrollView, Platform, useWindowDimensions } from "react-native";
-import Animated, {
-    FadeInDown,
-    FadeInRight,
-    FadeIn,
-    useSharedValue,
-    useAnimatedStyle,
-    withRepeat,
-    withTiming,
-    Easing,
-} from "react-native-reanimated";
-import { LinearGradient } from "expo-linear-gradient";
-import { useAuthStore, useMatchStore, usePacksStore } from "../../src/store";
-import { Ionicons } from "@expo/vector-icons";
-import { router, useFocusEffect } from "expo-router";
-import { GradientBackground, GlassCard } from "../../src/components/ui";
-import { colors, gradients, spacing, radius, typography, shadows } from "../../src/theme";
+import { useCallback, useMemo, useState } from 'react';
+import { ScrollView, StyleSheet, Platform, View, Text, useWindowDimensions } from 'react-native';
+import { useFocusEffect } from 'expo-router';
+import Animated, { FadeInDown } from 'react-native-reanimated';
+import { Ionicons } from '@expo/vector-icons';
+import { BlurView } from 'expo-blur';
+import { useAuthStore, usePacksStore, useSubscriptionStore } from '../../src/store';
+import { GradientBackground } from '../../src/components/ui';
+import { Paywall } from '../../src/components/paywall';
+import { CompactHeader, ContentRow } from '../../src/components/discovery';
+import { colors, spacing, typography, radius } from '../../src/theme';
+import type { QuestionPack, Category } from '../../src/types';

-const MAX_CONTENT_WIDTH = 500;
-const ACCENT_COLOR = colors.primary;
+const MAX_CONTENT_WIDTH = 600;

-export default function HomeScreen() {
+// Group packs by category
+function groupPacksByCategory(
+  packs: QuestionPack[],
+  categories: Category[]
+): { category: Category; packs: QuestionPack[] }[] {
+  const categoryMap = new Map<string, QuestionPack[]>();
+  const uncategorized: QuestionPack[] = [];
+
+  // Initialize map with empty arrays for each category
+  categories.forEach((cat) => {
+    categoryMap.set(cat.id, []);
+  });
+
+  // Group packs
+  packs.forEach((pack) => {
+    if (pack.category_id && categoryMap.has(pack.category_id)) {
+      categoryMap.get(pack.category_id)!.push(pack);
+    } else {
+      uncategorized.push(pack);
+    }
+  });
+
+  // Build result array maintaining category sort order
+  const result: { category: Category; packs: QuestionPack[] }[] = [];
+
+  categories.forEach((cat) => {
+    const categoryPacks = categoryMap.get(cat.id) || [];
+    if (categoryPacks.length > 0) {
+      result.push({ category: cat, packs: categoryPacks });
+    }
+  });
+
+  // Add uncategorized at the end if any
+  if (uncategorized.length > 0) {
+    result.push({
+      category: {
+        id: 'uncategorized',
+        name: 'More',
+        description: null,
+        icon: 'ellipsis-horizontal',
+        color: null,
+        sort_order: 999,
+        created_at: '',
+        is_public: true,
+      },
+      packs: uncategorized,
+    });
+  }
+
+  return result;
+}
+
+export default function DiscoveryScreen() {
  const { user, partner, couple } = useAuthStore();
-    const { matches, newMatchesCount, totalCount, fetchMatches } = useMatchStore();
-    const { enabledPackIds, fetchPacks } = usePacksStore();
+  const { packs, categories, fetchPacks, getPackProgress } = usePacksStore();
+  const { subscription } = useSubscriptionStore();
  const { width } = useWindowDimensions();
+  const [showPaywall, setShowPaywall] = useState(false);
+  const [headerHeight, setHeaderHeight] = useState(130);

-    // Refresh data when screen gains focus for freshness
+  // Check all sources of premium access: user flag, partner flag, or active subscription
+  const isPremiumUser = user?.is_premium || partner?.is_premium || subscription.isProUser;
+  const isWideScreen = width > MAX_CONTENT_WIDTH;
+
+  // Refresh data when screen gains focus
  useFocusEffect(
    useCallback(() => {
-            fetchMatches();
      fetchPacks();
    }, [])
  );

-    const topMatches = matches.slice(0, 3);
-    const isWideScreen = width > MAX_CONTENT_WIDTH;
-    const enabledPacksCount = enabledPackIds.length;
-
-    // Subtle pulsating animation for the CTA icon
-    const pulseScale = useSharedValue(1);
-    const glowOpacity = useSharedValue(0.3);
-
-    useEffect(() => {
-        const startPulse = () => {
-            pulseScale.value = 1;
-            pulseScale.value = withRepeat(
-                withTiming(1.1, { duration: 1500, easing: Easing.inOut(Easing.ease) }),
-                -1,
-                true
+  // Group packs by category
+  const packsByCategory = useMemo(
+    () => groupPacksByCategory(packs, categories),
+    [packs, categories]
  );
-            glowOpacity.value = withRepeat(
-                withTiming(0.6, { duration: 1500, easing: Easing.inOut(Easing.ease) }),
-                -1,
-                true
-            );
-        };
-        const timeout = setTimeout(startPulse, 100);
-        return () => clearTimeout(timeout);
-    }, []);

-    const pulseAnimatedStyle = useAnimatedStyle(() => ({
-        transform: [{ scale: pulseScale.value }],
-    }));
-
-    const glowAnimatedStyle = useAnimatedStyle(() => ({
-        opacity: glowOpacity.value,
-    }));
+  // Check if user has no packs enabled (empty state)
+  const hasNoPacks = packs.length === 0;

  return (
    <GradientBackground>
+      <View
+        style={[styles.stickyHeader, isWideScreen && styles.stickyHeaderWide]}
+        onLayout={(e) => setHeaderHeight(e.nativeEvent.layout.height)}
+      >
+        <BlurView intensity={80} tint="dark" style={StyleSheet.absoluteFill} />
+        <View style={[StyleSheet.absoluteFill, { backgroundColor: 'rgba(14, 14, 17, 0.85)' }]} />
+        <CompactHeader user={user} partner={partner} couple={couple} />
+      </View>
+
      <ScrollView
        style={styles.container}
        contentContainerStyle={[
          styles.contentContainer,
          isWideScreen && styles.contentContainerWide,
+          { paddingTop: headerHeight },
        ]}
        showsVerticalScrollIndicator={false}
      >
        <View style={[styles.innerContainer, isWideScreen && styles.innerContainerWide]}>
-                    {/* Premium Header */}
-                    <Animated.View
-                        entering={FadeInDown.delay(100).duration(600).springify()}
-                        style={styles.header}
-                    >
-                        {/* Greeting section */}
-                        <Text style={styles.label}>WELCOME BACK</Text>
-                        <Text style={styles.greeting}>
-                            {user?.name || "Beautiful"}
-                        </Text>
-
-                        {/* Decorative separator */}
-                        <View style={styles.separator}>
-                            <View style={styles.separatorLine} />
-                            <View style={styles.separatorDiamond} />
-                            <View style={styles.separatorLine} />
-                        </View>
-
-                        {/* Partner badge */}
-                        {partner ? (
-                            <Animated.View
-                                entering={FadeIn.delay(300).duration(400)}
-                                style={styles.partnerBadge}
-                            >
-                                <Ionicons name="heart" size={12} color={ACCENT_COLOR} />
-                                <Text style={styles.partnerText}>
-                                    Connected with {partner.name || partner.email?.split('@')[0] || 'Partner'}
-                                </Text>
-                            </Animated.View>
-                        ) : couple ? (
-                            <TouchableOpacity
-                                style={styles.waitingBadge}
-                                onPress={() => router.push("/(app)/pairing")}
-                            >
-                                <Ionicons name="hourglass-outline" size={12} color={ACCENT_COLOR} />
-                                <Text style={styles.waitingText}>Waiting for partner</Text>
-                            </TouchableOpacity>
-                        ) : (
-                            <TouchableOpacity
-                                style={styles.pairBadge}
-                                onPress={() => router.push("/(app)/pairing")}
-                            >
-                                <Ionicons name="add-circle-outline" size={12} color={colors.textTertiary} />
-                                <Text style={styles.pairText}>Connect with your partner</Text>
-                            </TouchableOpacity>
-                        )}
-
-                    </Animated.View>
-
-                    {/* Stats Row */}
-                    <Animated.View
-                        entering={FadeInDown.delay(200).duration(500)}
-                        style={styles.statsContainer}
-                    >
-                        <TouchableOpacity
-                            style={styles.statCardWrapper}
-                            onPress={() => router.push("/(app)/matches")}
-                            activeOpacity={0.7}
-                        >
-                            <View style={[styles.statCard, matches.length > 0 && styles.statCardActive]}>
-                                <View style={[styles.statIcon, matches.length > 0 && styles.statIconActive]}>
-                                    <Ionicons
-                                        name="heart"
-                                        size={18}
-                                        color={matches.length > 0 ? colors.text : ACCENT_COLOR}
+          {/* Content Rows by Category */}
+          {packsByCategory.map((group, index) => (
+            <ContentRow
+              key={group.category.id}
+              title={group.category.name}
+              packs={group.packs}
+              isPremiumUser={isPremiumUser}
+              categoryId={group.category.id}
+              delay={200 + index * 100}
+              getPackProgress={getPackProgress}
+              onShowPaywall={() => setShowPaywall(true)}
            />
-                                </View>
-                                <Text style={styles.statNumber}>{totalCount ?? matches.length}</Text>
-                                <Text style={styles.statLabel}>Matches</Text>
-                            </View>
-                        </TouchableOpacity>
-
-                        <TouchableOpacity
-                            style={styles.statCardWrapper}
-                            onPress={() => router.push("/(app)/packs")}
-                            activeOpacity={0.7}
-                        >
-                            <View style={[styles.statCard, enabledPacksCount > 0 && styles.statCardActive]}>
-                                <View style={[styles.statIcon, enabledPacksCount > 0 && styles.statIconActive]}>
-                                    <Ionicons
-                                        name="layers"
-                                        size={18}
-                                        color={enabledPacksCount > 0 ? colors.text : ACCENT_COLOR}
-                                    />
-                                </View>
-                                <Text style={styles.statNumber}>{enabledPacksCount}</Text>
-                                <Text style={styles.statLabel}>Packs</Text>
-                            </View>
-                        </TouchableOpacity>
-
-                        <TouchableOpacity
-                            style={styles.statCardWrapper}
-                            onPress={() => router.push("/(app)/matches")}
-                            activeOpacity={0.7}
-                        >
-                            <View style={[styles.statCard, newMatchesCount > 0 && styles.statCardActive]}>
-                                <View style={[styles.statIcon, newMatchesCount > 0 && styles.statIconActive]}>
-                                    <Ionicons
-                                        name="sparkles"
-                                        size={18}
-                                        color={newMatchesCount > 0 ? colors.text : ACCENT_COLOR}
-                                    />
-                                </View>
-                                <Text style={styles.statNumber}>{newMatchesCount}</Text>
-                                <Text style={styles.statLabel}>New</Text>
-                            </View>
-                        </TouchableOpacity>
-                    </Animated.View>
-
-                    {/* Play CTA */}
-                    <Animated.View
-                        entering={FadeInDown.delay(300).duration(500)}
-                        style={styles.ctaSection}
-                    >
-                        <TouchableOpacity
-                            onPress={() => router.push("/(app)/swipe")}
-                            activeOpacity={0.9}
-                        >
-                            <View style={styles.ctaCard}>
-                                {/* Glow effect */}
-                                <Animated.View style={[styles.ctaGlow, glowAnimatedStyle]} />
-
-                                <LinearGradient
-                                    colors={gradients.primary as [string, string]}
-                                    style={styles.ctaGradient}
-                                    start={{ x: 0, y: 0 }}
-                                    end={{ x: 1, y: 1 }}
-                                >
-                                    <View style={styles.ctaContent}>
-                                        <Text style={styles.ctaLabel}>EXPLORE</Text>
-                                        <Text style={styles.ctaTitle}>Ready to explore?</Text>
-                                        <Text style={styles.ctaSubtitle}>
-                                            Discover new experiences
-                                        </Text>
-                                    </View>
-                                    <Animated.View style={[styles.ctaIconContainer, pulseAnimatedStyle]}>
-                                        <Ionicons name="flame" size={28} color={colors.text} />
-                                    </Animated.View>
-                                </LinearGradient>
-                            </View>
-                        </TouchableOpacity>
-                    </Animated.View>
-
-                    {/* Top Matches (sorted by unread first, then recent) */}
-                    {topMatches.length > 0 && (
-                        <Animated.View
-                            entering={FadeInDown.delay(400).duration(500)}
-                            style={styles.section}
-                        >
-                            <View style={styles.sectionHeader}>
-                                <View style={styles.sectionTitleRow}>
-                                    <View style={styles.sectionIcon}>
-                                        <Ionicons name="heart" size={14} color={ACCENT_COLOR} />
-                                    </View>
-                                    <Text style={styles.sectionTitle}>Top Matches</Text>
-                                </View>
-                                <TouchableOpacity
-                                    onPress={() => router.push("/(app)/matches")}
-                                    style={styles.seeAllButton}
-                                >
-                                    <Text style={styles.seeAllText}>See all</Text>
-                                    <Ionicons name="chevron-forward" size={14} color={ACCENT_COLOR} />
-                                </TouchableOpacity>
-                            </View>
-                            {topMatches.map((match, index) => (
-                                <Animated.View
-                                    key={match.id}
-                                    entering={FadeInRight.delay(450 + index * 100).duration(400)}
-                                >
-                                    <TouchableOpacity
-                                        onPress={() => router.push(`/chat/${match.id}`)}
-                                        activeOpacity={0.7}
-                                    >
-                                        <View style={styles.matchCard}>
-                                            <View style={styles.matchRow}>
-                                                <LinearGradient
-                                                    colors={gradients.primary as [string, string]}
-                                                    style={styles.matchIcon}
-                                                    start={{ x: 0, y: 0 }}
-                                                    end={{ x: 1, y: 1 }}
-                                                >
-                                                    <Ionicons name="heart" size={14} color={colors.text} />
-                                                </LinearGradient>
-                                                <Text style={styles.matchText} numberOfLines={1}>
-                                                    {(match as any).question?.text || "A new match!"}
-                                                </Text>
-                                                {match.is_new && <View style={styles.newBadge} />}
-                                            </View>
-                                        </View>
-                                    </TouchableOpacity>
-                                </Animated.View>
          ))}
-                        </Animated.View>
-                    )}

-                    {/* Tips when no matches */}
-                    {topMatches.length === 0 && (
+          {/* Empty state when no packs */}
+          {hasNoPacks && (
            <Animated.View
-                            entering={FadeInDown.delay(400).duration(500)}
-                            style={styles.section}
+              entering={FadeInDown.delay(300).duration(500).springify()}
+              style={styles.emptyState}
            >
-                            <View style={styles.sectionHeader}>
-                                <View style={styles.sectionTitleRow}>
-                                    <View style={styles.sectionIcon}>
-                                        <Ionicons name="compass" size={14} color={ACCENT_COLOR} />
-                                    </View>
-                                    <Text style={styles.sectionTitle}>Getting Started</Text>
-                                </View>
-                            </View>
-
-                            <View style={styles.tipCard}>
-                                <View style={styles.tipRow}>
-                                    <View style={styles.tipIcon}>
-                                        <Ionicons name="layers-outline" size={18} color={ACCENT_COLOR} />
-                                    </View>
-                                    <View style={styles.tipContent}>
-                                        <Text style={styles.tipText}>Enable question packs</Text>
-                                        <Text style={styles.tipSubtext}>Choose topics to explore together</Text>
-                                    </View>
-                                </View>
-                            </View>
-                            <View style={[styles.tipCard, styles.tipCardSpaced]}>
-                                <View style={styles.tipRow}>
-                                    <View style={styles.tipIcon}>
-                                        <Ionicons name="swap-horizontal-outline" size={18} color={ACCENT_COLOR} />
-                                    </View>
-                                    <View style={styles.tipContent}>
-                                        <Text style={styles.tipText}>Swipe on questions</Text>
-                                        <Text style={styles.tipSubtext}>Answer yes, no, or maybe</Text>
-                                    </View>
-                                </View>
-                            </View>
-                            <View style={[styles.tipCard, styles.tipCardSpaced]}>
-                                <View style={styles.tipRow}>
-                                    <View style={styles.tipIcon}>
-                                        <Ionicons name="heart-outline" size={18} color={ACCENT_COLOR} />
-                                    </View>
-                                    <View style={styles.tipContent}>
-                                        <Text style={styles.tipText}>Discover matches</Text>
-                                        <Text style={styles.tipSubtext}>See where you both agree</Text>
-                                    </View>
-                                </View>
+              <View style={styles.emptyIcon}>
+                <Ionicons name="layers-outline" size={48} color={colors.primary} />
              </View>
+              <Text style={styles.emptyTitle}>No packs available</Text>
+              <Text style={styles.emptySubtitle}>
+                Check back soon for new content
+              </Text>
            </Animated.View>
          )}

          <View style={styles.bottomSpacer} />
        </View>
      </ScrollView>
+
+      {/* Paywall Modal */}
+      <Paywall
+        visible={showPaywall}
+        onClose={() => setShowPaywall(false)}
+        onSuccess={() => {
+          setShowPaywall(false);
+          fetchPacks(); // Refresh packs to update lock status
+        }}
+      />
    </GradientBackground>
  );
 }

+
 const styles = StyleSheet.create({
  container: {
    flex: 1,
@@ -350,292 +180,48 @@ const styles = StyleSheet.create({
  innerContainerWide: {
    maxWidth: MAX_CONTENT_WIDTH,
  },
-    header: {
-        paddingTop: 60,
-        paddingHorizontal: spacing.lg,
-        paddingBottom: spacing.xl,
-        alignItems: 'center',
-    },
-    label: {
-        ...typography.caption2,
-        fontWeight: '600',
-        letterSpacing: 2.5,
-        color: ACCENT_COLOR,
-        textAlign: 'center',
-        marginBottom: spacing.xs,
-    },
-    greeting: {
-        ...typography.largeTitle,
-        color: colors.text,
-        textAlign: 'center',
-    },
-    separator: {
-        flexDirection: 'row',
-        alignItems: 'center',
+  emptyState: {
+    flex: 1,
    justifyContent: 'center',
-        marginVertical: spacing.md,
-        width: 120,
-    },
-    separatorLine: {
-        flex: 1,
-        height: 1,
-        backgroundColor: 'rgba(233, 69, 96, 0.3)',
-    },
-    separatorDiamond: {
-        width: 5,
-        height: 5,
-        backgroundColor: ACCENT_COLOR,
-        transform: [{ rotate: '45deg' }],
-        marginHorizontal: spacing.sm,
-        opacity: 0.6,
-    },
-    partnerBadge: {
-        flexDirection: 'row',
    alignItems: 'center',
-        backgroundColor: 'rgba(233, 69, 96, 0.1)',
-        paddingHorizontal: spacing.md,
-        paddingVertical: spacing.sm,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: 'rgba(233, 69, 96, 0.2)',
-        gap: spacing.xs,
+    paddingHorizontal: spacing.xl,
+    paddingVertical: spacing.xxl,
  },
-    partnerText: {
-        ...typography.caption1,
+  emptyIcon: {
+    width: 80,
+    height: 80,
+    borderRadius: 40,
+    backgroundColor: 'rgba(233, 69, 96, 0.1)',
+    justifyContent: 'center',
+    alignItems: 'center',
+    marginBottom: spacing.lg,
+  },
+  emptyTitle: {
+    ...typography.title3,
    color: colors.text,
-        fontWeight: '500',
-    },
-    pairBadge: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        backgroundColor: colors.glass.background,
-        paddingHorizontal: spacing.md,
-        paddingVertical: spacing.sm,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: colors.glass.border,
-        gap: spacing.xs,
-    },
-    pairText: {
-        ...typography.caption1,
-        color: colors.textTertiary,
-    },
-    waitingBadge: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        backgroundColor: 'rgba(233, 69, 96, 0.1)',
-        paddingHorizontal: spacing.md,
-        paddingVertical: spacing.sm,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: 'rgba(233, 69, 96, 0.2)',
-        gap: spacing.xs,
-    },
-    waitingText: {
-        ...typography.caption1,
-        color: colors.text,
-        fontWeight: '500',
-    },
-    statsContainer: {
-        flexDirection: "row",
-        paddingHorizontal: spacing.lg,
-        gap: spacing.sm,
-    },
-    statCardWrapper: {
-        flex: 1,
-    },
-    statCard: {
-        alignItems: "center",
-        paddingVertical: spacing.md,
-        backgroundColor: 'rgba(233, 69, 96, 0.05)',
-        borderRadius: radius.lg,
-        borderWidth: 1,
-        borderColor: 'rgba(233, 69, 96, 0.1)',
-    },
-    statCardActive: {
-        backgroundColor: 'rgba(233, 69, 96, 0.1)',
-        borderColor: 'rgba(233, 69, 96, 0.2)',
-    },
-    statIcon: {
-        width: 36,
-        height: 36,
-        borderRadius: 18,
-        backgroundColor: 'rgba(233, 69, 96, 0.1)',
-        justifyContent: "center",
-        alignItems: "center",
    marginBottom: spacing.sm,
  },
-    statIconActive: {
-        backgroundColor: ACCENT_COLOR,
-    },
-    statNumber: {
-        ...typography.title2,
-        color: colors.text,
-    },
-    statLabel: {
-        ...typography.caption2,
-        color: colors.textSecondary,
-        marginTop: 2,
-    },
-    ctaSection: {
-        paddingHorizontal: spacing.lg,
-        marginTop: spacing.xl,
-    },
-    ctaCard: {
-        position: 'relative',
-        borderRadius: radius.xl,
-        overflow: 'hidden',
-    },
-    ctaGlow: {
-        position: 'absolute',
-        top: -20,
-        left: -20,
-        right: -20,
-        bottom: -20,
-        backgroundColor: ACCENT_COLOR,
-        borderRadius: radius.xl + 20,
-    },
-    ctaGradient: {
-        borderRadius: radius.xl,
-        padding: spacing.lg,
-        flexDirection: "row",
-        alignItems: "center",
-        ...shadows.lg,
-    },
-    ctaContent: {
-        flex: 1,
-    },
-    ctaLabel: {
-        ...typography.caption2,
-        fontWeight: '600',
-        letterSpacing: 2,
-        color: 'rgba(255,255,255,0.8)',
-        marginBottom: spacing.xs,
-    },
-    ctaTitle: {
-        ...typography.title2,
-        color: colors.text,
-        marginBottom: spacing.xs,
-    },
-    ctaSubtitle: {
-        ...typography.subhead,
-        color: "rgba(255,255,255,0.8)",
-    },
-    ctaIconContainer: {
-        width: 56,
-        height: 56,
-        borderRadius: 28,
-        backgroundColor: "rgba(255,255,255,0.2)",
-        borderWidth: 1,
-        borderColor: 'rgba(255,255,255,0.3)',
-        justifyContent: "center",
-        alignItems: "center",
-        marginLeft: spacing.md,
-    },
-    section: {
-        paddingHorizontal: spacing.lg,
-        marginTop: spacing.xl,
-    },
-    sectionHeader: {
-        flexDirection: "row",
-        justifyContent: "space-between",
-        alignItems: "center",
-        marginBottom: spacing.md,
-    },
-    sectionTitleRow: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        gap: spacing.sm,
-    },
-    sectionIcon: {
-        width: 24,
-        height: 24,
-        borderRadius: 12,
-        backgroundColor: 'rgba(233, 69, 96, 0.1)',
-        justifyContent: 'center',
-        alignItems: 'center',
-    },
-    sectionTitle: {
-        ...typography.headline,
-        color: colors.text,
-    },
-    seeAllButton: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        gap: 2,
-    },
-    seeAllText: {
-        ...typography.subhead,
-        color: ACCENT_COLOR,
-    },
-    matchCard: {
-        marginBottom: spacing.sm,
-        backgroundColor: 'rgba(233, 69, 96, 0.05)',
-        borderRadius: radius.md,
-        borderWidth: 1,
-        borderColor: 'rgba(233, 69, 96, 0.1)',
-        padding: spacing.md,
-    },
-    matchRow: {
-        flexDirection: "row",
-        alignItems: "center",
-    },
-    matchIcon: {
-        width: 28,
-        height: 28,
-        borderRadius: 14,
-        justifyContent: "center",
-        alignItems: "center",
-        marginRight: spacing.md,
-    },
-    matchText: {
-        flex: 1,
+  emptySubtitle: {
    ...typography.body,
-        color: colors.text,
-    },
-    newBadge: {
-        width: 8,
-        height: 8,
-        borderRadius: 4,
-        backgroundColor: ACCENT_COLOR,
-    },
-    tipCard: {
-        backgroundColor: 'rgba(233, 69, 96, 0.05)',
-        borderRadius: radius.md,
-        borderWidth: 1,
-        borderColor: 'rgba(233, 69, 96, 0.1)',
-        padding: spacing.md,
-    },
-    tipCardSpaced: {
-        marginTop: spacing.sm,
-    },
-    tipRow: {
-        flexDirection: 'row',
-        alignItems: 'center',
-    },
-    tipIcon: {
-        width: 36,
-        height: 36,
-        borderRadius: 18,
-        backgroundColor: 'rgba(233, 69, 96, 0.1)',
-        justifyContent: 'center',
-        alignItems: 'center',
-        marginRight: spacing.md,
-    },
-    tipContent: {
-        flex: 1,
-    },
-    tipText: {
-        ...typography.body,
-        color: colors.text,
-        fontWeight: '500',
-    },
-    tipSubtext: {
-        ...typography.caption1,
    color: colors.textSecondary,
-        marginTop: 2,
+    textAlign: 'center',
  },
  bottomSpacer: {
    height: spacing.lg,
  },
+  stickyHeader: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    zIndex: 10,
+    overflow: 'hidden', // Ensures blur doesn't bleed if we rounded corners (optional)
+  },
+  stickyHeaderWide: {
+    left: '50%',
+    right: 'auto',
+    width: MAX_CONTENT_WIDTH,
+    transform: [{ translateX: -MAX_CONTENT_WIDTH / 2 }],
+  },
 });
+
@@ -48,7 +48,7 @@ type GroupByOption = "pack" | "date" | "answer";

 export default function MyAnswersScreen() {
    const { responses, isLoading, isLoadingMore, hasMore, groupBy, dateSortOrder, fetchResponses, setGroupBy, toggleDateSortOrder, totalCount } = useResponsesStore();
-    const { user } = useAuthStore();
+    const { user, partner } = useAuthStore();
    const router = useRouter();
    const params = useLocalSearchParams();
    const { width } = useWindowDimensions();
@@ -152,6 +152,9 @@ export default function MyAnswersScreen() {
            index={index}
            onEditPress={() => handleEditPress(item)}
            onChatPress={item.match_id ? () => router.push(`/chat/${item.match_id}`) : undefined}
+            viewerId={user?.id}
+            viewerName={user?.name}
+            partnerName={partner?.name}
        />
    );

@@ -210,7 +213,7 @@ export default function MyAnswersScreen() {

    return (
        <GradientBackground>
-            {/* Ambient Orbs */}
+            {/* Ambient Orbs - Commented out for flat look
            <Animated.View
                style={[styles.ambientOrb, styles.orbTopRight, orbStyle1]}
                pointerEvents="none"
@@ -233,16 +236,13 @@ export default function MyAnswersScreen() {
                    end={{ x: 0, y: 0 }}
                />
            </Animated.View>
+            */}

            <View style={styles.container}>
                {/* Fixed Nav Bar */}
                <View style={styles.navBar}>
                    <Animated.View style={[styles.navBarBackground, navBarBackgroundStyle]}>
-                        {Platform.OS === "ios" ? (
-                            <BlurView intensity={80} tint="dark" style={StyleSheet.absoluteFill} />
-                        ) : (
-                            <View style={[StyleSheet.absoluteFill, { backgroundColor: "rgba(13, 13, 26, 0.95)" }]} />
-                        )}
+                        <View style={[StyleSheet.absoluteFill, { backgroundColor: colors.background }]} />
                    </Animated.View>
                    
                    <TouchableOpacity style={styles.navBarBackButton} onPress={handleBack}>
@@ -322,7 +322,7 @@ export default function MyAnswersScreen() {
                                    come back here to review and change your answers anytime.
                                </Text>
                                <GlassButton
-                                    onPress={() => router.push("/(app)/swipe")}
+                                    onPress={() => router.push("/")}
                                    style={{ marginTop: spacing.lg }}
                                >
                                    Start Swiping
@@ -390,7 +390,8 @@ const styles = StyleSheet.create({
    navBarBackground: {
        ...StyleSheet.absoluteFillObject,
        borderBottomWidth: 1,
-        borderBottomColor: 'rgba(212, 175, 55, 0.15)', // Gold tint
+        borderBottomColor: colors.border,
+        backgroundColor: colors.background,
        overflow: "hidden",
    },
    navBarBackButton: {
@@ -401,12 +402,52 @@ const styles = StyleSheet.create({
        width: 36,
        height: 36,
        borderRadius: 18,
-        backgroundColor: "rgba(255, 255, 255, 0.08)",
+        backgroundColor: colors.backgroundLight,
        justifyContent: "center",
        alignItems: "center",
        borderWidth: 1,
-        borderColor: "rgba(255, 255, 255, 0.1)",
+        borderColor: colors.border,
    },
+    // ...
+    countBadgePremium: {
+        flexDirection: "row",
+        alignItems: "center",
+        backgroundColor: colors.backgroundLight,
+        paddingHorizontal: spacing.md,
+        paddingVertical: spacing.sm,
+        borderRadius: radius.full,
+        borderWidth: 1,
+        borderColor: colors.border,
+        gap: spacing.xs,
+    },
+    // ...
+    groupByButton: {
+        flexDirection: "row",
+        alignItems: "center",
+        paddingHorizontal: spacing.md,
+        paddingVertical: spacing.sm,
+        borderRadius: radius.full,
+        backgroundColor: colors.backgroundLight,
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+    groupByButtonActive: {
+        backgroundColor: colors.background,
+        borderColor: colors.primary,
+    },
+    // ...
+    emptyIcon: {
+        width: 80,
+        height: 80,
+        borderRadius: 40,
+        backgroundColor: colors.backgroundLight,
+        justifyContent: "center",
+        alignItems: "center",
+        marginBottom: spacing.lg,
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+
    navBarTitle: {
        ...typography.headline,
        color: colors.text,
@@ -439,17 +480,7 @@ const styles = StyleSheet.create({
        color: colors.text,
        textAlign: "center",
    },
-    countBadgePremium: {
-        flexDirection: "row",
-        alignItems: "center",
-        backgroundColor: `${ACCENT_RGBA}0.1)`,
-        paddingHorizontal: spacing.md,
-        paddingVertical: spacing.sm,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: `${ACCENT_RGBA}0.2)`,
-        gap: spacing.xs,
-    },
+
    countTextPremium: {
        ...typography.caption2,
        fontWeight: "600",
@@ -463,20 +494,8 @@ const styles = StyleSheet.create({
        gap: spacing.sm,
        marginTop: spacing.md,
    },
-    groupByButton: {
-        flexDirection: "row",
-        alignItems: "center",
-        paddingHorizontal: spacing.md,
-        paddingVertical: spacing.sm,
-        borderRadius: radius.full,
-        backgroundColor: "rgba(255, 255, 255, 0.05)",
-        borderWidth: 1,
-        borderColor: "rgba(255, 255, 255, 0.1)",
-    },
-    groupByButtonActive: {
-        backgroundColor: `${ACCENT_RGBA}0.15)`,
-        borderColor: `${ACCENT_RGBA}0.3)`,
-    },
+
+
    groupByText: {
        ...typography.caption1,
        color: colors.textSecondary,
@@ -518,15 +537,7 @@ const styles = StyleSheet.create({
        paddingHorizontal: spacing.md,
        paddingVertical: spacing.xxl,
    },
-    emptyIcon: {
-        width: 80,
-        height: 80,
-        borderRadius: 40,
-        backgroundColor: `${ACCENT_RGBA}0.1)`,
-        justifyContent: "center",
-        alignItems: "center",
-        marginBottom: spacing.lg,
-    },
+
    emptyTitle: {
        ...typography.title2,
        color: colors.text,
@@ -9,6 +9,7 @@ import {
    Platform,
    Keyboard,
    ScrollView,
+    Image,
 } from 'react-native';
 import { useRouter } from 'expo-router';
 import { Ionicons } from '@expo/vector-icons';
@@ -17,22 +18,24 @@ import Animated, {
    FadeIn,
    FadeInUp,
    FadeOut,
-    FadeOutLeft,
    SlideInRight,
    SlideOutLeft,
-    Layout,
 } from 'react-native-reanimated';
 import { GradientBackground } from '../../src/components/ui/GradientBackground';
 import { GlassCard } from '../../src/components/ui/GlassCard';
 import { GlassButton } from '../../src/components/ui/GlassButton';
-import { IntensitySlider } from '../../src/components/ui/IntensitySlider';
+import { GlassToggle } from '../../src/components/ui/GlassToggle';
+import { Paywall } from '../../src/components/paywall';
 import { colors, gradients, spacing, typography, radius, shadows } from '../../src/theme';
 import { useAuthStore } from '../../src/store';
 import { supabase } from '../../src/lib/supabase';
 import { getProfileError } from '../../src/lib/errors';
 import { registerForPushNotificationsAsync, savePushToken } from '../../src/lib/notifications';
 import { Events } from '../../src/lib/analytics';
-import type { Gender, IntensityLevel } from '../../src/types';
+import { hasSeenOnboardingPaywall, markOnboardingPaywallSeen } from '../../src/lib/onboardingPaywallSeen';
+import { useAvatarPicker } from '../../src/hooks/useAvatarPicker';
+import { REQUIRED_ONBOARDING_VERSION, ONBOARDING_OFFERING_ID } from '../../src/constants/onboarding';
+import type { Gender } from '../../src/types';

 const GENDER_OPTIONS: { value: Gender; label: string; icon: string }[] = [
    { value: 'male', label: 'Male', icon: 'male' },
@@ -51,37 +54,51 @@ const PURPOSE_OPTIONS: { value: UsageReason; label: string; icon: string }[] = [
    { value: 'strengthen_relationship', label: 'Strengthen our relationship', icon: 'shield-checkmark' },
 ];

-const DEFAULT_MAX_INTENSITY: IntensityLevel = 2;
+// Intensity thresholds for backwards compatibility
+// When hide_nsfw=true, max_intensity=2 (mild content only)
+// When hide_nsfw=false, max_intensity=5 (all content)
+const NSFW_OFF_INTENSITY = 2;
+const NSFW_ON_INTENSITY = 5;

-const normalizeIntensity = (value: number | null | undefined): IntensityLevel | null => {
-    if (value === 1 || value === 2 || value === 3 || value === 4 || value === 5) return value;
-    return null;
-};
-
-const getInitialIntensity = (profile?: { max_intensity?: number | null; show_explicit_content?: boolean | null } | null): IntensityLevel => {
-    const normalized = normalizeIntensity(profile?.max_intensity);
-    if (normalized) return normalized;
-    return profile?.show_explicit_content ? 5 : DEFAULT_MAX_INTENSITY;
-};
-
-type Stage = 'name' | 'gender' | 'purpose' | 'explicit' | 'notifications';
+type Stage = 'avatar' | 'name' | 'gender' | 'purpose' | 'content' | 'notifications';

 export default function OnboardingScreen() {
    const router = useRouter();
    const { user, fetchUser } = useAuthStore();
-    const [stage, setStage] = useState<Stage>('name');
+    const [stage, setStage] = useState<Stage>('avatar');
    const [name, setName] = useState(user?.name || '');
    const [gender, setGender] = useState<Gender | null>(user?.gender || null);
    const [usageReason, setUsageReason] = useState<UsageReason | null>(null);
-    const [maxIntensity, setMaxIntensity] = useState<IntensityLevel>(() => getInitialIntensity(user));
+    const [hideNsfw, setHideNsfw] = useState(user?.hide_nsfw ?? false);
    const [isLoading, setIsLoading] = useState(false);
    const [error, setError] = useState<string | null>(null);
+    const [showPaywall, setShowPaywall] = useState(false);
    const inputRef = useRef<TextInput>(null);
+    const paywallNavigationRef = useRef(false);
+
+    const {
+        avatarUri,
+        isUploading: isUploadingAvatar,
+        showPicker: handleAvatarPress,
+        uploadAvatar,
+    } = useAvatarPicker({
+        userId: user?.id,
+        onSelect: () => setError(null),
+    });

    useEffect(() => {
        Events.onboardingStart();
    }, []);

+    const handleAvatarContinue = () => {
+        if (!avatarUri) {
+            setError('Please add a profile photo to continue');
+            return;
+        }
+        setStage('name');
+        Events.onboardingStageComplete('avatar');
+    };
+
    const handleNameSubmit = () => {
        if (!name.trim()) {
            setError('Please enter your name');
@@ -117,13 +134,13 @@ export default function OnboardingScreen() {
            setError('Please select what brings you to Sauci');
            return;
        }
-        setStage('explicit');
+        setStage('content');
        Events.onboardingStageComplete('purpose');
    };

-    const handleIntensityContinue = () => {
+    const handleContentContinue = () => {
        setStage('notifications');
-        Events.onboardingStageComplete('explicit');
+        Events.onboardingStageComplete('content');
    };

    const handleEnableNotifications = async () => {
@@ -153,19 +170,40 @@ export default function OnboardingScreen() {
        setError(null);

        try {
-            const showExplicitContent = maxIntensity >= 3;
+            // Upload avatar if one was selected
+            let avatarUrl: string | null = null;
+            if (avatarUri) {
+                avatarUrl = await uploadAvatar();
+                if (avatarUrl) {
+                    Events.avatarUploaded();
+                }
+            }

-            const { error: updateError } = await supabase
-                .from('profiles')
-                .update({
+            // Derive intensity from hide_nsfw for backwards compatibility
+            const maxIntensity = hideNsfw ? NSFW_OFF_INTENSITY : NSFW_ON_INTENSITY;
+            const showExplicitContent = !hideNsfw;
+            const updatedFields: string[] = ["name", "gender", "usage_reason", "max_intensity", "show_explicit_content", "hide_nsfw"];
+
+            const updateData: Record<string, any> = {
                name: name.trim(),
                gender,
                usage_reason: usageReason,
                max_intensity: maxIntensity,
                show_explicit_content: showExplicitContent,
+                hide_nsfw: hideNsfw,
                onboarding_completed: true,
+                onboarding_version: REQUIRED_ONBOARDING_VERSION,
                updated_at: new Date().toISOString(),
-                })
+            };
+
+            if (avatarUrl) {
+                updateData.avatar_url = avatarUrl;
+                updatedFields.push("avatar_url");
+            }
+
+            const { error: updateError } = await supabase
+                .from('profiles')
+                .update(updateData)
                .eq('id', user.id);

            if (updateError) {
@@ -176,8 +214,17 @@ export default function OnboardingScreen() {
            console.log('[Onboarding] Profile updated successfully, fetching user...');
            await fetchUser();
            console.log('[Onboarding] User fetched, navigating to home...');
-            Events.profileUpdated(["name", "gender", "usage_reason", "max_intensity", "show_explicit_content"]);
+            Events.profileUpdated(updatedFields);
            Events.onboardingComplete();
+            const currentUser = useAuthStore.getState().user;
+            if (currentUser?.id && !currentUser.is_premium) {
+                const hasSeenPaywall = await hasSeenOnboardingPaywall(currentUser.id);
+                if (!hasSeenPaywall) {
+                    paywallNavigationRef.current = true;
+                    setShowPaywall(true);
+                    return;
+                }
+            }
            router.replace('/');
        } catch (err: any) {
            console.error('Onboarding error:', err);
@@ -187,12 +234,24 @@ export default function OnboardingScreen() {
        }
    };

+    const handlePaywallClose = () => {
+        setShowPaywall(false);
+        const currentUser = useAuthStore.getState().user;
+        if (currentUser?.id) {
+            void markOnboardingPaywallSeen(currentUser.id);
+        }
+        if (paywallNavigationRef.current) {
+            paywallNavigationRef.current = false;
+            router.replace('/');
+        }
+    };
+
    const renderStage = () => {
        switch (stage) {
-            case 'name':
+            case 'avatar':
                return (
                    <Animated.View
-                        key="name"
+                        key="avatar"
                        entering={FadeInUp.duration(500)}
                        exiting={SlideOutLeft.duration(300)}
                        style={styles.stageContainer}
@@ -206,12 +265,72 @@ export default function OnboardingScreen() {
                            </LinearGradient>
                            <Text style={styles.title}>Welcome to Sauci</Text>
                            <Text style={styles.subtitle}>
-                                Let's get to know you
+                                Add a profile photo so your partner knows it's you
+                            </Text>
+                        </View>
+
+                        <GlassCard style={styles.card}>
+                            <View style={styles.avatarSection}>
+                                <Pressable onPress={handleAvatarPress} style={styles.avatarTouchable}>
+                                    {avatarUri ? (
+                                        <Image source={{ uri: avatarUri }} style={styles.avatarImage} />
+                                    ) : (
+                                        <View
+                                            style={styles.avatarPlaceholder}
+                                        >
+                                            <Ionicons name="camera" size={40} color={colors.textSecondary} />
+                                        </View>
+                                    )}
+                                    <View style={styles.avatarBadge}>
+                                        <Ionicons name={avatarUri ? "pencil" : "add"} size={16} color={colors.text} />
+                                    </View>
+                                </Pressable>
+                                <Text style={styles.avatarHint}>
+                                    {avatarUri ? 'Tap to change photo' : 'Tap to add a photo'}
+                                </Text>
+                            </View>
+                            {error && (
+                                <View style={styles.errorContainer}>
+                                    <Ionicons name="alert-circle" size={16} color={colors.error} />
+                                    <Text style={styles.errorText}>{error}</Text>
+                                </View>
+                            )}
+                        </GlassCard>
+
+                        <View style={styles.footer}>
+                            <GlassButton onPress={handleAvatarContinue} fullWidth size="lg">
+                                Continue
+                            </GlassButton>
+                        </View>
+                    </Animated.View>
+                );
+
+            case 'name':
+                return (
+                    <Animated.View
+                        key="name"
+                        entering={SlideInRight.duration(400)}
+                        exiting={SlideOutLeft.duration(300)}
+                        style={styles.stageContainer}
+                    >
+                        <View style={styles.header}>
+                            {avatarUri ? (
+                                <Image source={{ uri: avatarUri }} style={styles.headerAvatar} />
+                            ) : (
+                                <LinearGradient
+                                    colors={gradients.primary as [string, string]}
+                                    style={styles.iconContainer}
+                                >
+                                    <Ionicons name="person" size={40} color={colors.text} />
+                                </LinearGradient>
+                            )}
+                            <Text style={styles.title}>What can we call you?</Text>
+                            <Text style={styles.subtitle}>
+                                Nicknames and pet names are welcome too!
                            </Text>
                        </View>

                        <GlassCard style={styles.card}>
-                            <Text style={styles.label}>What's your name?</Text>
                            <View style={styles.inputContainer}>
                                <Ionicons
                                    name="person-outline"
@@ -224,7 +343,7 @@ export default function OnboardingScreen() {
                                    style={styles.input}
                                    value={name}
                                    onChangeText={setName}
-                                    placeholder="Enter your name"
+                                    placeholder="Your name or nickname"
                                    placeholderTextColor={colors.textTertiary}
                                    autoCapitalize="words"
                                    autoCorrect={false}
@@ -383,10 +502,10 @@ export default function OnboardingScreen() {
                    </Animated.View>
                );

-            case 'explicit':
+            case 'content':
                return (
                    <Animated.View
-                        key="explicit"
+                        key="content"
                        entering={SlideInRight.duration(400)}
                        exiting={FadeOut.duration(200)}
                        style={styles.stageContainer}
@@ -396,22 +515,40 @@ export default function OnboardingScreen() {
                                colors={gradients.primary as [string, string]}
                                style={styles.iconContainer}
                            >
-                                <Ionicons name="heart-circle" size={44} color={colors.text} />
+                                <Ionicons name="flame" size={44} color={colors.text} />
                            </LinearGradient>
-                            <Text style={styles.title}>Set Your Comfort Zone</Text>
+                            <Text style={styles.title}>Content Preferences</Text>
                            <Text style={styles.subtitle}>
-                                Choose the intimacy level you're comfortable with
+                                Choose what type of content you'd like to see
                            </Text>
                        </View>

                        <GlassCard style={styles.card}>
-                            <IntensitySlider
-                                value={maxIntensity}
-                                onValueChange={setMaxIntensity}
-                            />
-                            <Text style={styles.intensityNote}>
-                                Start where you're comfortable — you can always adjust later
+                            <View style={styles.contentToggleRow}>
+                                <View style={styles.contentToggleLeft}>
+                                    <LinearGradient
+                                        colors={gradients.primary as [string, string]}
+                                        style={styles.contentToggleIcon}
+                                    >
+                                        <Ionicons name="eye-off" size={24} color={colors.text} />
+                                    </LinearGradient>
+                                    <View style={styles.contentToggleText}>
+                                        <Text style={styles.contentToggleLabel}>Hide Adult Content</Text>
+                                        <Text style={styles.contentToggleDescription}>
+                                            Only show mild, family-friendly question packs
                                        </Text>
+                                    </View>
+                                </View>
+                                <GlassToggle
+                                    value={hideNsfw}
+                                    onValueChange={setHideNsfw}
+                                />
+                            </View>
+
+                            <Text style={styles.contentNote}>
+                                You can change this anytime in settings
+                            </Text>
+
                            {error && (
                                <View style={styles.errorContainer}>
                                    <Ionicons name="alert-circle" size={16} color={colors.error} />
@@ -422,7 +559,7 @@ export default function OnboardingScreen() {

                        <View style={styles.footer}>
                            <GlassButton
-                                onPress={handleIntensityContinue}
+                                onPress={handleContentContinue}
                                fullWidth
                                size="lg"
                            >
@@ -515,14 +652,16 @@ export default function OnboardingScreen() {
            >
                {/* Header with back button and progress dots */}
                <Animated.View entering={FadeIn.duration(600)} style={styles.headerBar}>
-                    {stage !== 'name' ? (
+                    {stage !== 'avatar' ? (
                        <Pressable
                            style={styles.backButton}
                            onPress={() => {
-                                if (stage === 'notifications') setStage('explicit');
-                                else if (stage === 'explicit') setStage('purpose');
+                                setError(null);
+                                if (stage === 'notifications') setStage('content');
+                                else if (stage === 'content') setStage('purpose');
                                else if (stage === 'purpose') setStage('gender');
-                                else setStage('name');
+                                else if (stage === 'gender') setStage('name');
+                                else if (stage === 'name') setStage('avatar');
                            }}
                        >
                            <Ionicons name="chevron-back" size={24} color={colors.text} />
@@ -531,10 +670,11 @@ export default function OnboardingScreen() {
                        <View style={styles.backButtonPlaceholder} />
                    )}
                    <View style={styles.progressContainer}>
+                        <View style={[styles.progressDot, stage === 'avatar' && styles.progressDotActive]} />
                        <View style={[styles.progressDot, stage === 'name' && styles.progressDotActive]} />
                        <View style={[styles.progressDot, stage === 'gender' && styles.progressDotActive]} />
                        <View style={[styles.progressDot, stage === 'purpose' && styles.progressDotActive]} />
-                        <View style={[styles.progressDot, stage === 'explicit' && styles.progressDotActive]} />
+                        <View style={[styles.progressDot, stage === 'content' && styles.progressDotActive]} />
                        <View style={[styles.progressDot, stage === 'notifications' && styles.progressDotActive]} />
                    </View>
                    <View style={styles.backButtonPlaceholder} />
@@ -548,6 +688,12 @@ export default function OnboardingScreen() {
                    {renderStage()}
                </ScrollView>
            </KeyboardAvoidingView>
+
+            <Paywall
+                visible={showPaywall}
+                onClose={handlePaywallClose}
+                offeringId={ONBOARDING_OFFERING_ID}
+            />
        </GradientBackground>
    );
 }
@@ -571,9 +717,92 @@ const styles = StyleSheet.create({
        width: 40,
        height: 40,
        borderRadius: 20,
-        backgroundColor: colors.glass.background,
+        backgroundColor: colors.backgroundLight,
        alignItems: 'center',
        justifyContent: 'center',
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+    // ...
+    progressDot: {
+        width: 8,
+        height: 8,
+        borderRadius: 4,
+        backgroundColor: colors.border,
+    },
+    // ...
+    avatarPlaceholder: {
+        width: 120,
+        height: 120,
+        borderRadius: 60,
+        alignItems: 'center',
+        justifyContent: 'center',
+        borderWidth: 2,
+        borderColor: colors.border,
+        borderStyle: 'dashed',
+        backgroundColor: colors.backgroundLight,
+    },
+    // ...
+    inputContainer: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        backgroundColor: colors.background, // Flat background
+        borderRadius: radius.md,
+        borderWidth: 1,
+        borderColor: colors.border,
+        paddingHorizontal: spacing.md,
+    },
+    // ...
+    genderOption: {
+        width: '48%',
+        alignItems: 'center',
+        backgroundColor: colors.backgroundLight,
+        borderRadius: radius.lg,
+        borderWidth: 2,
+        borderColor: colors.border,
+        paddingVertical: spacing.lg,
+        paddingHorizontal: spacing.md,
+        gap: spacing.sm,
+    },
+    // ...
+    purposeOption: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        backgroundColor: colors.backgroundLight,
+        borderRadius: radius.lg,
+        borderWidth: 2,
+        borderColor: colors.border,
+        padding: spacing.md,
+    },
+    // ...
+    purposeIcon: {
+        width: 44,
+        height: 44,
+        borderRadius: 22,
+        backgroundColor: colors.background,
+        alignItems: 'center',
+        justifyContent: 'center',
+        marginRight: spacing.md,
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+    // ...
+    radioOuter: {
+        width: 24,
+        height: 24,
+        borderRadius: 12,
+        borderWidth: 2,
+        borderColor: colors.border,
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    // ...
+    notificationFeature: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        paddingVertical: spacing.md,
+        borderBottomWidth: 1,
+        borderBottomColor: colors.border,
    },
    backButtonPlaceholder: {
        width: 40,
@@ -583,12 +812,7 @@ const styles = StyleSheet.create({
        justifyContent: 'center',
        gap: spacing.sm,
    },
-    progressDot: {
-        width: 8,
-        height: 8,
-        borderRadius: 4,
-        backgroundColor: colors.glass.border,
-    },
+
    progressDotActive: {
        backgroundColor: colors.primary,
        width: 24,
@@ -611,6 +835,47 @@ const styles = StyleSheet.create({
        marginBottom: spacing.lg,
        ...shadows.lg,
    },
+    headerAvatar: {
+        width: 80,
+        height: 80,
+        borderRadius: 40,
+        marginBottom: spacing.lg,
+        borderWidth: 2,
+        borderColor: colors.primary,
+    },
+    avatarSection: {
+        alignItems: 'center',
+        paddingVertical: spacing.lg,
+    },
+    avatarTouchable: {
+        position: 'relative',
+    },
+    avatarImage: {
+        width: 120,
+        height: 120,
+        borderRadius: 60,
+        borderWidth: 3,
+        borderColor: colors.primary,
+    },
+
+    avatarBadge: {
+        position: 'absolute',
+        bottom: 4,
+        right: 4,
+        width: 32,
+        height: 32,
+        borderRadius: 16,
+        backgroundColor: colors.primary,
+        alignItems: 'center',
+        justifyContent: 'center',
+        borderWidth: 2,
+        borderColor: colors.background,
+    },
+    avatarHint: {
+        ...typography.caption1,
+        color: colors.textSecondary,
+        marginTop: spacing.md,
+    },
    title: {
        ...typography.largeTitle,
        color: colors.text,
@@ -636,15 +901,7 @@ const styles = StyleSheet.create({
        color: colors.text,
        marginBottom: spacing.md,
    },
-    inputContainer: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        backgroundColor: colors.glass.background,
-        borderRadius: radius.md,
-        borderWidth: 1,
-        borderColor: colors.glass.border,
-        paddingHorizontal: spacing.md,
-    },
+
    inputIcon: {
        marginRight: spacing.sm,
    },
@@ -659,17 +916,7 @@ const styles = StyleSheet.create({
        flexWrap: 'wrap',
        gap: spacing.sm,
    },
-    genderOption: {
-        width: '48%',
-        alignItems: 'center',
-        backgroundColor: colors.glass.background,
-        borderRadius: radius.lg,
-        borderWidth: 2,
-        borderColor: colors.glass.border,
-        paddingVertical: spacing.lg,
-        paddingHorizontal: spacing.md,
-        gap: spacing.sm,
-    },
+
    genderOptionSelected: {
        borderColor: colors.primary,
        backgroundColor: colors.primaryLight,
@@ -686,28 +933,12 @@ const styles = StyleSheet.create({
    purposeList: {
        gap: spacing.sm,
    },
-    purposeOption: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        backgroundColor: colors.glass.background,
-        borderRadius: radius.lg,
-        borderWidth: 2,
-        borderColor: colors.glass.border,
-        padding: spacing.md,
-    },
+
    purposeOptionSelected: {
        borderColor: colors.primary,
        backgroundColor: colors.primaryLight,
    },
-    purposeIcon: {
-        width: 44,
-        height: 44,
-        borderRadius: 22,
-        backgroundColor: colors.glass.background,
-        alignItems: 'center',
-        justifyContent: 'center',
-        marginRight: spacing.md,
-    },
+
    purposeIconSelected: {
        backgroundColor: colors.primaryLight,
    },
@@ -720,21 +951,44 @@ const styles = StyleSheet.create({
        color: colors.text,
        fontWeight: '600',
    },
-    intensityNote: {
+    contentToggleRow: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+    },
+    contentToggleLeft: {
+        flex: 1,
+        flexDirection: 'row',
+        alignItems: 'center',
+        marginRight: spacing.md,
+    },
+    contentToggleIcon: {
+        width: 48,
+        height: 48,
+        borderRadius: 24,
+        alignItems: 'center',
+        justifyContent: 'center',
+        marginRight: spacing.md,
+    },
+    contentToggleText: {
+        flex: 1,
+    },
+    contentToggleLabel: {
+        ...typography.headline,
+        color: colors.text,
+    },
+    contentToggleDescription: {
+        ...typography.caption1,
+        color: colors.textSecondary,
+        marginTop: 2,
+    },
+    contentNote: {
        ...typography.caption1,
        color: colors.textSecondary,
        textAlign: 'center',
-        marginTop: spacing.md,
-    },
-    radioOuter: {
-        width: 24,
-        height: 24,
-        borderRadius: 12,
-        borderWidth: 2,
-        borderColor: colors.glass.border,
-        alignItems: 'center',
-        justifyContent: 'center',
+        marginTop: spacing.lg,
    },
+
    radioOuterSelected: {
        borderColor: colors.primary,
    },
@@ -761,13 +1015,7 @@ const styles = StyleSheet.create({
    footer: {
        marginTop: 'auto',
    },
-    notificationFeature: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        paddingVertical: spacing.md,
-        borderBottomWidth: 1,
-        borderBottomColor: colors.glass.border,
-    },
+
    notificationFeatureLast: {
        borderBottomWidth: 0,
    },
@@ -1,15 +0,0 @@
-import { Stack } from "expo-router";
-import { colors } from "../../../src/theme";
-
-export default function PacksLayout() {
-    return (
-        <Stack
-            screenOptions={{
-                headerShown: false,
-                contentStyle: { backgroundColor: colors.background },
-                animation: "fade",
-                animationDuration: 150,
-            }}
-        />
-    );
-}
@@ -1,298 +0,0 @@
-import { View, Text, StyleSheet, Pressable, Platform } from "react-native";
-import { Ionicons } from "@expo/vector-icons";
-import { router } from "expo-router";
-import { useEffect } from "react";
-import Animated, { FadeInDown } from "react-native-reanimated";
-import { LinearGradient } from "expo-linear-gradient";
-import { GradientBackground } from "../../../src/components/ui";
-import { usePacksStore } from "../../../src/store";
-import { colors, spacing, radius, typography, shadows } from "../../../src/theme";
-
-interface PackTypeCard {
-    id: string;
-    title: string;
-    description: string;
-    icon: keyof typeof Ionicons.glyphMap;
-    color: string;
-    colorRgba: string;
-    gradient: [string, string];
-    comingSoon: boolean;
-    route?: string;
-}
-
-const PACK_TYPES: PackTypeCard[] = [
-    {
-        id: "questions",
-        title: "Question Packs",
-        description: "Explore intimate questions together and discover what you both want",
-        icon: "layers",
-        color: colors.primary,
-        colorRgba: "rgba(233, 69, 96, ",
-        gradient: ["rgba(233, 69, 96, 0.25)", "rgba(155, 89, 182, 0.25)"],
-        comingSoon: false,
-        route: "/(app)/packs/questions",
-    },
-    {
-        id: "dares",
-        title: "Dare Packs",
-        description: "Spice things up with exciting dares for adventurous couples",
-        icon: "flash",
-        color: colors.premium.gold,
-        colorRgba: "rgba(212, 175, 55, ",
-        gradient: ["rgba(212, 175, 55, 0.25)", "rgba(184, 134, 11, 0.25)"],
-        comingSoon: true,
-        route: "/(app)/dares",
-    },
-    {
-        id: "quiz",
-        title: "Quiz Packs",
-        description: "Test how well you know each other with fun couple quizzes",
-        icon: "help-circle",
-        color: colors.premium.rose,
-        colorRgba: "rgba(232, 164, 174, ",
-        gradient: ["rgba(232, 164, 174, 0.25)", "rgba(212, 145, 155, 0.25)"],
-        comingSoon: true,
-        route: "/(app)/quiz",
-    },
-];
-
-export default function PackTypeSelection() {
-    const { fetchPacks } = usePacksStore();
-
-    // Prefetch packs data so it's ready when navigating to questions
-    useEffect(() => {
-        fetchPacks();
-    }, []);
-
-    const handlePackTypePress = (packType: PackTypeCard) => {
-        if (packType.route) {
-            router.push(packType.route as any);
-        }
-    };
-
-    return (
-        <GradientBackground>
-            <View style={styles.container}>
-                {/* Header */}
-                <Animated.View
-                    entering={FadeInDown.duration(600).springify()}
-                    style={styles.header}
-                >
-                    <Text style={styles.label}>EXPLORE</Text>
-                    <Text style={styles.title}>Content Packs</Text>
-
-                    {/* Decorative Separator */}
-                    <View style={styles.separator}>
-                        <View style={styles.separatorLine} />
-                        <View style={styles.separatorDiamond} />
-                        <View style={styles.separatorLine} />
-                    </View>
-
-                    <Text style={styles.subtitle}>
-                        Choose a pack type to explore
-                    </Text>
-                </Animated.View>
-
-                {/* Pack Type Cards */}
-                <View style={styles.cardsContainer}>
-                    {PACK_TYPES.map((packType, index) => (
-                        <Animated.View
-                            key={packType.id}
-                            entering={FadeInDown.delay(100 + index * 100).duration(500).springify()}
-                        >
-                            <Pressable
-                                onPress={() => handlePackTypePress(packType)}
-                                style={({ pressed }) => [
-                                    styles.card,
-                                    pressed && !packType.comingSoon && styles.cardPressed,
-                                    packType.comingSoon && styles.cardDisabled,
-                                ]}
-                            >
-                                <LinearGradient
-                                    colors={packType.gradient as [string, string]}
-                                    start={{ x: 0, y: 0 }}
-                                    end={{ x: 1, y: 1 }}
-                                    style={styles.cardGradient}
-                                >
-                                    {/* Icon Circle */}
-                                    <View
-                                        style={[
-                                            styles.iconCircle,
-                                            {
-                                                backgroundColor: `${packType.colorRgba}0.15)`,
-                                                borderColor: `${packType.colorRgba}0.3)`,
-                                            },
-                                        ]}
-                                    >
-                                        <Ionicons
-                                            name={packType.icon}
-                                            size={32}
-                                            color={packType.comingSoon ? colors.textTertiary : packType.color}
-                                        />
-                                    </View>
-
-                                    {/* Content */}
-                                    <View style={styles.cardContent}>
-                                        <View style={styles.cardTitleRow}>
-                                            <Text
-                                                style={[
-                                                    styles.cardTitle,
-                                                    packType.comingSoon && styles.cardTitleDisabled,
-                                                ]}
-                                            >
-                                                {packType.title}
-                                            </Text>
-                                            {packType.comingSoon && (
-                                                <View style={styles.comingSoonBadge}>
-                                                    <Text style={styles.comingSoonText}>Coming Soon</Text>
-                                                </View>
-                                            )}
-                                        </View>
-                                        <Text
-                                            style={[
-                                                styles.cardDescription,
-                                                packType.comingSoon && styles.cardDescriptionDisabled,
-                                            ]}
-                                        >
-                                            {packType.description}
-                                        </Text>
-                                    </View>
-
-                                    {/* Arrow */}
-                                    {!packType.comingSoon && (
-                                        <Ionicons
-                                            name="chevron-forward"
-                                            size={24}
-                                            color={colors.textSecondary}
-                                        />
-                                    )}
-                                </LinearGradient>
-                            </Pressable>
-                        </Animated.View>
-                    ))}
-                </View>
-            </View>
-        </GradientBackground>
-    );
-}
-
-const styles = StyleSheet.create({
-    container: {
-        flex: 1,
-    },
-    header: {
-        paddingTop: 60,
-        paddingHorizontal: spacing.lg,
-        paddingBottom: spacing.lg,
-        alignItems: "center",
-    },
-    label: {
-        ...typography.caption1,
-        fontWeight: "600",
-        letterSpacing: 3,
-        color: colors.primary,
-        textAlign: "center",
-        marginBottom: spacing.xs,
-    },
-    title: {
-        ...typography.title1,
-        color: colors.text,
-        textAlign: "center",
-    },
-    separator: {
-        flexDirection: "row",
-        alignItems: "center",
-        justifyContent: "center",
-        marginVertical: spacing.md,
-        width: 140,
-    },
-    separatorLine: {
-        flex: 1,
-        height: 1,
-        backgroundColor: "rgba(233, 69, 96, 0.3)",
-    },
-    separatorDiamond: {
-        width: 6,
-        height: 6,
-        backgroundColor: colors.primary,
-        transform: [{ rotate: "45deg" }],
-        marginHorizontal: spacing.md,
-        opacity: 0.6,
-    },
-    subtitle: {
-        ...typography.body,
-        color: colors.textSecondary,
-        textAlign: "center",
-    },
-    cardsContainer: {
-        paddingHorizontal: spacing.lg,
-        gap: spacing.md,
-    },
-    card: {
-        borderRadius: radius.lg,
-        overflow: "hidden",
-        borderWidth: 1,
-        borderColor: colors.glass.border,
-        ...shadows.md,
-    },
-    cardPressed: {
-        opacity: 0.9,
-        transform: [{ scale: 0.98 }],
-    },
-    cardDisabled: {
-        opacity: 0.6,
-    },
-    cardGradient: {
-        flexDirection: "row",
-        alignItems: "center",
-        padding: spacing.lg,
-        gap: spacing.md,
-    },
-    iconCircle: {
-        width: 64,
-        height: 64,
-        borderRadius: 32,
-        justifyContent: "center",
-        alignItems: "center",
-        borderWidth: 1,
-    },
-    cardContent: {
-        flex: 1,
-    },
-    cardTitleRow: {
-        flexDirection: "row",
-        alignItems: "center",
-        gap: spacing.sm,
-        marginBottom: spacing.xs,
-    },
-    cardTitle: {
-        ...typography.title3,
-        color: colors.text,
-    },
-    cardTitleDisabled: {
-        color: colors.textSecondary,
-    },
-    cardDescription: {
-        ...typography.subhead,
-        color: colors.textSecondary,
-        lineHeight: 20,
-    },
-    cardDescriptionDisabled: {
-        color: colors.textTertiary,
-    },
-    comingSoonBadge: {
-        backgroundColor: "rgba(255, 255, 255, 0.1)",
-        paddingHorizontal: spacing.sm,
-        paddingVertical: 2,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: "rgba(255, 255, 255, 0.15)",
-    },
-    comingSoonText: {
-        ...typography.caption2,
-        color: colors.textTertiary,
-        fontWeight: "500",
-        textTransform: "uppercase",
-        letterSpacing: 0.5,
-    },
-});
@@ -1,815 +0,0 @@
-import { View, Text, StyleSheet, RefreshControl, Platform, Alert, Pressable } from "react-native";
-import { usePacksStore, useAuthStore, useSubscriptionStore } from "../../../src/store";
-import { Ionicons } from "@expo/vector-icons";
-import { router } from "expo-router";
-import { useMemo, useState, useCallback } from "react";
-import Animated, {
-    FadeIn,
-    FadeOut,
-    useAnimatedStyle,
-    useSharedValue,
-    withTiming,
-    useAnimatedScrollHandler,
-    interpolate,
-    Extrapolation,
-} from "react-native-reanimated";
-import { BlurView } from "expo-blur";
-import { GradientBackground } from "../../../src/components/ui";
-import { Paywall } from "../../../src/components/paywall";
-import { PackTeaser } from "../../../src/components/PackTeaser";
-import { colors, spacing, radius, typography } from "../../../src/theme";
-import { getPackIconName } from "../../../src/lib/packIcons";
-import type { QuestionPack, Category } from "../../../src/types";
-
-const HEADER_MAX_HEIGHT = 180;
-const HEADER_MIN_HEIGHT = 100;
-const HEADER_SCROLL_DISTANCE = HEADER_MAX_HEIGHT - HEADER_MIN_HEIGHT;
-
-const INTENSITY_LABELS: Record<number, string> = {
-    1: "Light",
-    2: "Mild",
-    3: "Moderate",
-    4: "Spicy",
-    5: "Intense",
-};
-
-const clampIntensity = (value: number) => Math.min(5, Math.max(1, Math.round(value)));
-
-const isValidIntensity = (value?: number | null): value is number =>
-    typeof value === "number" && value >= 1 && value <= 5;
-
-const getIntensityDisplay = (pack: QuestionPack) => {
-    const min = isValidIntensity(pack.min_intensity) ? pack.min_intensity : null;
-    const max = isValidIntensity(pack.max_intensity) ? pack.max_intensity : null;
-    const avg = typeof pack.avg_intensity === "number" ? clampIntensity(pack.avg_intensity) : null;
-    const fallback = avg ?? (pack.is_explicit ? 5 : 2);
-
-    const minCount = min ?? max ?? fallback;
-    const maxCount = max ?? min ?? fallback;
-    const label = minCount === maxCount
-        ? INTENSITY_LABELS[minCount]
-        : `${INTENSITY_LABELS[minCount]} - ${INTENSITY_LABELS[maxCount]}`;
-
-    return { minCount, maxCount, label };
-};
-
-
-interface PackRowProps {
-    pack: QuestionPack;
-    isEnabled: boolean;
-    isPremiumLocked: boolean;
-    isExpanded: boolean;
-    onToggle: () => void;
-    onPress: () => void;
-    onInfoPress: () => void;
-}
-
-function PackRow({ pack, isEnabled, isPremiumLocked, isExpanded, onToggle, onPress, onInfoPress }: PackRowProps) {
-    const questionCount = pack.questions?.[0]?.count || 0;
-    const intensityDisplay = getIntensityDisplay(pack);
-
-
-    return (
-        <Pressable onPress={onPress} style={styles.packRow}>
-            <View style={styles.packRowMain}>
-                <View style={[styles.packIcon, isEnabled && styles.packIconEnabled]}>
-                    <Ionicons
-                        name={getPackIconName(pack.icon)}
-                        size={20}
-                        color={isEnabled ? colors.primary : colors.textSecondary}
-                    />
-                </View>
-
-                <View style={styles.packContent}>
-                    <View style={styles.packTitleRow}>
-                        <Text style={styles.packName} numberOfLines={1}>{pack.name}</Text>
-                        {pack.is_premium && (
-                            <View style={[styles.premiumBadge, isPremiumLocked && styles.premiumBadgeLocked]}>
-                                <Ionicons
-                                    name={isPremiumLocked ? "lock-closed" : "sparkles"}
-                                    size={12}
-                                    color={colors.premium.gold}
-                                />
-                                <Text style={styles.premiumBadgeText}>PRO</Text>
-                            </View>
-                        )}
-                    </View>
-                    <Text style={styles.packMeta}>
-                        {questionCount} {questionCount === 1 ? "question" : "questions"}
-                        {isEnabled && <Text style={styles.packMetaEnabled}> · Enabled</Text>}
-                    </Text>
-                    <View style={styles.packIntensityRow}>
-                        <View style={styles.packIntensityFlames}>
-                            {Array.from({ length: 5 }).map((_, index) => {
-                                const level = index + 1;
-                                const isInRange = level >= intensityDisplay.minCount && level <= intensityDisplay.maxCount;
-
-                                return (
-                                    <Ionicons
-                                        key={`intensity-${pack.id}-${index}`}
-                                        name={isInRange ? "flame" : "flame-outline"}
-                                        size={12}
-                                        color={isInRange ? colors.primary : colors.textTertiary}
-                                    />
-                                );
-                            })}
-                        </View>
-                        <Text style={styles.packIntensityText}>{intensityDisplay.label}</Text>
-                    </View>
-                </View>
-
-
-                <Ionicons
-                    name={isExpanded ? "chevron-up" : "chevron-down"}
-                    size={20}
-                    color={colors.textTertiary}
-                />
-            </View>
-
-            {isExpanded && (
-                <Animated.View
-                    entering={FadeIn.duration(200)}
-                    exiting={FadeOut.duration(150)}
-                    style={styles.packExpanded}
-                >
-                    {pack.description && (
-                        <Text style={styles.packDescription}>{pack.description}</Text>
-                    )}
-                    <View style={styles.packActions}>
-                        <Pressable style={styles.packInfoButton} onPress={onInfoPress}>
-                            <Ionicons name="eye-outline" size={18} color={colors.textSecondary} />
-                            <Text style={styles.packInfoButtonText}>Preview</Text>
-                        </Pressable>
-
-                        <Pressable
-                            style={[
-                                styles.packToggleButton,
-                                isEnabled && styles.packToggleButtonEnabled,
-                                isPremiumLocked && styles.packToggleButtonLocked,
-                            ]}
-                            onPress={onToggle}
-                        >
-                            {isPremiumLocked ? (
-                                <>
-                                    <Ionicons name="lock-closed" size={16} color={colors.premium.gold} />
-                                    <Text style={[styles.packToggleButtonText, styles.packToggleButtonTextLocked]}>
-                                        Unlock
-                                    </Text>
-                                </>
-                            ) : isEnabled ? (
-                                <>
-                                    <Ionicons name="checkmark" size={16} color={colors.primary} />
-                                    <Text style={[styles.packToggleButtonText, styles.packToggleButtonTextEnabled]}>
-                                        Enabled
-                                    </Text>
-                                </>
-                            ) : (
-                                <>
-                                    <Ionicons name="add" size={16} color={colors.text} />
-                                    <Text style={styles.packToggleButtonText}>Enable</Text>
-                                </>
-                            )}
-                        </Pressable>
-                    </View>
-                </Animated.View>
-            )}
-        </Pressable>
-    );
-}
-
-interface CategorySectionProps {
-    category: Category;
-    packs: QuestionPack[];
-    enabledPackIds: string[];
-    hasPremiumAccess: boolean;
-    expandedPackId: string | null;
-    onPackPress: (packId: string) => void;
-    onPackToggle: (pack: QuestionPack) => void;
-    onPackInfo: (pack: QuestionPack) => void;
-}
-
-function CategorySection({
-    category,
-    packs,
-    enabledPackIds,
-    hasPremiumAccess,
-    expandedPackId,
-    onPackPress,
-    onPackToggle,
-    onPackInfo,
-}: CategorySectionProps) {
-    const [isCollapsed, setIsCollapsed] = useState(false);
-    const enabledCount = packs.filter(p => enabledPackIds.includes(p.id)).length;
-
-    const rotateAnim = useSharedValue(0);
-
-    const chevronStyle = useAnimatedStyle(() => ({
-        transform: [{ rotate: `${rotateAnim.value}deg` }],
-    }));
-
-    const handleToggleCollapse = () => {
-        rotateAnim.value = withTiming(isCollapsed ? 0 : -90, { duration: 200 });
-        setIsCollapsed(!isCollapsed);
-    };
-
-    return (
-        <View style={styles.categorySection}>
-            <Pressable style={styles.categoryHeader} onPress={handleToggleCollapse}>
-                <View style={styles.categoryHeaderLeft}>
-                    <Ionicons
-                        name={getPackIconName(category.icon)}
-                        size={16}
-                        color={colors.textSecondary}
-                    />
-                    <Text style={styles.categoryName}>{category.name}</Text>
-                    {enabledCount > 0 && (
-                        <View style={styles.categoryBadge}>
-                            <Text style={styles.categoryBadgeText}>{enabledCount}</Text>
-                        </View>
-                    )}
-                </View>
-                <Animated.View style={chevronStyle}>
-                    <Ionicons name="chevron-down" size={20} color={colors.textSecondary} />
-                </Animated.View>
-            </Pressable>
-
-            {!isCollapsed && (
-                <Animated.View
-                    entering={FadeIn.duration(200)}
-                    exiting={FadeOut.duration(150)}
-                    style={styles.packsList}
-                >
-                    {packs.map((pack) => (
-                        <PackRow
-                            key={pack.id}
-                            pack={pack}
-                            isEnabled={enabledPackIds.includes(pack.id)}
-                            isPremiumLocked={pack.is_premium && !hasPremiumAccess}
-                            isExpanded={expandedPackId === pack.id}
-                            onPress={() => onPackPress(pack.id)}
-                            onToggle={() => onPackToggle(pack)}
-                            onInfoPress={() => onPackInfo(pack)}
-                        />
-                    ))}
-                </Animated.View>
-            )}
-        </View>
-    );
-}
-
-export default function QuestionPacksScreen() {
-    const { packs, categories, enabledPackIds, togglePack, isLoading, fetchPacks } = usePacksStore();
-    const { user, partner } = useAuthStore();
-    const { subscription } = useSubscriptionStore();
-
-    const [expandedPackId, setExpandedPackId] = useState<string | null>(null);
-    const [showPaywall, setShowPaywall] = useState(false);
-    const [showTeaser, setShowTeaser] = useState(false);
-    const [teaserPack, setTeaserPack] = useState<QuestionPack | null>(null);
-
-    const scrollY = useSharedValue(0);
-
-    const scrollHandler = useAnimatedScrollHandler({
-        onScroll: (event) => {
-            scrollY.value = event.contentOffset.y;
-        },
-    });
-
-    const hasPremiumAccess = useMemo(() => {
-        return user?.is_premium || partner?.is_premium || subscription.isProUser;
-    }, [user?.is_premium, partner?.is_premium, subscription.isProUser]);
-
-    const packsByCategory = useMemo(() => {
-        const grouped = new Map<string, QuestionPack[]>();
-        categories.forEach(cat => grouped.set(cat.id, []));
-        grouped.set("uncategorized", []);
-        packs.forEach(pack => {
-            const catId = pack.category_id || "uncategorized";
-            const existing = grouped.get(catId) || [];
-            existing.push(pack);
-            grouped.set(catId, existing);
-        });
-        return grouped;
-    }, [packs, categories]);
-
-    const handlePackPress = useCallback((packId: string) => {
-        setExpandedPackId(current => current === packId ? null : packId);
-    }, []);
-
-    const handlePackToggle = useCallback(async (pack: QuestionPack) => {
-        if (pack.is_premium && !hasPremiumAccess) {
-            setTeaserPack(pack);
-            setShowTeaser(true);
-            return;
-        }
-        const result = await togglePack(pack.id);
-        if (!result.success && result.reason === "no_couple") {
-            Alert.alert(
-                "Pair with Partner",
-                "You need to pair with your partner before you can customise question packs.",
-                [
-                    { text: "Later", style: "cancel" },
-                    { text: "Pair Now", onPress: () => router.push("/pairing") }
-                ]
-            );
-        }
-    }, [hasPremiumAccess, togglePack]);
-
-    const handlePackInfo = useCallback((pack: QuestionPack) => {
-        const isPremiumLocked = pack.is_premium && !hasPremiumAccess;
-        if (isPremiumLocked) {
-            setTeaserPack(pack);
-            setShowTeaser(true);
-        } else {
-            router.push(`/pack/${pack.id}`);
-        }
-    }, [hasPremiumAccess]);
-
-    const handleTeaserUnlock = useCallback(() => {
-        setShowTeaser(false);
-        setShowPaywall(true);
-    }, []);
-
-    const handleTeaserClose = useCallback(() => {
-        setShowTeaser(false);
-        setTeaserPack(null);
-    }, []);
-
-    const enabledPackCount = enabledPackIds.length;
-    const totalQuestions = packs
-        .filter(p => enabledPackIds.includes(p.id))
-        .reduce((sum, p) => sum + (p.questions?.[0]?.count || 0), 0);
-
-    // Animated styles for collapsing header
-    const largeHeaderStyle = useAnimatedStyle(() => {
-        const opacity = interpolate(
-            scrollY.value,
-            [0, HEADER_SCROLL_DISTANCE * 0.5],
-            [1, 0],
-            Extrapolation.CLAMP
-        );
-        const translateY = interpolate(
-            scrollY.value,
-            [0, HEADER_SCROLL_DISTANCE],
-            [0, -20],
-            Extrapolation.CLAMP
-        );
-        return { opacity, transform: [{ translateY }] };
-    });
-
-    const compactHeaderStyle = useAnimatedStyle(() => {
-        const opacity = interpolate(
-            scrollY.value,
-            [HEADER_SCROLL_DISTANCE * 0.5, HEADER_SCROLL_DISTANCE],
-            [0, 1],
-            Extrapolation.CLAMP
-        );
-        return { opacity };
-    });
-
-    const navBarBackgroundStyle = useAnimatedStyle(() => {
-        const opacity = interpolate(
-            scrollY.value,
-            [0, HEADER_SCROLL_DISTANCE * 0.8],
-            [0, 1],
-            Extrapolation.CLAMP
-        );
-        return { opacity };
-    });
-
-    return (
-        <GradientBackground>
-            <View style={styles.container}>
-                {/* Fixed Nav Bar */}
-                <View style={styles.navBar}>
-                    {/* Nav bar background with blur */}
-                    <Animated.View style={[styles.navBarBackground, navBarBackgroundStyle]}>
-                        {Platform.OS === "ios" ? (
-                            <BlurView intensity={80} tint="dark" style={StyleSheet.absoluteFill} />
-                        ) : (
-                            <View style={[StyleSheet.absoluteFill, { backgroundColor: "rgba(13, 13, 26, 0.95)" }]} />
-                        )}
-                    </Animated.View>
-
-                    {/* Back button */}
-                    <Pressable
-                        style={styles.backButton}
-                        onPress={() => router.back()}
-                        hitSlop={8}
-                    >
-                        <Ionicons name="chevron-back" size={24} color={colors.text} />
-                    </Pressable>
-
-                    {/* Compact title (fades in on scroll) */}
-                    <Animated.Text style={[styles.navBarTitle, compactHeaderStyle]}>
-                        Question Packs
-                    </Animated.Text>
-
-                    {/* Spacer for alignment */}
-                    <View style={styles.navBarSpacer} />
-                </View>
-
-                {/* Scrollable Content */}
-                <Animated.ScrollView
-                    showsVerticalScrollIndicator={false}
-                    onScroll={scrollHandler}
-                    scrollEventThrottle={16}
-                    refreshControl={
-                        <RefreshControl
-                            refreshing={isLoading}
-                            onRefresh={fetchPacks}
-                            tintColor={colors.primary}
-                            colors={[colors.primary]}
-                            progressViewOffset={HEADER_MAX_HEIGHT}
-                        />
-                    }
-                    contentContainerStyle={styles.scrollContent}
-                >
-                    {/* Large Header (fades out on scroll) */}
-                    <Animated.View style={[styles.largeHeader, largeHeaderStyle]}>
-                        <Text style={styles.label}>COLLECTION</Text>
-                        <Text style={styles.title}>Question Packs</Text>
-
-                        <View style={styles.separator}>
-                            <View style={styles.separatorLine} />
-                            <View style={styles.separatorDiamond} />
-                            <View style={styles.separatorLine} />
-                        </View>
-
-                        <View style={styles.statsBadge}>
-                            <Ionicons name="checkmark-circle" size={14} color={colors.primary} />
-                            <Text style={styles.statsBadgeText}>
-                                {totalQuestions} {totalQuestions === 1 ? "question" : "questions"} from {enabledPackCount} {enabledPackCount === 1 ? "pack" : "packs"}
-                            </Text>
-                        </View>
-                    </Animated.View>
-
-                    {/* Categories */}
-                    <View style={styles.categoriesContainer}>
-                        {categories.map(category => {
-                            const categoryPacks = packsByCategory.get(category.id) || [];
-                            if (categoryPacks.length === 0) return null;
-
-                            return (
-                                <CategorySection
-                                    key={category.id}
-                                    category={category}
-                                    packs={categoryPacks}
-                                    enabledPackIds={enabledPackIds}
-                                    hasPremiumAccess={hasPremiumAccess}
-                                    expandedPackId={expandedPackId}
-                                    onPackPress={handlePackPress}
-                                    onPackToggle={handlePackToggle}
-                                    onPackInfo={handlePackInfo}
-                                />
-                            );
-                        })}
-
-                        {(packsByCategory.get("uncategorized")?.length || 0) > 0 && (
-                            <CategorySection
-                                category={{
-                                    id: "uncategorized",
-                                    name: "Other",
-                                    description: null,
-                                    icon: "📁",
-                                    sort_order: 999,
-                                    created_at: "",
-                                    is_public: true
-                                }}
-                                packs={packsByCategory.get("uncategorized") || []}
-                                enabledPackIds={enabledPackIds}
-                                hasPremiumAccess={hasPremiumAccess}
-                                expandedPackId={expandedPackId}
-                                onPackPress={handlePackPress}
-                                onPackToggle={handlePackToggle}
-                                onPackInfo={handlePackInfo}
-                            />
-                        )}
-                    </View>
-                </Animated.ScrollView>
-
-                {/* Modals */}
-                {teaserPack && (
-                    <PackTeaser
-                        visible={showTeaser}
-                        packId={teaserPack.id}
-                        packName={teaserPack.name}
-                        packIcon={teaserPack.icon}
-                        onClose={handleTeaserClose}
-                        onUnlock={handleTeaserUnlock}
-                    />
-                )}
-
-                <Paywall
-                    visible={showPaywall}
-                    onClose={() => setShowPaywall(false)}
-                    onSuccess={() => fetchPacks()}
-                />
-            </View>
-        </GradientBackground>
-    );
-}
-
-const NAV_BAR_HEIGHT = 44;
-const STATUS_BAR_HEIGHT = 60; // Match other pages
-
-const styles = StyleSheet.create({
-    container: {
-        flex: 1,
-    },
-
-    // Fixed Nav Bar
-    navBar: {
-        position: "absolute",
-        top: 0,
-        left: 0,
-        right: 0,
-        height: STATUS_BAR_HEIGHT + NAV_BAR_HEIGHT,
-        flexDirection: "row",
-        alignItems: "center",
-        paddingTop: STATUS_BAR_HEIGHT - 10,
-        paddingHorizontal: spacing.md,
-        zIndex: 100,
-    },
-    navBarBackground: {
-        ...StyleSheet.absoluteFillObject,
-        borderBottomWidth: 1,
-        borderBottomColor: "rgba(255, 255, 255, 0.1)",
-        overflow: "hidden",
-    },
-    backButton: {
-        width: 40,
-        height: 40,
-        borderRadius: 20,
-        backgroundColor: "rgba(255, 255, 255, 0.1)",
-        justifyContent: "center",
-        alignItems: "center",
-    },
-    navBarTitle: {
-        flex: 1,
-        ...typography.headline,
-        color: colors.text,
-        textAlign: "center",
-        marginRight: 40, // Balance with back button
-    },
-    navBarSpacer: {
-        width: 0,
-    },
-
-    // Large Header
-    largeHeader: {
-        alignItems: "center",
-        paddingBottom: spacing.lg,
-    },
-    label: {
-        ...typography.caption1,
-        fontWeight: "600",
-        letterSpacing: 3,
-        color: colors.primary,
-        textAlign: "center",
-        marginBottom: spacing.xs,
-    },
-    title: {
-        ...typography.title1,
-        color: colors.text,
-        textAlign: "center",
-    },
-    separator: {
-        flexDirection: "row",
-        alignItems: "center",
-        justifyContent: "center",
-        marginVertical: spacing.md,
-        width: 140,
-    },
-    separatorLine: {
-        flex: 1,
-        height: 1,
-        backgroundColor: "rgba(233, 69, 96, 0.3)",
-    },
-    separatorDiamond: {
-        width: 6,
-        height: 6,
-        backgroundColor: colors.primary,
-        transform: [{ rotate: "45deg" }],
-        marginHorizontal: spacing.md,
-        opacity: 0.6,
-    },
-    statsBadge: {
-        flexDirection: "row",
-        alignItems: "center",
-        backgroundColor: "rgba(233, 69, 96, 0.1)",
-        paddingHorizontal: spacing.md,
-        paddingVertical: spacing.sm,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: "rgba(233, 69, 96, 0.2)",
-        gap: spacing.sm,
-    },
-    statsBadgeText: {
-        ...typography.caption1,
-        color: colors.textSecondary,
-        fontWeight: "500",
-    },
-
-    // Scroll Content
-    scrollContent: {
-        paddingTop: 60, // Match other pages
-        paddingBottom: Platform.OS === "ios" ? 120 : 100,
-    },
-    categoriesContainer: {
-        paddingHorizontal: spacing.lg,
-    },
-
-    // Category Section
-    categorySection: {
-        marginBottom: spacing.lg,
-    },
-    categoryHeader: {
-        flexDirection: "row",
-        alignItems: "center",
-        justifyContent: "space-between",
-        paddingVertical: spacing.sm,
-        marginBottom: spacing.xs,
-    },
-    categoryHeaderLeft: {
-        flexDirection: "row",
-        alignItems: "center",
-        gap: spacing.sm,
-    },
-    categoryName: {
-        ...typography.headline,
-        color: colors.text,
-        textTransform: "uppercase",
-        letterSpacing: 1,
-        fontSize: 13,
-    },
-    categoryBadge: {
-        backgroundColor: colors.primary,
-        paddingHorizontal: 8,
-        paddingVertical: 2,
-        borderRadius: 10,
-        minWidth: 20,
-        alignItems: "center",
-    },
-    categoryBadgeText: {
-        ...typography.caption2,
-        color: colors.text,
-        fontWeight: "600",
-    },
-    packsList: {
-        backgroundColor: "rgba(255, 255, 255, 0.03)",
-        borderRadius: radius.lg,
-        borderWidth: 1,
-        borderColor: colors.glass.border,
-        overflow: "hidden",
-    },
-
-    // Pack Row
-    packRow: {
-        borderBottomWidth: 1,
-        borderBottomColor: colors.glass.border,
-    },
-    packRowMain: {
-        flexDirection: "row",
-        alignItems: "center",
-        padding: spacing.md,
-        gap: spacing.md,
-    },
-    packIcon: {
-        width: 44,
-        height: 44,
-        borderRadius: 12,
-        backgroundColor: "rgba(255, 255, 255, 0.05)",
-        justifyContent: "center",
-        alignItems: "center",
-        borderWidth: 1,
-        borderColor: "rgba(255, 255, 255, 0.08)",
-    },
-    packIconEnabled: {
-        backgroundColor: "rgba(233, 69, 96, 0.1)",
-        borderColor: "rgba(233, 69, 96, 0.2)",
-    },
-    packContent: {
-        flex: 1,
-    },
-    packTitleRow: {
-        flexDirection: "row",
-        alignItems: "center",
-        gap: spacing.xs,
-    },
-    packName: {
-        ...typography.body,
-        color: colors.text,
-        fontWeight: "500",
-        flexShrink: 1,
-    },
-    premiumBadge: {
-        flexDirection: "row",
-        alignItems: "center",
-        gap: 4,
-        paddingHorizontal: 8,
-        paddingVertical: 3,
-        borderRadius: radius.full,
-        backgroundColor: "rgba(212, 175, 55, 0.12)",
-        borderWidth: 1,
-        borderColor: "rgba(212, 175, 55, 0.25)",
-    },
-    premiumBadgeLocked: {
-        backgroundColor: "rgba(212, 175, 55, 0.18)",
-        borderColor: "rgba(212, 175, 55, 0.35)",
-    },
-    premiumBadgeText: {
-        ...typography.caption2,
-        color: colors.premium.gold,
-        fontWeight: "700",
-        letterSpacing: 0.6,
-    },
-    packMeta: {
-        ...typography.caption1,
-        color: colors.textTertiary,
-        marginTop: 2,
-    },
-    packMetaEnabled: {
-        color: colors.primary,
-    },
-    packIntensityRow: {
-        flexDirection: "row",
-        alignItems: "center",
-        gap: 6,
-        marginTop: spacing.xs,
-    },
-    packIntensityFlames: {
-        flexDirection: "row",
-        alignItems: "center",
-        gap: 2,
-    },
-    packIntensityText: {
-        ...typography.caption2,
-        color: colors.textSecondary,
-        fontWeight: "600",
-    },
-
-    // Expanded Pack
-    packExpanded: {
-        paddingHorizontal: spacing.md,
-        paddingBottom: spacing.md,
-        paddingTop: 0,
-    },
-    packDescription: {
-        ...typography.subhead,
-        color: colors.textSecondary,
-        lineHeight: 20,
-        marginBottom: spacing.md,
-    },
-    packActions: {
-        flexDirection: "row",
-        gap: spacing.sm,
-    },
-    packInfoButton: {
-        flexDirection: "row",
-        alignItems: "center",
-        gap: spacing.xs,
-        paddingVertical: spacing.sm,
-        paddingHorizontal: spacing.md,
-        borderRadius: radius.sm,
-        backgroundColor: "rgba(255, 255, 255, 0.05)",
-        borderWidth: 1,
-        borderColor: colors.glass.border,
-    },
-    packInfoButtonText: {
-        ...typography.subhead,
-        color: colors.textSecondary,
-    },
-    packToggleButton: {
-        flex: 1,
-        flexDirection: "row",
-        alignItems: "center",
-        justifyContent: "center",
-        gap: spacing.xs,
-        paddingVertical: spacing.sm,
-        paddingHorizontal: spacing.md,
-        borderRadius: radius.sm,
-        backgroundColor: "rgba(255, 255, 255, 0.08)",
-        borderWidth: 1,
-        borderColor: "rgba(255, 255, 255, 0.12)",
-    },
-    packToggleButtonEnabled: {
-        backgroundColor: "rgba(233, 69, 96, 0.1)",
-        borderColor: "rgba(233, 69, 96, 0.3)",
-    },
-    packToggleButtonLocked: {
-        backgroundColor: "rgba(212, 175, 55, 0.1)",
-        borderColor: "rgba(212, 175, 55, 0.3)",
-    },
-    packToggleButtonText: {
-        ...typography.subhead,
-        color: colors.text,
-        fontWeight: "500",
-    },
-    packToggleButtonTextEnabled: {
-        color: colors.primary,
-    },
-    packToggleButtonTextLocked: {
-        color: colors.premium.gold,
-    },
-});
@@ -145,7 +145,7 @@ export default function PairingScreen() {
        if (couple?.invite_code) {
            try {
                await Share.share({
-                    message: `Join me on Sauci! Use my invite code to pair up: ${couple.invite_code}`,
+                    message: `Join me on Sauci! Download the app at https://sauci.app and use my invite code to pair up: ${couple.invite_code}`,
                });
                Events.codeShared();
            } catch (error) {
@@ -418,10 +418,56 @@ const styles = StyleSheet.create({
        width: 44,
        height: 44,
        borderRadius: 22,
-        backgroundColor: colors.glass.background,
+        backgroundColor: colors.backgroundLight,
        justifyContent: "center",
        alignItems: "center",
        marginRight: spacing.md,
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+    // ...
+    input: {
+        backgroundColor: colors.background, // Flat background
+        borderRadius: radius.md,
+        borderWidth: 1,
+        borderColor: colors.border,
+        padding: spacing.md,
+        ...typography.headline,
+        color: colors.text,
+        textAlign: "center",
+        letterSpacing: 4,
+        fontFamily: Platform.OS === "ios" ? "Courier" : "monospace",
+        marginBottom: spacing.md,
+    },
+    // ...
+    dividerLine: {
+        flex: 1,
+        height: 1,
+        backgroundColor: colors.border,
+    },
+    // ...
+    copyIcon: {
+        width: 36,
+        height: 36,
+        borderRadius: 18,
+        backgroundColor: colors.background,
+        justifyContent: "center",
+        alignItems: "center",
+        marginLeft: spacing.md,
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+    // ...
+    waitingBadge: {
+        flexDirection: "row",
+        alignItems: "center",
+        backgroundColor: colors.backgroundLight,
+        paddingHorizontal: spacing.md,
+        paddingVertical: spacing.sm,
+        borderRadius: radius.full,
+        gap: spacing.sm,
+        borderWidth: 1,
+        borderColor: colors.border,
    },
    title: {
        ...typography.title1,
@@ -462,29 +508,13 @@ const styles = StyleSheet.create({
        marginBottom: spacing.sm,
        marginLeft: spacing.xs,
    },
-    input: {
-        backgroundColor: colors.glass.background,
-        borderRadius: radius.md,
-        borderWidth: 1,
-        borderColor: colors.glass.border,
-        padding: spacing.md,
-        ...typography.headline,
-        color: colors.text,
-        textAlign: "center",
-        letterSpacing: 4,
-        fontFamily: Platform.OS === "ios" ? "Courier" : "monospace",
-        marginBottom: spacing.md,
-    },
+
    divider: {
        flexDirection: "row",
        alignItems: "center",
        marginVertical: spacing.lg,
    },
-    dividerLine: {
-        flex: 1,
-        height: 1,
-        backgroundColor: colors.glass.border,
-    },
+
    dividerText: {
        ...typography.subhead,
        color: colors.textTertiary,
@@ -501,15 +531,7 @@ const styles = StyleSheet.create({
        letterSpacing: 6,
        fontFamily: Platform.OS === "ios" ? "Courier" : "monospace",
    },
-    copyIcon: {
-        width: 36,
-        height: 36,
-        borderRadius: 18,
-        backgroundColor: colors.glass.background,
-        justifyContent: "center",
-        alignItems: "center",
-        marginLeft: spacing.md,
-    },
+
    tapToCopy: {
        ...typography.caption1,
        color: colors.textTertiary,
@@ -520,15 +542,7 @@ const styles = StyleSheet.create({
        alignItems: "center",
        marginTop: spacing.xl,
    },
-    waitingBadge: {
-        flexDirection: "row",
-        alignItems: "center",
-        backgroundColor: colors.glass.background,
-        paddingHorizontal: spacing.md,
-        paddingVertical: spacing.sm,
-        borderRadius: radius.full,
-        gap: spacing.sm,
-    },
+
    waitingText: {
        ...typography.subhead,
        color: colors.textTertiary,
@@ -163,14 +163,35 @@ const styles = StyleSheet.create({
        opacity: 0.6,
    },
    badge: {
-        backgroundColor: 'rgba(232, 164, 174, 0.1)',
+        backgroundColor: colors.backgroundLight,
        paddingHorizontal: spacing.lg,
        paddingVertical: spacing.sm,
        borderRadius: radius.full,
        borderWidth: 1,
-        borderColor: 'rgba(232, 164, 174, 0.2)',
+        borderColor: colors.border,
        marginBottom: spacing.xl,
    },
+    interestButton: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'center',
+        backgroundColor: colors.backgroundLight,
+        paddingHorizontal: spacing.lg,
+        paddingVertical: spacing.sm + 2,
+        borderRadius: radius.full,
+        borderWidth: 1,
+        borderColor: colors.border,
+        gap: spacing.sm,
+    },
+    interestButtonActive: {
+        backgroundColor: colors.background,
+        borderColor: colors.primary,
+    },
+    interestButtonText: {
+        ...typography.subhead,
+        fontWeight: '600',
+        color: ACCENT_COLOR,
+    },
    badgeText: {
        ...typography.caption2,
        fontWeight: '600',
@@ -208,25 +229,4 @@ const styles = StyleSheet.create({
        marginTop: spacing.xl,
        minHeight: 44,
    },
-    interestButton: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        justifyContent: 'center',
-        backgroundColor: 'rgba(232, 164, 174, 0.1)',
-        paddingHorizontal: spacing.lg,
-        paddingVertical: spacing.sm + 2,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: 'rgba(232, 164, 174, 0.2)',
-        gap: spacing.sm,
-    },
-    interestButtonActive: {
-        backgroundColor: 'rgba(232, 164, 174, 0.15)',
-        borderColor: 'rgba(232, 164, 174, 0.3)',
-    },
-    interestButtonText: {
-        ...typography.subhead,
-        fontWeight: '600',
-        color: ACCENT_COLOR,
-    },
 });
@@ -0,0 +1,12 @@
+import { Stack } from 'expo-router';
+
+export default function SettingsLayout() {
+    return (
+        <Stack
+            screenOptions={{
+                headerShown: false,
+                animation: 'slide_from_right',
+            }}
+        />
+    );
+}
@@ -0,0 +1,3 @@
+import { AccountScreen } from "../../../src/features/profile/screens";
+
+export default AccountScreen;
@@ -0,0 +1,3 @@
+import { NotificationsScreen } from "../../../src/features/profile/screens";
+
+export default NotificationsScreen;
@@ -0,0 +1,3 @@
+import { PartnerScreen } from "../../../src/features/profile/screens";
+
+export default PartnerScreen;
@@ -0,0 +1,3 @@
+import { PreferencesScreen } from "../../../src/features/profile/screens";
+
+export default PreferencesScreen;
@@ -0,0 +1,3 @@
+import { ProfileSettingsScreen } from "../../../src/features/profile/screens";
+
+export default ProfileSettingsScreen;
@@ -0,0 +1,3 @@
+import { SaveAccountScreen } from "../../../src/features/profile/screens";
+
+export default SaveAccountScreen;
@@ -0,0 +1,3 @@
+import { SubscriptionScreen } from "../../../src/features/profile/screens";
+
+export default SubscriptionScreen;
@@ -0,0 +1,3 @@
+import { SupportScreen } from "../../../src/features/profile/screens";
+
+export default SupportScreen;
@@ -2,6 +2,8 @@ import { useState, useEffect, useRef, useCallback } from "react";
 import { View, StyleSheet, Text, ActivityIndicator, Platform, TouchableOpacity } from "react-native";
 import { useLocalSearchParams, router, useFocusEffect } from "expo-router";
 import { Ionicons } from "@expo/vector-icons";
+import * as FileSystem from "expo-file-system";
+import { decode } from "base64-arraybuffer";
 import Animated, {
    FadeIn,
    FadeInUp,
@@ -17,16 +19,45 @@ import { supabase } from "../../src/lib/supabase";
 import { usePacksStore, useAuthStore } from "../../src/store";
 import { useAmbientOrbAnimation } from "../../src/hooks";
 import { skipQuestion, getSkippedQuestionIds } from "../../src/lib/skippedQuestions";
-import { hasSeenSwipeTutorial, markSwipeTutorialSeen } from "../../src/lib/swipeTutorialSeen";
 import { invokeWithAuthRetry } from "../../src/lib/authErrorHandler";
-// import SwipeCard from "../../src/components/SwipeCard";
-import { SwipeCardPremium as SwipeCard } from "../../src/components/swipe"; // PoC: Premium styling
-import { SwipeTutorial } from "../../src/components/tutorials";
+import {
+    QuestionCard,
+    QuestionCardText,
+    QuestionCardPhoto,
+    QuestionCardAudio,
+    QuestionCardWhoLikely
+} from "../../src/components/questions";
 import { QuestionFeedbackModal } from "../../src/components/feedback";
+import { MatchConfetti } from "../../src/components/MatchConfetti";
 import { GradientBackground, GlassCard, GlassButton, DecorativeSeparator } from "../../src/components/ui";
 import { Paywall } from "../../src/components/paywall";
 import { Events } from "../../src/lib/analytics";
-import { colors, gradients, spacing, typography, radius, shadows } from "../../src/theme";
+import { colors, gradients, spacing, typography, radius, shadows, getCategoryColor } from "../../src/theme";
+import type { AnswerType } from "../../src/types";
+
+// Response data types for different question types
+interface TextResponseData {
+    type: 'text_answer';
+    text: string;
+}
+
+interface PhotoResponseData {
+    type: 'photo';
+    media_path: string;
+}
+
+interface AudioResponseData {
+    type: 'audio';
+    media_path: string;
+    duration_seconds: number;
+}
+
+interface WhoLikelyResponseData {
+    type: 'who_likely';
+    chosen_user_id: string;
+}
+
+type ResponseData = TextResponseData | PhotoResponseData | AudioResponseData | WhoLikelyResponseData;

 interface DailyLimitInfo {
    responses_today: number;
@@ -40,19 +71,35 @@ export default function SwipeScreen() {
    const params = useLocalSearchParams();
    // Normalize packId - useLocalSearchParams can return string | string[]
    const packId = Array.isArray(params.packId) ? params.packId[0] : params.packId;
+    // Mode can be 'pending' to show only questions partner has answered
+    const mode = Array.isArray(params.mode) ? params.mode[0] : params.mode;
+    // Start question ID - when user taps a specific pending question, start there
+    const startQuestionId = Array.isArray(params.startQuestionId) ? params.startQuestionId[0] : params.startQuestionId;
    const [questions, setQuestions] = useState<any[]>([]);
    const [isLoading, setIsLoading] = useState(true);
    const [currentIndex, setCurrentIndex] = useState(0);
-    const [showTutorial, setShowTutorial] = useState(false);
    const [feedbackQuestion, setFeedbackQuestion] = useState<{id: string, text: string} | null>(null);
+    const [isUploading, setIsUploading] = useState(false);
    const [isBlocked, setIsBlocked] = useState(false);
    const [gapInfo, setGapInfo] = useState<{ unanswered: number; threshold: number } | null>(null);
    const [dailyLimitInfo, setDailyLimitInfo] = useState<DailyLimitInfo | null>(null);
    const [showPaywall, setShowPaywall] = useState(false);
-    const { enabledPackIds, ensureEnabledPacksLoaded } = usePacksStore();
-    const { partner, couple } = useAuthStore();
+    const [packContext, setPackContext] = useState<{ name: string; icon: string } | null>(null);
+    const [showConfetti, setShowConfetti] = useState(false);
+    const { enabledPackIds, ensureEnabledPacksLoaded, packs } = usePacksStore();
+    const { user, partner, couple } = useAuthStore();
+
+    // Supported question types - filter out types the UI doesn't support yet
+    const supportedTypes = ['swipe', 'text_answer', 'photo', 'audio', 'who_likely'];
+
+    // Filter questions to only supported types (safety during rollout)
+    // Must be calculated early since it's used by effectiveTotal and throughout rendering
+    const filteredQuestions = questions.filter(q =>
+        !q.question_type || supportedTypes.includes(q.question_type)
+    );
    const hasTrackedExhausted = useRef(false);
    const fetchRequestId = useRef(0);
+    const lastFetchedMode = useRef<string | undefined>(undefined);

    // Ambient orb breathing animations
    const { orbStyle1, orbStyle2 } = useAmbientOrbAnimation();
@@ -112,16 +159,41 @@ export default function SwipeScreen() {
    const isFirstMount = useRef(true);

    useEffect(() => {
-        // Reset state when pack changes
+        // Reset state when pack or mode changes
        setCurrentIndex(0);
        setIsLoading(true);
        setIsBlocked(false);
        setGapInfo(null);
        hasTrackedExhausted.current = false;
+        lastFetchedMode.current = mode;

        // Use lightweight ensureEnabledPacksLoaded instead of full fetchPacks
-        ensureEnabledPacksLoaded().then(() => fetchQuestions());
-        checkTutorial();
+        ensureEnabledPacksLoaded().then(() => {
+            if (mode === 'pending') {
+                fetchPendingQuestions();
+            } else {
+                fetchQuestions();
+            }
+        });
+    }, [packId, mode, startQuestionId]);
+
+    // Fetch pack context when packId is provided
+    useEffect(() => {
+        if (packId) {
+            const fetchPackContext = async () => {
+                const { data } = await supabase
+                    .from('question_packs')
+                    .select('name, icon')
+                    .eq('id', packId)
+                    .single();
+                if (data) {
+                    setPackContext({ name: data.name, icon: data.icon || 'layers' });
+                }
+            };
+            fetchPackContext();
+        } else {
+            setPackContext(null);
+        }
    }, [packId]);

    // Refresh questions when screen gains focus (handles partner answering while away)
@@ -132,9 +204,17 @@ export default function SwipeScreen() {
                isFirstMount.current = false;
                return;
            }
-            // Silently refetch to get updated partner_answered status
+            // Skip if mode just changed (useEffect handles that)
+            if (lastFetchedMode.current !== mode) {
+                return;
+            }
+            // Silently refetch to get updated status
+            if (mode === 'pending') {
+                fetchPendingQuestions();
+            } else {
                fetchQuestions();
-        }, [packId])
+            }
+        }, [packId, mode])
    );

    // Check if user is too far ahead of partner (called when questions empty or after swipe)
@@ -212,7 +292,7 @@ export default function SwipeScreen() {

    // Calculate effective total questions (accounting for gap limit AND daily limit)
    const effectiveTotal = (() => {
-        let total = questions.length;
+        let total = filteredQuestions.length;

        // Apply gap limit if active
        if (gapInfo && gapInfo.threshold > 0) {
@@ -230,27 +310,16 @@ export default function SwipeScreen() {

    // Track when all questions are exhausted
    useEffect(() => {
-        if (questions.length > 0 && currentIndex >= questions.length && !hasTrackedExhausted.current) {
+        if (filteredQuestions.length > 0 && currentIndex >= filteredQuestions.length && !hasTrackedExhausted.current) {
            hasTrackedExhausted.current = true;
            Events.allQuestionsExhausted();
        }
-    }, [currentIndex, questions.length]);
-
-    const checkTutorial = async () => {
-        const seen = await hasSeenSwipeTutorial();
-        if (!seen) {
-            setShowTutorial(true);
-        }
-    };
-
-    const handleTutorialComplete = async () => {
-        await markSwipeTutorialSeen();
-        setShowTutorial(false);
-    };
+    }, [currentIndex, filteredQuestions.length]);

    // Filter out questions from disabled packs immediately when enabledPackIds changes
+    // Skip this filter in pending mode - user should answer ALL questions partner swiped on
    useEffect(() => {
-        if (!packId && enabledPackIds.length > 0 && questions.length > 0) {
+        if (!packId && mode !== 'pending' && enabledPackIds.length > 0 && questions.length > 0) {
            const enabledSet = new Set(enabledPackIds);
            setQuestions(prev => {
                const filtered = prev.filter(q => enabledSet.has(q.pack_id));
@@ -261,7 +330,7 @@ export default function SwipeScreen() {
                return filtered;
            });
        }
-    }, [enabledPackIds]);
+    }, [enabledPackIds, mode]);


    const fetchQuestions = async () => {
@@ -287,7 +356,12 @@ export default function SwipeScreen() {
            }

            // Filter out recently skipped questions
-            const filtered = (data || []).filter((q: any) => !skippedIds.has(q.id));
+            let filtered = (data || []).filter((q: any) => !skippedIds.has(q.id));
+
+            // If no unskipped questions remain, show skipped ones again
+            if (filtered.length === 0 && data && data.length > 0) {
+                filtered = data;
+            }

            // Always check answer gap and daily limit when user has partner and not viewing specific pack
            if (partner && !packId) {
@@ -315,33 +389,238 @@ export default function SwipeScreen() {
        }
    };

-    const handleSwipe = async (direction: "left" | "right" | "up" | "down") => {
-        const question = questions[currentIndex];
+    // Fetch pending questions (partner answered, user hasn't) for "Your Turn" mode
+    const fetchPendingQuestions = async () => {
+        const currentRequestId = ++fetchRequestId.current;
+        const userId = useAuthStore.getState().user?.id;
+        const coupleId = useAuthStore.getState().user?.couple_id;

-        setCurrentIndex(prev => prev + 1);
+        if (!coupleId || !userId) {
+            if (currentRequestId === fetchRequestId.current) {
+                setQuestions([]);
+                setIsLoading(false);
+            }
+            return;
+        }
+
+        try {
+            // Get partner's user_id
+            const { data: coupleProfiles } = await supabase
+                .from("profiles")
+                .select("id")
+                .eq("couple_id", coupleId)
+                .neq("id", userId);
+
+            const partnerId = coupleProfiles?.[0]?.id;
+            if (!partnerId) {
+                if (currentRequestId === fetchRequestId.current) {
+                    setQuestions([]);
+                    setIsLoading(false);
+                }
+                return;
+            }
+
+            // Get questions the current user has already answered
+            const { data: userResponses } = await supabase
+                .from("responses")
+                .select("question_id")
+                .eq("user_id", userId)
+                .eq("couple_id", coupleId);
+
+            const answeredQuestionIds = new Set(userResponses?.map(r => r.question_id) ?? []);
+
+            // Get partner's responses (questions they answered that user hasn't)
+            // Order by oldest first so user burns down the backlog
+            const { data: partnerResponses, error } = await supabase
+                .from("responses")
+                .select(`
+                    id,
+                    question_id,
+                    created_at,
+                    question:questions(
+                        *,
+                        pack:question_packs(id, name, icon)
+                    )
+                `)
+                .eq("user_id", partnerId)
+                .eq("couple_id", coupleId)
+                .order("created_at", { ascending: true }); // Oldest first
+
+            if (currentRequestId !== fetchRequestId.current) return;
+
+            if (error) {
+                console.error("Error fetching pending questions:", error);
+                throw error;
+            }
+
+            // Filter to only questions user hasn't answered, excluding deleted questions
+            const pendingQuestions = (partnerResponses ?? [])
+                .filter(r => {
+                    const question = r.question as any;
+                    return !answeredQuestionIds.has(r.question_id) && question && !question.deleted_at;
+                })
+                .map(r => {
+                    const question = r.question as any;
+                    return {
+                        ...question,
+                        pack_id: question.pack?.id,
+                        pack_name: question.pack?.name,
+                        pack_icon: question.pack?.icon,
+                    };
+                });
+
+            if (currentRequestId === fetchRequestId.current) {
+                // If user tapped a specific question, reorder so it's first
+                let orderedQuestions = pendingQuestions;
+                if (startQuestionId && pendingQuestions.length > 0) {
+                    const startIndex = pendingQuestions.findIndex(q => q.id === startQuestionId);
+                    if (startIndex !== -1) {
+                        // Put tapped question first, then the rest in original order
+                        const tappedQuestion = pendingQuestions[startIndex];
+                        const rest = pendingQuestions.filter((_, i) => i !== startIndex);
+                        orderedQuestions = [tappedQuestion, ...rest];
+                    }
+                }
+
+                setQuestions(orderedQuestions);
+                setCurrentIndex(0); // Always start at 0 now since we reordered
+
+                // Don't check gap/daily limits in pending mode - user is just catching up
+                setIsBlocked(false);
+                setGapInfo(null);
+                setDailyLimitInfo(null);
+            }
+        } catch (error) {
+            if (currentRequestId === fetchRequestId.current) {
+                console.error("Failed to fetch pending questions:", error);
+                setQuestions([]);
+            }
+        } finally {
+            if (currentRequestId === fetchRequestId.current) {
+                setIsLoading(false);
+            }
+        }
+    };
+
+    // Upload media (photo/audio) to Supabase storage
+    const uploadResponseMedia = async (
+        localUri: string,
+        questionId: string,
+        mediaType: 'photo' | 'audio'
+    ): Promise<string | null> => {
+        if (!user?.id) return null;
+
+        try {
+            const timestamp = Date.now();
+            const extMatch = localUri.match(/\.(\w+)$/);
+            const ext = extMatch ? extMatch[1] : (mediaType === 'photo' ? 'jpg' : 'm4a');
+            const fileName = `${user.id}/${questionId}_${timestamp}.${ext}`;
+            const contentType = mediaType === 'photo'
+                ? `image/${ext === 'jpg' ? 'jpeg' : ext}`
+                : `audio/${ext}`;
+
+            let fileBody: ArrayBuffer | Blob;
+
+            if (Platform.OS === 'web') {
+                const response = await fetch(localUri);
+                fileBody = await response.blob();
+            } else {
+                const base64 = await FileSystem.readAsStringAsync(localUri, {
+                    encoding: FileSystem.EncodingType.Base64,
+                });
+                fileBody = decode(base64);
+            }
+
+            const { error } = await supabase.storage
+                .from('response-media')
+                .upload(fileName, fileBody, { contentType });
+
+            if (error) {
+                console.error('Media upload error:', error);
+                return null;
+            }
+
+            return fileName;
+        } catch (error) {
+            console.error('Media upload failed:', error);
+            return null;
+        }
+    };
+
+    // Handle answer submission from question cards (supports response_data for new question types)
+    const handleAnswer = async (questionId: string, answer: AnswerType | 'skip', responseData?: ResponseData) => {
+        const question = filteredQuestions[currentIndex];

        // Handle skip - don't submit a response, just store it for later
-        if (direction === "down") {
-            await skipQuestion(question.id);
+        if (answer === 'skip') {
+            setCurrentIndex(prev => prev + 1);
+            await skipQuestion(questionId);
            Events.questionSkipped();
            return;
        }

-        const answer = direction === "right" ? "yes" : direction === "left" ? "no" : "maybe";
-
        try {
-            const { error } = await invokeWithAuthRetry("submit-response", {
+            // Upload media if response contains photo or audio with local URI
+            let finalResponseData = responseData;
+            if (responseData) {
+                if (responseData.type === 'photo' && responseData.media_path) {
+                    setIsUploading(true);
+                    try {
+                        const uploadedPath = await uploadResponseMedia(responseData.media_path, questionId, 'photo');
+                        if (uploadedPath) {
+                            finalResponseData = { ...responseData, media_path: uploadedPath };
+                        } else {
+                            console.error('Photo upload failed, skipping response_data');
+                            finalResponseData = undefined;
+                        }
+                    } finally {
+                        setIsUploading(false);
+                    }
+                } else if (responseData.type === 'audio' && responseData.media_path) {
+                    setIsUploading(true);
+                    try {
+                        const uploadedPath = await uploadResponseMedia(responseData.media_path, questionId, 'audio');
+                        if (uploadedPath) {
+                            finalResponseData = { ...responseData, media_path: uploadedPath };
+                        } else {
+                            console.error('Audio upload failed, skipping response_data');
+                            finalResponseData = undefined;
+                        }
+                    } finally {
+                        setIsUploading(false);
+                    }
+                }
+            }
+
+            const { data, error } = await invokeWithAuthRetry("submit-response", {
                body: {
-                    question_id: question.id,
+                    question_id: questionId,
                    answer,
+                    response_data: finalResponseData,
                },
            });

            if (error) {
                console.error("Submit response error:", error);
+                // Advance to next question even on error
+                setCurrentIndex(prev => prev + 1);
            } else {
                Events.questionAnswered(answer, question.pack_id);

+                // Check if a match was created
+                const hasMatch = data?.match != null;
+
+                if (hasMatch) {
+                    // Show confetti celebration - delay advancing to next question
+                    setShowConfetti(true);
+                    // Confetti component will call onAnimationComplete which advances
+                } else {
+                    // No match - advance immediately
+                    setCurrentIndex(prev => prev + 1);
+                }
+
+                // Skip limit checks in pending mode - user is just catching up
+                if (mode !== 'pending') {
                    // Increment local daily count if we have limit info
                    if (dailyLimitInfo && dailyLimitInfo.limit_value > 0) {
                        setDailyLimitInfo(prev => prev ? {
@@ -355,8 +634,134 @@ export default function SwipeScreen() {
                    // Check both gap and daily limit
                    await Promise.all([checkAnswerGap(), checkDailyLimit()]);
                }
+            }
        } catch (error) {
            console.error("Failed to submit response", error);
+            // Advance to next question even on error
+            setCurrentIndex(prev => prev + 1);
+        }
+    };
+
+    // Handle confetti animation completion
+    const handleConfettiComplete = useCallback(() => {
+        setShowConfetti(false);
+        setCurrentIndex(prev => prev + 1);
+    }, []);
+
+    // Get pack info for a question - use packContext if viewing a specific pack, otherwise question's pack
+    const getQuestionPackInfo = (question: any) => {
+        // If viewing specific pack, use that context but try to enrich with color from store
+        if (packId) {
+            const pack = packs.find(p => p.id === packId);
+            const categoryColor = pack ? getCategoryColor(pack.category) : undefined;
+            
+            if (packContext) {
+                return { ...packContext, color: categoryColor };
+            }
+            if (pack) {
+                return { name: pack.name, icon: pack.icon || 'layers', color: categoryColor };
+            }
+        }
+
+        // For pending mode or mixed mode, look up pack details
+        if (question.pack_id) {
+            const pack = packs.find(p => p.id === question.pack_id);
+            const categoryColor = pack ? getCategoryColor(pack.category) : undefined;
+            
+            // Pending questions might have name/icon embedded if pack not found in store
+            if (question.pack_name) {
+                return { 
+                    name: question.pack_name, 
+                    icon: question.pack_icon || 'layers',
+                    color: categoryColor 
+                };
+            }
+            
+            if (pack) {
+                return { name: pack.name, icon: pack.icon || 'layers', color: categoryColor };
+            }
+        }
+        
+        return null;
+    };
+
+    // Render the appropriate question card based on question_type
+    const renderQuestionCard = (question: any) => {
+        // For backwards compatibility: default to 'swipe' if no question_type
+        const questionType = question.question_type || 'swipe';
+        const packInfo = getQuestionPackInfo(question);
+
+        switch (questionType) {
+            case 'text_answer':
+                return (
+                    <QuestionCardText
+                        key={question.id}
+                        question={question}
+                        packInfo={packInfo}
+                        onAnswer={(answer, responseData) => handleAnswer(question.id, answer, responseData)}
+                        onReport={() => setFeedbackQuestion({
+                            id: question.id,
+                            text: question.text
+                        })}
+                    />
+                );
+            case 'photo':
+                return (
+                    <QuestionCardPhoto
+                        key={question.id}
+                        question={question}
+                        packInfo={packInfo}
+                        onAnswer={(answer, responseData) => handleAnswer(question.id, answer, responseData)}
+                        onReport={() => setFeedbackQuestion({
+                            id: question.id,
+                            text: question.text
+                        })}
+                    />
+                );
+            case 'audio':
+                return (
+                    <QuestionCardAudio
+                        key={question.id}
+                        question={question}
+                        packInfo={packInfo}
+                        onAnswer={(answer, responseData) => handleAnswer(question.id, answer, responseData)}
+                        onReport={() => setFeedbackQuestion({
+                            id: question.id,
+                            text: question.text
+                        })}
+                    />
+                );
+            case 'who_likely':
+                return (
+                    <QuestionCardWhoLikely
+                        key={question.id}
+                        question={question}
+                        packInfo={packInfo}
+                        user={{ id: user?.id || '', name: user?.name || undefined, avatar_url: user?.avatar_url }}
+                        partner={{ id: partner?.id || '', name: partner?.name || undefined, avatar_url: partner?.avatar_url }}
+                        onAnswer={(responseData) => handleAnswer(question.id, 'yes', responseData)}
+                        onSkip={() => handleAnswer(question.id, 'skip')}
+                        onReport={() => setFeedbackQuestion({
+                            id: question.id,
+                            text: question.text
+                        })}
+                    />
+                );
+            case 'swipe':
+            default:
+                // Standard swipe card for 'swipe' type and any unknown types (backwards compatibility)
+                return (
+                    <QuestionCard
+                        key={question.id}
+                        question={question}
+                        packInfo={packInfo}
+                        onAnswer={(answer) => handleAnswer(question.id, answer)}
+                        onReport={() => setFeedbackQuestion({
+                            id: question.id,
+                            text: question.text
+                        })}
+                    />
+                );
        }
    };

@@ -443,7 +848,7 @@ export default function SwipeScreen() {
        const LIMIT_ACCENT = colors.premium.gold;
        return (
            <GradientBackground>
-                {/* Ambient Orbs - Gold/warm glow */}
+                {/* Ambient Orbs - Gold/warm glow - Commented out for flat design
                <Animated.View style={[styles.ambientOrb, styles.dailyLimitOrbTop, orbStyle1]} pointerEvents="none">
                    <LinearGradient
                        colors={[colors.premium.goldGlow, 'transparent']}
@@ -460,6 +865,7 @@ export default function SwipeScreen() {
                        end={{ x: 0, y: 0 }}
                    />
                </Animated.View>
+                */}

                <View style={styles.centerContainer}>
                    <Animated.View
@@ -669,10 +1075,10 @@ export default function SwipeScreen() {
                        <Text style={styles.waitingTeaser}>Your journey of discovery awaits</Text>

                        <GlassButton
-                            onPress={() => router.push("/packs")}
+                            onPress={() => router.push("/")}
                            style={{ marginTop: spacing.lg }}
                        >
-                            Choose Packs
+                            Browse Packs
                        </GlassButton>
                    </Animated.View>
                </View>
@@ -680,8 +1086,10 @@ export default function SwipeScreen() {
        );
    }

-    if (currentIndex >= questions.length) {
+    if (currentIndex >= filteredQuestions.length) {
        const CAUGHT_UP_ACCENT = colors.premium.rose;
+        const isPackMode = !!packId;
+        const isPendingMode = mode === 'pending';
        return (
            <GradientBackground>
                <View style={styles.centerContainer}>
@@ -695,8 +1103,12 @@ export default function SwipeScreen() {
                        </View>

                        {/* Title section */}
-                        <Text style={styles.caughtUpLabel}>COMPLETE</Text>
-                        <Text style={styles.waitingTitle}>All Caught Up</Text>
+                        <Text style={styles.caughtUpLabel}>
+                            {isPendingMode ? 'QUEUE COMPLETE' : isPackMode ? 'PACK COMPLETE' : 'COMPLETE'}
+                        </Text>
+                        <Text style={styles.waitingTitle}>
+                            {isPendingMode ? 'All Caught Up!' : isPackMode ? packContext?.name || 'Pack Complete' : 'All Caught Up'}
+                        </Text>

                        <DecorativeSeparator variant="rose" />

@@ -705,33 +1117,80 @@ export default function SwipeScreen() {
                            entering={FadeIn.delay(300).duration(400)}
                            style={styles.waitingBadge}
                        >
-                            <Text style={styles.waitingBadgeText}>YOU'RE AHEAD</Text>
+                            <Text style={styles.waitingBadgeText}>
+                                {isPendingMode ? 'YOUR TURN COMPLETE' : isPackMode ? 'ALL QUESTIONS ANSWERED' : "YOU'RE AHEAD"}
+                            </Text>
                        </Animated.View>

                        {/* Description */}
                        <Text style={styles.waitingDescription}>
-                            You've answered all available questions. New questions are added regularly, or explore different packs.
+                            {isPendingMode
+                                ? "You've answered all the questions your partner swiped on. Nice work! Check back later for more."
+                                : isPackMode
+                                ? "You've answered all questions in this pack. Head home to discover more!"
+                                : "You've answered all available questions. New questions are added regularly, or explore different packs from home."
+                            }
                        </Text>

                        {/* Feature hints */}
                        <View style={styles.waitingFeatures}>
+                            {isPendingMode ? (
+                                <>
+                                    <View style={styles.waitingFeatureItem}>
+                                        <Ionicons name="heart" size={16} color={CAUGHT_UP_ACCENT} />
+                                        <Text style={styles.waitingFeatureText}>Check your matches</Text>
+                                    </View>
+                                    <View style={styles.waitingFeatureItem}>
+                                        <Ionicons name="chatbubbles-outline" size={16} color={CAUGHT_UP_ACCENT} />
+                                        <Text style={styles.waitingFeatureText}>Chat about discoveries</Text>
+                                    </View>
+                                    <View style={styles.waitingFeatureItem}>
+                                        <Ionicons name="sparkles" size={16} color={CAUGHT_UP_ACCENT} />
+                                        <Text style={styles.waitingFeatureText}>Keep exploring together</Text>
+                                    </View>
+                                </>
+                            ) : (
+                                <>
                                    <View style={styles.waitingFeatureItem}>
                                        <Ionicons name="sparkles" size={16} color={CAUGHT_UP_ACCENT} />
                                        <Text style={styles.waitingFeatureText}>New questions weekly</Text>
                                    </View>
                                    <View style={styles.waitingFeatureItem}>
-                                <Ionicons name="layers-outline" size={16} color={CAUGHT_UP_ACCENT} />
-                                <Text style={styles.waitingFeatureText}>Try different packs</Text>
+                                        <Ionicons name="home-outline" size={16} color={CAUGHT_UP_ACCENT} />
+                                        <Text style={styles.waitingFeatureText}>Explore from home</Text>
                                    </View>
                                    <View style={styles.waitingFeatureItem}>
                                        <Ionicons name="chatbubbles-outline" size={16} color={CAUGHT_UP_ACCENT} />
                                        <Text style={styles.waitingFeatureText}>Chat about your matches</Text>
                                    </View>
+                                </>
+                            )}
                        </View>

                        {/* Bottom teaser */}
-                        <Text style={styles.waitingTeaser}>More ways to connect are on the way</Text>
+                        <Text style={styles.waitingTeaser}>
+                            {isPendingMode
+                                ? 'Your partner will love that you caught up'
+                                : isPackMode
+                                ? 'Discover more ways to connect'
+                                : 'More ways to connect are on the way'}
+                        </Text>

+                        {isPendingMode ? (
+                            <GlassButton
+                                onPress={() => router.push("/(app)/matches")}
+                                style={{ marginTop: spacing.lg }}
+                            >
+                                View Matches
+                            </GlassButton>
+                        ) : isPackMode ? (
+                            <GlassButton
+                                onPress={() => router.push("/")}
+                                style={{ marginTop: spacing.lg }}
+                            >
+                                Back to Home
+                            </GlassButton>
+                        ) : (
                            <GlassButton
                                variant="secondary"
                                onPress={fetchQuestions}
@@ -739,6 +1198,7 @@ export default function SwipeScreen() {
                            >
                                Refresh Questions
                            </GlassButton>
+                        )}
                    </Animated.View>
                </View>
            </GradientBackground>
@@ -747,7 +1207,7 @@ export default function SwipeScreen() {

    return (
        <GradientBackground>
-            {/* Ambient Orbs - Premium gold/rose */}
+            {/* Ambient Orbs - Premium gold/rose - Commented out for flat design
            <Animated.View style={[styles.ambientOrb, styles.orbTopRight, orbStyle1]} pointerEvents="none">
                <LinearGradient
                    colors={[colors.premium.goldGlow, 'transparent']}
@@ -764,6 +1224,7 @@ export default function SwipeScreen() {
                    end={{ x: 0, y: 0 }}
                />
            </Animated.View>
+            */}

            <View style={styles.container}>
                {/* Header */}
@@ -771,18 +1232,27 @@ export default function SwipeScreen() {
                    entering={FadeIn.duration(400)}
                    style={styles.header}
                >
+                    <View style={styles.headerRow}>
+                        {/* Back button when playing specific pack or pending mode */}
+                        {(packId || mode === 'pending') && (
+                            <TouchableOpacity onPress={() => router.back()} style={styles.backButton}>
+                                <Ionicons name="chevron-back" size={24} color={colors.text} />
+                            </TouchableOpacity>
+                        )}
                        <View style={styles.progressContainer}>
                            {/* Premium label */}
-                        <Text style={styles.progressLabel}>EXPLORE</Text>
+                            <Text style={styles.progressLabel}>
+                                {mode === 'pending' ? 'YOUR TURN' : packContext ? packContext.name.toUpperCase() : 'EXPLORE'}
+                            </Text>
                            <Text style={styles.progressText}>
-                            {currentIndex + 1} of {effectiveTotal || questions.length}
+                                {currentIndex + 1} of {effectiveTotal || filteredQuestions.length}
                            </Text>
                            <View style={[styles.progressBar, styles.progressBarPremium]}>
                                <Animated.View
                                    style={[
                                        styles.progressFill,
                                        styles.progressFillPremium,
-                                    { width: `${((currentIndex + 1) / (effectiveTotal || questions.length || 1)) * 100}%` }
+                                        { width: `${((currentIndex + 1) / (effectiveTotal || filteredQuestions.length || 1)) * 100}%` }
                                    ]}
                                >
                                    {/* Shimmer sweep */}
@@ -797,57 +1267,29 @@ export default function SwipeScreen() {
                                </Animated.View>
                            </View>
                        </View>
+                    </View>
                </Animated.View>

                {/* Card Stack */}
                <View style={styles.cardContainer}>
                    {/* Third card (deepest) */}
-                    {questions[currentIndex + 2] && (
+                    {filteredQuestions[currentIndex + 2] && (
                        <View style={[styles.stackCard, styles.stackCardThird]} />
                    )}

                    {/* Second card */}
-                    {questions[currentIndex + 1] && (
+                    {filteredQuestions[currentIndex + 1] && (
                        <View style={[styles.stackCard, styles.stackCardSecond]} />
                    )}

-                    {/* Active card */}
-                    <SwipeCard
-                        key={questions[currentIndex].id}
-                        question={questions[currentIndex]}
-                        onSwipe={handleSwipe}
-                        onReport={() => setFeedbackQuestion({
-                            id: questions[currentIndex].id,
-                            text: questions[currentIndex].text
-                        })}
-                    />
+                    {/* Active card - render appropriate component based on question_type */}
+                    {renderQuestionCard(filteredQuestions[currentIndex])}
                </View>

-                {/* Hint - Premium styling */}
-                <Animated.View
-                    entering={FadeIn.delay(500).duration(400)}
-                    style={styles.hintContainer}
-                >
-                    <Text style={styles.hintTextPremium}>Swipe or tap to answer</Text>
-                    
-                    <TouchableOpacity
-                        onPress={() => router.push({ pathname: "/my-answers", params: { returnTo: "/(app)/swipe" } })}
-                        style={styles.editLinkButton}
-                        hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
-                    >
-                        <Text style={styles.editLinkText}>Edit previous answers</Text>
-                    </TouchableOpacity>
-                </Animated.View>
-
                {/* Bottom spacing for tab bar */}
                <View style={styles.bottomSpacer} />
            </View>

-            {/* Tutorial Overlay */}
-            {showTutorial && (
-                <SwipeTutorial onComplete={handleTutorialComplete} />
-            )}
-
            {/* Question Feedback Modal */}
            <QuestionFeedbackModal
                visible={!!feedbackQuestion}
@@ -856,6 +1298,12 @@ export default function SwipeScreen() {
                questionText={feedbackQuestion?.text || ''}
            />

+            {/* Match Confetti Animation */}
+            <MatchConfetti
+                visible={showConfetti}
+                onAnimationComplete={handleConfettiComplete}
+            />
+
            {/* Paywall Modal */}
            <Paywall
                visible={showPaywall}
@@ -866,6 +1314,16 @@ export default function SwipeScreen() {
                    fetchQuestions();
                }}
            />
+
+            {/* Upload spinner overlay */}
+            {isUploading && (
+                <View style={styles.uploadOverlay}>
+                    <View style={styles.uploadSpinnerContainer}>
+                        <ActivityIndicator size="large" color={colors.premium.gold} />
+                        <Text style={styles.uploadText}>Uploading...</Text>
+                    </View>
+                </View>
+            )}
        </GradientBackground>
    );
 }
@@ -904,6 +1362,16 @@ const styles = StyleSheet.create({
        paddingHorizontal: spacing.lg,
        paddingBottom: spacing.md,
    },
+    headerRow: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    backButton: {
+        position: 'absolute',
+        left: 0,
+        padding: spacing.sm,
+    },
    progressContainer: {
        alignItems: "center",
    },
@@ -958,11 +1426,11 @@ const styles = StyleSheet.create({
        justifyContent: "center",
        alignItems: "center",
    },
-    // Card stack - Premium styling
+    // Card stack - Premium styling (background cards)
    stackCard: {
        position: "absolute",
        width: "85%",
-        height: 500,
+        height: "85%",
        backgroundColor: '#0d0d1a',
        borderRadius: radius.xl,
        borderWidth: 1,
@@ -978,32 +1446,6 @@ const styles = StyleSheet.create({
        opacity: 0.2,
        ...shadows.sm,
    },
-    hintContainer: {
-        alignItems: "center",
-        paddingBottom: spacing.md,
-    },
-    hintText: {
-        ...typography.caption1,
-        color: colors.textTertiary,
-    },
-    hintTextPremium: {
-        ...typography.caption1,
-        fontStyle: 'italic',
-        color: colors.textTertiary,
-        letterSpacing: 0.5,
-    },
-    editLinkButton: {
-        marginTop: spacing.md,
-        paddingVertical: spacing.xs,
-        paddingHorizontal: spacing.sm,
-    },
-    editLinkText: {
-        ...typography.caption2,
-        color: colors.premium.gold,
-        textDecorationLine: 'underline',
-        opacity: 0.8,
-        letterSpacing: 0.5,
-    },
    bottomSpacer: {
        height: Platform.OS === 'ios' ? 100 : 80,
    },
@@ -1208,4 +1650,26 @@ const styles = StyleSheet.create({
        fontWeight: '600',
        color: '#000',
    },
+    // Upload overlay styles
+    uploadOverlay: {
+        ...StyleSheet.absoluteFillObject,
+        backgroundColor: 'rgba(0, 0, 0, 0.6)',
+        justifyContent: 'center',
+        alignItems: 'center',
+        zIndex: 100,
+    },
+    uploadSpinnerContainer: {
+        backgroundColor: colors.backgroundLight,
+        paddingHorizontal: spacing.xl,
+        paddingVertical: spacing.lg,
+        borderRadius: radius.lg,
+        alignItems: 'center',
+        gap: spacing.md,
+        borderWidth: 1,
+        borderColor: 'rgba(212, 175, 55, 0.2)',
+    },
+    uploadText: {
+        ...typography.subhead,
+        color: colors.text,
+    },
 });
@@ -61,6 +61,7 @@ export default function LoginScreen() {
    const [email, setEmail] = useState("");
    const [password, setPassword] = useState("");
    const [isLoading, setIsLoading] = useState(false);
+    const [isGuestLoading, setIsGuestLoading] = useState(false);
    const [isMagicLinkSent, setIsMagicLinkSent] = useState(false);
    const [pendingVerification, setPendingVerification] = useState<PendingVerification | null>(null);
    const [isCheckingVerification, setIsCheckingVerification] = useState(false);
@@ -364,6 +365,20 @@ export default function LoginScreen() {
        }
    };

+    const handleGuestSignIn = async () => {
+        clearError();
+        setIsGuestLoading(true);
+        const { error: authError } = await supabase.auth.signInAnonymously();
+        setIsGuestLoading(false);
+
+        if (authError) {
+            showError(getAuthError(authError));
+            return;
+        }
+
+        Events.signIn("guest");
+    };
+ 
    if (isMagicLinkSent) {
        return (
            <GradientBackground showAccent>
@@ -663,6 +678,23 @@ export default function LoginScreen() {
                                </View>
                            </Animated.View>
                        )}
+
+                        <Animated.View
+                            entering={FadeInDown.delay(400).duration(600).springify()}
+                            style={styles.guestContainer}
+                        >
+                            <GlassButton
+                                variant="ghost"
+                                onPress={handleGuestSignIn}
+                                loading={isGuestLoading}
+                                disabled={isGuestLoading}
+                                icon={<Ionicons name="person-outline" size={20} color={colors.primary} />}
+                                fullWidth
+                            >
+                                Continue without Login
+                            </GlassButton>
+                            <Text style={styles.guestHint}>Save your account anytime in Settings.</Text>
+                        </Animated.View>
                    </View>
                </ScrollView>
            </KeyboardAvoidingView>
@@ -736,10 +768,18 @@ const styles = StyleSheet.create({
    },
    modeToggleContainer: {
        flexDirection: "row",
-        backgroundColor: colors.glass.background,
+        backgroundColor: colors.background, // Flat background
        borderRadius: radius.md,
        padding: 4,
        marginBottom: spacing.lg,
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+    // ...
+    dividerLine: {
+        flex: 1,
+        height: 1,
+        backgroundColor: colors.border,
    },
    modeToggle: {
        flex: 1,
@@ -800,11 +840,7 @@ const styles = StyleSheet.create({
        alignItems: "center",
        marginBottom: spacing.lg,
    },
-    dividerLine: {
-        flex: 1,
-        height: 1,
-        backgroundColor: colors.glass.border,
-    },
+
    dividerText: {
        ...typography.caption1,
        color: colors.textTertiary,
@@ -821,4 +857,14 @@ const styles = StyleSheet.create({
        flex: 1,
        height: 48,
    },
+    guestContainer: {
+        marginTop: spacing.lg,
+        alignItems: "center",
+        gap: spacing.sm,
+    },
+    guestHint: {
+        ...typography.caption1,
+        color: colors.textTertiary,
+        textAlign: "center",
+    },
 });
@@ -1,17 +1,12 @@
 // Polyfills must be imported FIRST before any other React Native imports
 import "../src/polyfills/web";
-import "../src/polyfills/crypto";

 // Initialize Sentry early to capture all errors
 import { initSentry, setUserContext, clearUserContext } from "../src/lib/sentry";
 initSentry();

-// Initialize Analytics
+// Analytics imports (initialization deferred until app mounts)
 import { initAnalytics, setUserId, clearUserId, logScreenView, Events } from "../src/lib/analytics";
-initAnalytics();
-
-// Track cold start immediately
-Events.appOpened("cold");

 // Import push notification utilities
 import {
@@ -21,8 +16,8 @@ import {
    handleNotificationResponse,
 } from "../src/lib/notifications";

-import React, { useEffect, useRef } from "react";
-import { Platform, View, AppState, AppStateStatus } from "react-native";
+import React, { useEffect, useRef, useState } from "react";
+import { Platform, View, AppState, AppStateStatus, Modal, Text, StyleSheet, Pressable, TouchableOpacity } from "react-native";

 // Suppress useLayoutEffect warning on server-side rendering
 if (Platform.OS === "web" && typeof globalThis.window === "undefined") {
@@ -39,6 +34,7 @@ if (Platform.OS === "web" && typeof globalThis.window === "undefined") {

 import { Stack, router, usePathname } from "expo-router";
 import { StatusBar } from "expo-status-bar";
+import { Ionicons } from "@expo/vector-icons";
 // GestureHandlerRootView is only needed on native platforms
 // On web, we use a simple View to avoid findNodeHandle errors
 const GestureHandlerRootView = Platform.OS === "web"
@@ -48,13 +44,34 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import * as Linking from "expo-linking";
 import { useAuthStore } from "../src/store";
 import { supabase } from "../src/lib/supabase";
+import { colors, spacing, radius, typography } from "../src/theme";
+import { hasSeenGuestAccountWarning, markGuestAccountWarningSeen } from "../src/lib/guestAccountWarningSeen";

 const queryClient = new QueryClient();

 export default function RootLayout() {
-    const { fetchUser, setUser } = useAuthStore();
+    const { fetchUser, setUser, isAuthenticated, isAnonymous } = useAuthStore();
    const pathname = usePathname();
    const appState = useRef(AppState.currentState);
+    const analyticsInitialized = useRef(false);
+
+    const [showGuestWarning, setShowGuestWarning] = useState(false);
+    const [checkingGuestWarning, setCheckingGuestWarning] = useState(false);
+
+    const dismissGuestWarning = async () => {
+        await markGuestAccountWarningSeen();
+        setShowGuestWarning(false);
+    };
+
+
+    // Initialize analytics after native modules are ready
+    useEffect(() => {
+        if (!analyticsInitialized.current) {
+            analyticsInitialized.current = true;
+            initAnalytics();
+            Events.appOpened("cold");
+        }
+    }, []);

    // Track screen views
    useEffect(() => {
@@ -63,6 +80,22 @@ export default function RootLayout() {
        }
    }, [pathname]);

+    // Warn guest users (first time only) that accounts are not recoverable
+    useEffect(() => {
+        if (!isAuthenticated || !isAnonymous) return;
+        if (checkingGuestWarning) return;
+        if (pathname?.startsWith("/(auth)")) return;
+
+        setCheckingGuestWarning(true);
+        hasSeenGuestAccountWarning()
+            .then((seen) => {
+                if (!seen) {
+                    setShowGuestWarning(true);
+                }
+            })
+            .finally(() => setCheckingGuestWarning(false));
+    }, [isAuthenticated, isAnonymous, pathname, checkingGuestWarning]);
+
    // Track warm starts when app comes back from background
    useEffect(() => {
        const subscription = AppState.addEventListener("change", (nextAppState: AppStateStatus) => {
@@ -176,7 +209,7 @@ export default function RootLayout() {
        const { data: { subscription: authSubscription } } = supabase.auth.onAuthStateChange(
            async (event, session) => {
                console.log('[Auth] onAuthStateChange:', event, 'hasSession:', !!session, 'userId:', session?.user?.id);
-                if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
+                if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED" || event === "USER_UPDATED") {
                    console.log('[Auth] Calling fetchUser...');
                    fetchUser();
                    // Set Sentry user context for error tracking
@@ -218,7 +251,144 @@ export default function RootLayout() {
                        contentStyle: { backgroundColor: "#1a1a2e" },
                    }}
                />
+
+                <Modal
+                    visible={showGuestWarning}
+                    transparent
+                    animationType="fade"
+                    onRequestClose={dismissGuestWarning}
+                >
+                    <Pressable
+                        style={styles.guestWarningOverlay}
+                        onPress={dismissGuestWarning}
+                    >
+                        <Pressable style={styles.guestWarningCard} onPress={() => { }}>
+                            <View style={styles.guestWarningHeader}>
+                                <View style={styles.guestWarningIcon}>
+                                    <Ionicons name="warning" size={22} color={colors.primary} />
+                                </View>
+                                <TouchableOpacity
+                                    onPress={dismissGuestWarning}
+                                    hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
+                                    style={styles.guestWarningClose}
+                                >
+                                    <Ionicons name="close" size={20} color={colors.textSecondary} />
+                                </TouchableOpacity>
+                            </View>
+
+                            <Text style={styles.guestWarningTitle}>Your account isn't saved</Text>
+                            <Text style={styles.guestWarningBody}>
+                                If you delete the app or switch devices, you won't be able to recover this account.
+                                Save your account now to protect your couple, matches, and purchases.
+                            </Text>
+
+                            <View style={styles.guestWarningActions}>
+                                <TouchableOpacity
+                                    style={styles.guestWarningPrimary}
+                                    onPress={async () => {
+                                        await markGuestAccountWarningSeen();
+                                        setShowGuestWarning(false);
+                                        router.push("/(app)/settings/save-account" as any);
+                                    }}
+                                    activeOpacity={0.8}
+                                >
+                                    <Text style={styles.guestWarningPrimaryText}>Save account</Text>
+                                </TouchableOpacity>
+                                <TouchableOpacity
+                                    style={styles.guestWarningSecondary}
+                                    onPress={async () => {
+                                        await markGuestAccountWarningSeen();
+                                        setShowGuestWarning(false);
+                                    }}
+                                    activeOpacity={0.8}
+                                >
+                                    <Text style={styles.guestWarningSecondaryText}>Not now</Text>
+                                </TouchableOpacity>
+                            </View>
+                        </Pressable>
+                    </Pressable>
+                </Modal>
            </GestureHandlerRootView>
        </QueryClientProvider>
    );
 }
+
+const styles = StyleSheet.create({
+    guestWarningOverlay: {
+        flex: 1,
+        justifyContent: "center",
+        alignItems: "center",
+        padding: spacing.lg,
+        backgroundColor: "rgba(0, 0, 0, 0.75)",
+    },
+    guestWarningCard: {
+        width: "100%",
+        maxWidth: 420,
+        backgroundColor: colors.backgroundLight,
+        borderRadius: radius.xl,
+        padding: spacing.lg,
+        borderWidth: 1,
+        borderColor: colors.glass.border,
+    },
+    guestWarningHeader: {
+        flexDirection: "row",
+        alignItems: "center",
+        justifyContent: "space-between",
+        marginBottom: spacing.md,
+    },
+    guestWarningIcon: {
+        width: 40,
+        height: 40,
+        borderRadius: 20,
+        backgroundColor: colors.primaryLight,
+        justifyContent: "center",
+        alignItems: "center",
+    },
+    guestWarningClose: {
+        width: 40,
+        height: 40,
+        borderRadius: 20,
+        backgroundColor: colors.glass.background,
+        justifyContent: "center",
+        alignItems: "center",
+    },
+    guestWarningTitle: {
+        ...typography.headline,
+        color: colors.text,
+        marginBottom: spacing.sm,
+    },
+    guestWarningBody: {
+        ...typography.body,
+        color: colors.textSecondary,
+        lineHeight: 22,
+        marginBottom: spacing.lg,
+    },
+    guestWarningActions: {
+        gap: spacing.sm,
+    },
+    guestWarningPrimary: {
+        backgroundColor: colors.primary,
+        paddingVertical: 14,
+        borderRadius: radius.md,
+        alignItems: "center",
+    },
+    guestWarningPrimaryText: {
+        ...typography.subhead,
+        color: colors.text,
+        fontWeight: "600",
+    },
+    guestWarningSecondary: {
+        backgroundColor: colors.glass.background,
+        paddingVertical: 14,
+        borderRadius: radius.md,
+        alignItems: "center",
+        borderWidth: 1,
+        borderColor: colors.glass.border,
+    },
+    guestWarningSecondaryText: {
+        ...typography.subhead,
+        color: colors.textSecondary,
+        fontWeight: "600",
+    },
+});
+
@@ -1,6 +1,7 @@
 import { Redirect } from "expo-router";
 import { useAuthStore } from "../src/store";
 import { View, ActivityIndicator, StyleSheet } from "react-native";
+import { needsOnboarding } from "../src/constants/onboarding";

 export default function Index() {
    const { isAuthenticated, isLoading, user } = useAuthStore();
@@ -19,8 +20,8 @@ export default function Index() {
        return <Redirect href="/(auth)/login" />;
    }

-    // If user hasn't completed onboarding, go to onboarding first
-    if (!user?.onboarding_completed) {
+    // If user hasn't completed onboarding or needs to re-onboard, go to onboarding
+    if (needsOnboarding(user?.onboarding_completed, user?.onboarding_version)) {
        return <Redirect href="/(app)/onboarding" />;
    }

@@ -242,12 +242,19 @@ export default function PackDetailsScreen() {
                    {category ? category.name.toUpperCase() : 'PREVIEW'}
                </Text>

+                {/* Explicit badge */}
+                {pack?.is_explicit && (
+                    <View style={styles.explicitBadge}>
+                        <Ionicons name="flame" size={12} color={colors.text} />
+                        <Text style={styles.explicitBadgeText}>18+ EXPLICIT</Text>
+                    </View>
+                )}
+
                {/* Icon with enhanced glow for premium */}
                <View style={styles.iconWrapper}>
                    {pack?.is_premium && (
                        <>
-                            <View style={styles.iconGlowOuter} />
-                            <View style={styles.iconGlow} />
+                            {/* Glow effects removed for flat design */}
                        </>
                    )}
                    <View style={[
@@ -329,11 +336,7 @@ export default function PackDetailsScreen() {
                {/* Fixed Nav Bar */}
                <View style={styles.navBar}>
                    <Animated.View style={[styles.navBarBackground, navBarBackgroundStyle]}>
-                        {Platform.OS === "ios" ? (
-                            <BlurView intensity={80} tint="dark" style={StyleSheet.absoluteFill} />
-                        ) : (
-                            <View style={[StyleSheet.absoluteFill, { backgroundColor: "rgba(13, 13, 26, 0.95)" }]} />
-                        )}
+                        <View style={[StyleSheet.absoluteFill, { backgroundColor: colors.background }]} />
                    </Animated.View>

                    <TouchableOpacity onPress={() => router.back()} style={styles.backButton}>
@@ -440,8 +443,87 @@ const styles = StyleSheet.create({
    navBarBackground: {
        ...StyleSheet.absoluteFillObject,
        borderBottomWidth: 1,
-        borderBottomColor: 'rgba(233, 69, 96, 0.15)',
+        borderBottomColor: colors.border,
        overflow: "hidden",
+        backgroundColor: colors.background, // Flat
+    },
+    // ...
+
+    // ...
+    premiumBanner: {
+        marginHorizontal: spacing.lg,
+        marginBottom: spacing.lg,
+        borderRadius: radius.md,
+        overflow: 'hidden',
+        // Removed heavy shadow
+        borderWidth: 1,
+        borderColor: colors.premium.gold,
+    },
+    // ...
+    iconWrapper: {
+        position: 'relative',
+        marginBottom: spacing.md,
+        // Removed glowing background elements
+    },
+    // ...
+    iconContainer: {
+        width: 72,
+        height: 72,
+        borderRadius: 36,
+        backgroundColor: colors.backgroundLight,
+        justifyContent: 'center',
+        alignItems: 'center',
+        borderWidth: 1,
+        borderColor: colors.border,
+        overflow: 'hidden',
+    },
+    iconContainerPremium: {
+        borderColor: colors.premium.gold,
+        borderWidth: 2,
+        backgroundColor: colors.backgroundLight,
+        // Removed heavy shadows
+    },
+    // ...
+    statsBadge: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        gap: spacing.xs,
+        backgroundColor: colors.backgroundLight,
+        paddingHorizontal: spacing.lg,
+        paddingVertical: spacing.sm,
+        borderRadius: radius.full,
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+    // ...
+    questionCard: {
+        backgroundColor: colors.backgroundLight, // Flat
+        borderRadius: radius.md,
+        borderWidth: 1,
+        borderColor: colors.border,
+        marginBottom: spacing.sm,
+    },
+    // ...
+    partnerTextContainer: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        gap: spacing.xs,
+        marginBottom: spacing.sm,
+        paddingVertical: spacing.xs,
+        paddingHorizontal: spacing.sm,
+        backgroundColor: colors.background, // Nested flat container
+        borderRadius: radius.sm,
+        alignSelf: 'flex-start',
+        borderWidth: 1,
+        borderColor: colors.border,
+    },
+    // ...
+    tooltipContainer: {
+        maxWidth: 320,
+        overflow: 'hidden',
+        backgroundColor: colors.backgroundLight, // Flat
+        borderWidth: 1,
+        borderColor: colors.border,
    },
    backButton: {
        zIndex: 10,
@@ -482,17 +564,7 @@ const styles = StyleSheet.create({
    },

    // Premium Banner
-    premiumBanner: {
-        marginHorizontal: spacing.lg,
-        marginBottom: spacing.lg,
-        borderRadius: radius.md,
-        overflow: 'hidden',
-        shadowColor: colors.premium.gold,
-        shadowOffset: { width: 0, height: 4 },
-        shadowOpacity: 0.3,
-        shadowRadius: 8,
-        elevation: 8,
-    },
+
    premiumBannerContent: {
        flexDirection: 'row',
        alignItems: 'center',
@@ -519,49 +591,32 @@ const styles = StyleSheet.create({
    labelPremium: {
        color: colors.premium.gold,
    },
-    iconWrapper: {
-        position: 'relative',
+    explicitBadge: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        backgroundColor: colors.error,
+        paddingHorizontal: spacing.md,
+        paddingVertical: spacing.xs,
+        borderRadius: radius.full,
+        gap: spacing.xs,
        marginBottom: spacing.md,
    },
+    explicitBadgeText: {
+        ...typography.caption2,
+        fontWeight: '700',
+        color: colors.text,
+        letterSpacing: 1,
+    },
+
+    // Removed glow styles
    iconGlowOuter: {
-        position: 'absolute',
-        top: -20,
-        left: -20,
-        right: -20,
-        bottom: -20,
-        borderRadius: 60,
-        backgroundColor: 'rgba(212, 175, 55, 0.08)',
+        display: 'none',
    },
    iconGlow: {
-        position: 'absolute',
-        top: -10,
-        left: -10,
-        right: -10,
-        bottom: -10,
-        borderRadius: 50,
-        backgroundColor: 'rgba(212, 175, 55, 0.2)',
-    },
-    iconContainer: {
-        width: 72,
-        height: 72,
-        borderRadius: 36,
-        backgroundColor: 'rgba(255, 255, 255, 0.06)',
-        justifyContent: 'center',
-        alignItems: 'center',
-        borderWidth: 1,
-        borderColor: 'rgba(255, 255, 255, 0.1)',
-        overflow: 'hidden',
-    },
-    iconContainerPremium: {
-        borderColor: colors.premium.gold,
-        borderWidth: 2,
-        backgroundColor: 'rgba(212, 175, 55, 0.15)',
-        shadowColor: colors.premium.gold,
-        shadowOffset: { width: 0, height: 0 },
-        shadowOpacity: 0.5,
-        shadowRadius: 12,
-        elevation: 8,
+        display: 'none',
    },
+
+
    crownBadge: {
        position: 'absolute',
        top: -4,
@@ -647,17 +702,7 @@ const styles = StyleSheet.create({
        paddingHorizontal: spacing.md,
        marginBottom: spacing.md,
    },
-    statsBadge: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        gap: spacing.xs,
-        backgroundColor: 'rgba(233, 69, 96, 0.1)',
-        paddingHorizontal: spacing.lg,
-        paddingVertical: spacing.sm,
-        borderRadius: radius.full,
-        borderWidth: 1,
-        borderColor: 'rgba(233, 69, 96, 0.2)',
-    },
+
    statsBadgePremium: {
        backgroundColor: 'rgba(212, 175, 55, 0.1)',
        borderColor: 'rgba(212, 175, 55, 0.3)',
@@ -676,13 +721,7 @@ const styles = StyleSheet.create({
        paddingHorizontal: spacing.md,
        paddingBottom: Platform.OS === 'ios' ? 100 : 80,
    },
-    questionCard: {
-        backgroundColor: 'rgba(22, 33, 62, 0.4)',
-        borderRadius: radius.md,
-        borderWidth: 1,
-        borderColor: 'rgba(255, 255, 255, 0.06)',
-        marginBottom: spacing.sm,
-    },
+
    questionContent: {
        padding: spacing.md,
    },
@@ -697,17 +736,7 @@ const styles = StyleSheet.create({
        marginBottom: spacing.sm,
        lineHeight: 22,
    },
-    partnerTextContainer: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        gap: spacing.xs,
-        marginBottom: spacing.sm,
-        paddingVertical: spacing.xs,
-        paddingHorizontal: spacing.sm,
-        backgroundColor: 'rgba(232, 164, 174, 0.1)',
-        borderRadius: radius.sm,
-        alignSelf: 'flex-start',
-    },
+
    partnerText: {
        ...typography.caption1,
        color: colors.premium.rose,
@@ -755,10 +784,7 @@ const styles = StyleSheet.create({
        alignItems: 'center',
        padding: spacing.lg,
    },
-    tooltipContainer: {
-        maxWidth: 320,
-        overflow: 'hidden',
-    },
+
    tooltipTitle: {
        ...typography.title3,
        color: colors.text,
@@ -5,13 +5,16 @@
  },
  "build": {
    "development": {
+      "node": "20.10.0",
      "developmentClient": true,
      "distribution": "internal"
    },
    "preview": {
+      "node": "20.10.0",
      "distribution": "internal"
    },
    "production": {
+      "node": "20.10.0",
      "autoIncrement": true,
      "env": {
        "EXPO_PUBLIC_SUPABASE_URL": "https://ckjcrkjpmhqhiucifukx.supabase.co",
Author	SHA1	Message	Date
jjbrunton	45499edc9a	Fix chat message race condition on notification tap	2026-01-25 20:29:11 +00:00
jjbrunton	0711080112	Remove partner text from shareable card	2026-01-25 19:57:34 +00:00
jjbrunton	a531f43d91	Fix premium access check and tab bar styling	2026-01-25 19:56:47 +00:00
jjbruntonandClaude Opus 4.5	1e4974e2a0	Rename add_question_types to earlier timestamp The migration needs to run before add_question_type_to_recommended_questions which depends on the question_type enum. Both had timestamp 20260125110000, causing alphabetical sort to run them in wrong order. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 19:36:48 +00:00
jjbruntonandClaude Opus 4.5	7952d98d18	Make add_question_types migration idempotent - Use IF NOT EXISTS for CREATE TYPE - Use ADD COLUMN IF NOT EXISTS for ALTER TABLE - Use DROP POLICY IF EXISTS before CREATE POLICY This allows the migration to run safely even if schema already exists. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 19:35:25 +00:00
jjbruntonandClaude Opus 4.5	d4e05bc7ff	Add --include-all flag to db push in CI Allows migrations with timestamps before existing remote migrations to be applied. Needed when migration files are renamed or when environments have diverged. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 19:34:18 +00:00
jjbruntonandClaude Opus 4.5	a6b3b6a251	Reposition app as relationship improvement tool Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 19:30:42 +00:00
jjbruntonandClaude Opus 4.5	9402369246	Rename migration to fix timestamp ordering The add_question_types migration had an earlier timestamp than add_color_to_categories which was already applied to production. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 19:24:23 +00:00
jjbrunton	1daf386765	Add question types, nudge feature, and share modal - Add new question card components (photo, audio, text, who-likely) - Add share preview modal for matches - Add nudge notification system with rate limiting - Add session-based notification improvements - Add match confetti celebration animation - Update onboarding flow with paywall tracking - Remove deprecated swipe card and tutorial components - Update GlassCard/GlassInput to use solid backgrounds - Fix routing issues after packs screen removal	2026-01-25 19:17:39 +00:00
jjbrunton	8612b16b93	Enable admin question types and category grouping Keep shared linting configured for the repo.	2026-01-25 11:53:42 +00:00
jjbrunton	6c2e471d47	Make profile picture mandatory and show partner avatar	2026-01-25 10:21:06 +00:00
jjbruntonandClaude Opus 4.5	69ac0940d3	Add discovery UI, hide NSFW setting, and pack progress - New discovery components (ContentTile, ContentRow, CircularProgress) - Refactor home screen with compact header and content tiles - Add hide_nsfw profile setting for content filtering - Add color column to categories table - Track pack progress (answered/total questions) - Update related stores and tests Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 10:14:44 +00:00
jjbruntonandClaude Opus 4.5	bc38e41572	Deploy migrations and functions to both non-prod and prod Use matrix strategy to deploy sequentially: non-prod first, then prod. This ensures both environments stay in sync and provides a safety gate. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-25 09:50:58 +00:00
jjbruntonandClaude Opus 4.5	6f1be7a4e1	Fix supabase-js Deno compatibility by pinning to v2.45.0 The latest supabase-js@2.92.0 has a Deno compatibility bug with createRequire that causes all edge functions to fail with: "The argument 'filename' must be a file URL object..." Pin all edge functions to @2.45.0 with ?target=deno parameter to ensure Deno-compatible builds from esm.sh. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:55:35 +00:00
jjbruntonandClaude Opus 4.5	f88ee513d4	Fix function list parsing to skip header rows Use grep to only match lines starting with lowercase (function names), and add validation to skip empty or invalid names. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:45:01 +00:00
jjbruntonandClaude Opus 4.5	5ae776d921	Use --workdir apps for all Supabase CLI commands CLI expects supabase/functions/ relative to workdir, so --workdir apps makes it find apps/supabase/functions/. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:43:19 +00:00
jjbruntonandClaude Opus 4.5	dcf5588d55	Fix functions deploy to run from apps/supabase directory Supabase CLI expects functions in supabase/functions/ relative to workdir. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:42:18 +00:00
jjbruntonandClaude Opus 4.5	df9f711a3e	Add --project-ref to functions deploy command Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:41:10 +00:00
jjbruntonandClaude Opus 4.5	9ce864afa5	Fix db push by running supabase link from correct directory supabase db push doesn't support --project-ref, it relies on link. Run link from apps/supabase so the config is in the right place. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:40:09 +00:00
jjbruntonandClaude Opus 4.5	22a2c8b5c6	Add workflow_dispatch and self-trigger to deploy workflow - Allow manual triggering via workflow_dispatch - Trigger on changes to the workflow file itself Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:37:48 +00:00
jjbruntonandClaude Opus 4.5	b090400604	Fix supabase db push in CI by passing --project-ref directly The supabase link command was running from repo root while db push ran from apps/supabase, causing it to not find the linked project. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:36:33 +00:00
jjbruntonandClaude Opus 4.5	4b6df665f3	Fix Terraform type coercion in SMTP settings merge Separate string and numeric settings into different locals to prevent merge() from coercing integers to strings. The Supabase API requires rate_limit_email_sent to be an integer. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:25:44 +00:00
jjbruntonandClaude Opus 4.5	c309fbaa98	Clean up Terraform: remove duplicate workspace-based config - Remove root-level main.tf, variables.tf, outputs.tf, versions.tf (duplicated the module-based approach) - Remove duplicate terraform/templates/ directory - Remove stale terraform.tfvars.example and .terraform.lock.hcl - Remove outdated scripts/import-production.sh - Fix non-prod SMTP error by using merge() to completely omit SMTP fields instead of setting them to null - Update README to remove workspace migration section The environment directories approach (terraform/environments/*) is now the only supported method. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-24 21:21:54 +00:00
jjbrunton	7e2e723880	Align prod schema and deploy tooling	2026-01-24 20:16:01 +00:00
jjbrunton	d2db86ec7f	Update	2026-01-23 21:54:27 +00:00
jjbrunton	2ad85f6009	Update App Store URLs and bump Android version	2026-01-18 14:48:07 +00:00
jjbrunton	19a6bb7cda	Add Google Play links to web	2026-01-17 23:27:44 +00:00
jjbrunton	e28dcc1592	Fix match modal question display	2026-01-17 23:00:36 +00:00
jjbrunton	3e70669a27	Add match notification digests	2026-01-17 20:16:05 +00:00
jjbrunton	b070a6f6a2	Add profile photo to onboarding flow	2026-01-17 19:22:36 +00:00
jjbrunton	349f460e15	Add guest auth and save-account flow Introduce anonymous sign-in with in-app saving, guest recovery warnings, paywall prompts, and admin guest labeling.	2026-01-17 17:55:06 +00:00
jjbrunton	ce68d57a49	Update comfort zone dialogs to explain gate logic	2026-01-17 17:21:04 +00:00
jjbrunton	b8c271cce1	Add show all intensities toggle on packs page	2026-01-17 17:12:10 +00:00
jjbruntonandClaude Opus 4.5	a0049b7f8a	Add couple comfort zone gate toggle and bump version Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-17 16:59:02 +00:00
jjbrunton	494ed17fe2	Add streaks, scheduled releases, and notification settings - Couple streaks with milestone notifications - Scheduled pack releases with admin UI - Notification preferences screen - Refactored profile settings screens - Partner activity notifications	2026-01-17 16:38:47 +00:00
jjbrunton	12f312421b	Fix Firebase Analytics setup and disable ad ID	2026-01-16 23:36:52 +00:00
jjbrunton	a558f5e67e	Use RPC function for gift premium to fix RLS issues	2026-01-16 18:41:21 +00:00
jjbrunton	0be833bba2	Add gift_premium permission for admin users	2026-01-16 18:31:47 +00:00
jjbrunton	1911f8f058	Switch analytics from PostHog to Firebase	2026-01-16 15:38:17 +00:00
jjbrunton	23e24aa4c2	Fix admin user detail page not showing email	2026-01-16 14:57:40 +00:00
jjbruntonandClaude Opus 4.5	e671ae9d1c	Add admin user details, pack notifications, remove crypto - Add enabled packs and feature interests to admin user page - Add clickable links from responses to packs in admin - Add pack change notification edge function - Remove react-native-quick-crypto (unused E2EE) - Bump mobile version to 1.0.1 (versionCode 22) - Add EAS config and preview build scripts - Gitignore keystore and APK files Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-11 19:03:34 +00:00
jjbrunton	a7a13c9614	Add release notes and fix answer gap deadlock - Add mobile release notes for v1.0.1 - Fix answer gap deadlock with NET gap calculation - Randomize question order for variety - Dismiss keyboard when match modal appears - Add keyboard dismiss on chat scroll - Pin EAS build node version	2026-01-11 15:10:14 +00:00