@biggora/claude-plugins 1.0.0 → 1.1.0

package/src/skills/screen-recording/references/approach2-xvfb.md

@@ -0,0 +1,232 @@
+# Approach 2: Virtual Display Recording (Xvfb + FFmpeg x11grab)
+
+Capture a real running application on a virtual screen.
+
+## How It Works
+
+```
+Xvfb :99  ←── virtual display (invisible, in RAM)
+    ↑
+Your app runs here (DISPLAY=:99)
+    ↓
+FFmpeg x11grab ←── records the virtual display → MP4
+```
+
+## Full Working Template
+
+```python
+#!/usr/bin/env python3
+"""
+Virtual Display Screen Recorder
+Launches a real app on a virtual display and records it.
+"""
+
+import subprocess, os, time, signal, shutil
+
+WIDTH, HEIGHT = 1280, 720
+DISPLAY_NUM = ":99"
+FPS = 24
+DURATION = 30  # seconds to record
+OUTPUT = "/home/claude/recording.mp4"
+
+
+def start_virtual_display():
+    """Start Xvfb virtual display"""
+    proc = subprocess.Popen([
+        "Xvfb", DISPLAY_NUM,
+        "-screen", "0", f"{WIDTH}x{HEIGHT}x24",
+        "-ac", "-nolisten", "tcp"
+    ], stderr=subprocess.DEVNULL)
+    time.sleep(1.0)  # wait for display to initialize
+    print(f"✅ Virtual display {DISPLAY_NUM} started (PID {proc.pid})")
+    return proc
+
+
+def start_recording(output_path, duration=None):
+    """Start FFmpeg recording of virtual display"""
+    cmd = [
+        "ffmpeg",
+        "-f", "x11grab",
+        "-video_size", f"{WIDTH}x{HEIGHT}",
+        "-framerate", str(FPS),
+        "-i", DISPLAY_NUM,
+        "-c:v", "libx264",
+        "-preset", "ultrafast",
+        "-pix_fmt", "yuv420p",
+    ]
+    if duration:
+        cmd.extend(["-t", str(duration)])
+    cmd.extend([output_path, "-y", "-loglevel", "quiet"])
+    
+    proc = subprocess.Popen(cmd)
+    time.sleep(0.5)
+    print(f"✅ Recording started → {output_path}")
+    return proc
+
+
+def run_app_on_display(app_command, env_extra=None):
+    """Run an application on the virtual display"""
+    env = os.environ.copy()
+    env["DISPLAY"] = DISPLAY_NUM
+    if env_extra:
+        env.update(env_extra)
+    proc = subprocess.Popen(app_command, env=env, stderr=subprocess.DEVNULL)
+    return proc
+
+
+def record_session(app_fn, duration=30, output=OUTPUT):
+    """
+    Full recording session:
+    1. Start virtual display
+    2. Start recording
+    3. Run app_fn(display) — your automation code
+    4. Stop recording, stop display
+    """
+    xvfb = start_virtual_display()
+    recorder = start_recording(output, duration)
+    
+    try:
+        app_fn(DISPLAY_NUM)
+        # Wait remaining time or until done
+        time.sleep(duration)
+    finally:
+        recorder.send_signal(signal.SIGINT)
+        recorder.wait()
+        xvfb.terminate()
+        xvfb.wait()
+        print(f"✅ Recording saved: {os.path.getsize(output):,} bytes")
+    
+    return output
+
+
+# ── EXAMPLE: Record a Python Tkinter app ─────────────────────────────────────
+
+def my_tkinter_app_script():
+    return '''
+import tkinter as tk
+import time
+
+root = tk.Tk()
+root.title("My App Demo")
+root.geometry("1280x720")
+root.configure(bg="#0c0c20")
+
+label = tk.Label(root, text="Loading...", font=("Arial", 48), 
+                 bg="#0c0c20", fg="white")
+label.pack(pady=200)
+
+def update():
+    texts = ["Detecting issues...", "Processing...", "✅ Complete!", "100% Accurate"]
+    for i, t in enumerate(texts):
+        root.after(i * 2000, lambda t=t: label.configure(text=t))
+    root.after(8000, root.destroy)
+
+root.after(500, update)
+root.mainloop()
+'''
+
+def run_demo(display):
+    # Write app to temp file
+    with open('/tmp/demo_app.py', 'w') as f:
+        f.write(my_tkinter_app_script())
+    
+    env = os.environ.copy()
+    env["DISPLAY"] = display
+    subprocess.Popen(["python3", "/tmp/demo_app.py"], env=env)
+    time.sleep(10)  # let app run
+
+
+# ── EXAMPLE: Record a Chromium browser session ───────────────────────────────
+
+def record_browser(url, duration=20, output=OUTPUT):
+    """Record a browser navigating to a URL"""
+    xvfb = start_virtual_display()
+    recorder = start_recording(output, duration)
+    
+    env = os.environ.copy()
+    env["DISPLAY"] = DISPLAY_NUM
+    
+    # Launch Chromium in window mode (not headless — we WANT it visible)
+    subprocess.Popen([
+        "chromium", "--no-sandbox",
+        f"--window-size={WIDTH},{HEIGHT}",
+        "--window-position=0,0",
+        "--start-maximized",
+        url
+    ], env=env, stderr=subprocess.DEVNULL)
+    
+    time.sleep(duration)
+    recorder.send_signal(signal.SIGINT)
+    recorder.wait()
+    xvfb.terminate()
+    print(f"✅ Browser recording saved: {output}")
+    return output
+
+
+# ── POST-PROCESSING ───────────────────────────────────────────────────────────
+
+def add_narration(video_path, narration_text, output_path):
+    """Add TTS narration to a recorded video"""
+    import pyttsx3
+    
+    engine = pyttsx3.init()
+    engine.setProperty('rate', 140)
+    engine.save_to_file(narration_text, '/tmp/narration.wav')
+    engine.runAndWait()
+    
+    subprocess.run([
+        'ffmpeg', '-i', '/tmp/narration.wav', 
+        '-c:a', 'libmp3lame', '-b:a', '128k',
+        '/tmp/narration.mp3', '-y', '-loglevel', 'quiet'
+    ])
+    
+    subprocess.run([
+        'ffmpeg', '-i', video_path, '-i', '/tmp/narration.mp3',
+        '-c:v', 'copy', '-c:a', 'aac',
+        '-shortest', output_path, '-y', '-loglevel', 'quiet'
+    ])
+    return output_path
+
+
+def add_overlay_text(video_path, text, position="bottom", output_path=None):
+    """Add text overlay to recorded video using FFmpeg"""
+    if not output_path:
+        output_path = video_path.replace('.mp4', '_overlay.mp4')
+    
+    if position == "bottom":
+        vf = f"drawtext=text='{text}':fontcolor=white:fontsize=24:x=(w-text_w)/2:y=h-th-20:box=1:boxcolor=black@0.5"
+    else:
+        vf = f"drawtext=text='{text}':fontcolor=white:fontsize=24:x=20:y=20"
+    
+    subprocess.run([
+        'ffmpeg', '-i', video_path, '-vf', vf,
+        output_path, '-y', '-loglevel', 'quiet'
+    ])
+    return output_path
+
+
+if __name__ == "__main__":
+    result = record_session(run_demo, duration=12, output=OUTPUT)
+    # Add narration
+    final = add_narration(result, "This is our automated UI demo.", 
+                          "/home/claude/final_recording.mp4")
+    shutil.copy(final, "/mnt/user-data/outputs/recording.mp4")
+    print(f"🎉 Done: /mnt/user-data/outputs/recording.mp4")
+```
+
+## When to Use This Approach
+
+✅ When you need to show a REAL running application
+✅ When demonstrating web UI (real browser rendering)
+✅ When the app has complex visual state hard to reproduce with Pillow
+
+❌ Don't use for simple text/graphic demos (too slow — use Approach 1)
+❌ Avoid if network access to the app is needed (may be blocked)
+
+## Important Notes
+
+- Xvfb uses RAM for the framebuffer — 1280x720x24 ≈ 3.5MB per frame
+- Always kill both `ffmpeg` and `Xvfb` in a `finally` block to avoid orphan processes
+- Use `DISPLAY=:99` not `:0` to avoid conflicts with any host display
+- FFmpeg's `-preset ultrafast` is recommended for real-time capture
+- For longer recordings (>60s), consider `-crf 28` to reduce file size

package/src/skills/screen-recording/references/design-patterns.md

@@ -0,0 +1,168 @@
+# Design Patterns for Screen Recording Videos
+
+## UI Component Library (Pillow)
+
+### Rounded Rectangle
+```python
+def rounded_rect(draw, x, y, w, h, r, fill=None, outline=None, width=1):
+    draw.rectangle([x+r, y, x+w-r, y+h], fill=fill)
+    draw.rectangle([x, y+r, x+w, y+h-r], fill=fill)
+    draw.ellipse([x, y, x+2*r, y+2*r], fill=fill)
+    draw.ellipse([x+w-2*r, y, x+w, y+2*r], fill=fill)
+    draw.ellipse([x, y+h-2*r, x+2*r, y+h], fill=fill)
+    draw.ellipse([x+w-2*r, y+h-2*r, x+w, y+h], fill=fill)
+    if outline:
+        draw.arc([x, y, x+2*r, y+2*r], 180, 270, fill=outline, width=width)
+        draw.arc([x+w-2*r, y, x+w, y+2*r], 270, 360, fill=outline, width=width)
+        draw.arc([x, y+h-2*r, x+2*r, y+h], 90, 180, fill=outline, width=width)
+        draw.arc([x+w-2*r, y+h-2*r, x+w, y+h], 0, 90, fill=outline, width=width)
+        draw.line([x+r, y, x+w-r, y], fill=outline, width=width)
+        draw.line([x+r, y+h, x+w-r, y+h], fill=outline, width=width)
+        draw.line([x, y+r, x, y+h-r], fill=outline, width=width)
+        draw.line([x+w, y+r, x+w, y+h-r], fill=outline, width=width)
+```
+
+### Notification Toast
+```python
+def draw_toast(draw, message, t, appear_at=0, dismiss_at=3, icon="✓", color=(60,200,100)):
+    p = ease(max(0, t - appear_at), 0.4)
+    if t > dismiss_at:
+        p = 1 - ease(t - dismiss_at, 0.3)
+    if p <= 0:
+        return
+    x, y = 900, int(30 + (1-p) * -80)
+    draw.rectangle([x, y, x+340, y+60], fill=(30, 40, 30), 
+                   outline=color, width=2)
+    draw.text((x+15, y+18), f"{icon} {message}", fill=color)
+```
+
+### Metric Card
+```python
+def draw_metric(draw, x, y, label, value, unit="", trend=None):
+    draw.rectangle([x, y, x+220, y+110], fill=(20, 25, 55), 
+                   outline=(60, 80, 160), width=1)
+    draw.text((x+12, y+10), label, fill=(140, 140, 180))
+    draw.text((x+12, y+45), str(value), fill=(255, 255, 255))
+    if unit:
+        draw.text((x+12+len(str(value))*18, y+55), unit, fill=(140, 140, 180))
+    if trend == "up":
+        draw.text((x+180, y+10), "↑", fill=(60, 200, 100))
+    elif trend == "down":
+        draw.text((x+180, y+10), "↓", fill=(255, 80, 80))
+```
+
+### Simple Bar Chart
+```python
+def draw_bar_chart(draw, data, x, y, w, h, t, animate=True):
+    """data = [(label, value), ...]"""
+    max_val = max(v for _, v in data)
+    bar_w = w // len(data) - 10
+    
+    for i, (label, val) in enumerate(data):
+        p = ease(t, 1.0) if animate else 1.0
+        bar_h = int((val / max_val) * h * p)
+        bx = x + i * (bar_w + 10)
+        # Bar
+        draw.rectangle([bx, y+h-bar_h, bx+bar_w, y+h], fill=(60, 120, 255))
+        # Label
+        draw.text((bx, y+h+8), label, fill=(140, 140, 180))
+        # Value
+        if p > 0.7:
+            draw.text((bx, y+h-bar_h-24), str(val), fill=(240, 240, 255))
+```
+
+## Transition Patterns
+
+### Fade between scenes
+```python
+def cross_fade(draw_a, draw_b, t, fade_start, fade_duration, img_size):
+    if t < fade_start:
+        draw_a(...)
+    elif t < fade_start + fade_duration:
+        p = ease(t - fade_start, fade_duration)
+        # Render both on separate images and blend
+        img_a = render_scene_a(t)
+        img_b = render_scene_b(t - fade_start)
+        return Image.blend(img_a, img_b, p)
+    else:
+        draw_b(...)
+```
+
+### Slide transition
+```python
+def slide_in(draw, content_fn, t, direction="left", duration=0.5):
+    p = ease(t, duration)
+    if direction == "left":
+        offset_x = int((1 - p) * 1280)
+        # Draw content shifted right, moving left
+        # Use PIL paste with offset
+    elif direction == "up":
+        offset_y = int((1 - p) * 720)
+```
+
+## Narration Script Patterns
+
+### Per-scene narration timing
+```python
+SCENES = [
+    {"id": "intro",   "duration": 4, "narration": "Welcome to our demo."},
+    {"id": "feature", "duration": 6, "narration": "Our system detects issues automatically."},
+]
+
+def build_full_narration(scenes):
+    """Concatenate all narrations for single TTS call"""
+    # Add natural pauses between scenes
+    parts = []
+    for s in scenes:
+        parts.append(s["narration"])
+        parts.append("...")  # pause
+    return " ".join(parts)
+```
+
+### Voice settings
+```python
+engine = pyttsx3.init()
+
+# Speed: 100=slow, 150=normal, 200=fast
+engine.setProperty('rate', 140)
+
+# Volume: 0.0-1.0
+engine.setProperty('volume', 0.9)
+
+# List available voices (usually 1-2 with espeak)
+voices = engine.getProperty('voices')
+for v in voices:
+    print(v.id, v.name, v.languages)
+# Set voice by ID
+engine.setProperty('voice', voices[0].id)
+```
+
+## File Size Optimization
+
+```python
+# For web delivery: compress output
+subprocess.run([
+    'ffmpeg', '-i', 'output.mp4',
+    '-c:v', 'libx264', '-crf', '28',     # 23=good, 28=smaller, 35=small
+    '-preset', 'slow',                    # slow=better compression
+    '-c:a', 'aac', '-b:a', '96k',
+    'output_compressed.mp4', '-y', '-loglevel', 'quiet'
+])
+
+# For GIF (social media / documentation)
+subprocess.run([
+    'ffmpeg', '-i', 'output.mp4',
+    '-vf', 'fps=10,scale=960:-1:flags=lanczos',
+    '-loop', '0',
+    'demo.gif', '-y', '-loglevel', 'quiet'
+])
+```
+
+## Checklist Before Rendering
+
+- [ ] All scenes have `draw_fn` implemented
+- [ ] `total_duration = sum(s["duration"] for s in SCENES)` is correct
+- [ ] `make_frame` returns `np.array(img)` (not PIL Image)
+- [ ] Audio `.with_duration(total_duration)` called
+- [ ] Output path is in `/home/claude/` first, then copied to `/mnt/user-data/outputs/`
+- [ ] `apt-get install -y espeak-ng` was run if pyttsx3 is used

package/src/skills/test-mobile-app/SKILL.md

@@ -0,0 +1,212 @@
+---
+name: test-mobile-app
+description: >
+  Automated mobile application testing skill. Use this skill whenever the user
+  wants to test a mobile app (Android or iOS), write test cases, analyze app
+  structure, run automated UI tests via emulator, or generate test reports.
+  Trigger when user mentions: "test my app", "run tests", "UI testing",
+  "write test cases", "check app functionality", "test on emulator",
+  "mobile QA", "test coverage", "use case testing", "user scenario testing",
+  or any combination of mobile + test/check/verify/validate.
+  Also trigger when user uploads or references an APK, .ipa, or a mobile
+  project folder (React Native, Flutter, Android, iOS) and asks what to do next.
+  Always use this skill for any mobile app QA task — even partial ones like
+  "just write some use cases" or "show me what tests I should run".
+---
+
+# Mobile App Testing Skill
+
+This skill enables Claude to perform end-to-end mobile application testing:
+1. **Analyze** the app structure and infer user-facing functionality
+2. **Generate** use cases from an end-user perspective
+3. **Write** concrete test scenarios with expected results
+4. **Execute** tests via Appium + Android emulator (or interpret results statically)
+5. **Produce** a structured HTML/Markdown test report
+
+---
+
+## Phase 1 — App Analysis
+
+### What to collect
+
+Before generating use cases, gather as much context as possible:
+
+- **Source code** (Android/Java/Kotlin, iOS/Swift, React Native, Flutter)
+- **APK file** — use `androguard` to extract Activity list, permissions, Manifest
+- **Screenshots** — analyze UI from images
+- **Description** — what the app does, target audience
+
+### APK Analysis (Android)
+
+Read `scripts/analyze_apk.py` for full script. Quick usage:
+```bash
+python3 scripts/analyze_apk.py path/to/app.apk
+```
+Outputs: package name, activities, permissions, strings → feeds into use case generation.
+
+### Source Code Analysis
+
+If source is available, scan for:
+- Screen/Activity/Fragment/Page names → each is a potential use case surface
+- Navigation graphs (React Navigation, NavController)
+- API endpoints called (network requests)
+- Form fields, validation logic
+- Authentication flows
+
+---
+
+## Phase 2 — Use Case Generation
+
+### Methodology
+
+Think from the perspective of a **real end user** — not a developer.
+Ask: *"What would a person actually do with this app?"*
+
+Use case format:
+```
+UC-<N>: <Short Title>
+Actor: End User
+Precondition: <What must be true before this action>
+Steps:
+  1. <action>
+  2. <action>
+  ...
+Expected outcome: <what the user sees/gets>
+Priority: High / Medium / Low
+```
+
+### Use Case Categories to Always Cover
+
+1. **Onboarding** — first launch, tutorial, permissions prompt
+2. **Authentication** — registration, login, logout, password reset
+3. **Core Feature Flow** — the primary value action of the app (1-3 flows)
+4. **Data Entry** — any form: required fields, validation, error states
+5. **Navigation** — bottom nav, back button, deep links
+6. **Empty States** — what happens when there's no data
+7. **Error Handling** — no internet, server error, invalid input
+8. **Settings / Profile** — change preferences, update data
+9. **Notifications** — if the app uses push notifications
+10. **Accessibility** — basic: is text readable, are tap targets big enough
+
+Aim for **15–30 use cases** depending on app complexity.
+
+---
+
+## Phase 3 — Test Scenario Writing
+
+For each use case, write a test scenario:
+
+```
+TEST-<N>: <Title>
+Related UC: UC-<N>
+Type: Functional | UI | Regression | Smoke
+Steps:
+  1. Launch app
+  2. <specific action with exact input data>
+  3. ...
+Assertions:
+  - Element <locator> is visible
+  - Text "<expected>" is displayed
+  - Screen navigates to <ScreenName>
+  - No crash / error dialog
+Expected Result: PASS / FAIL criteria
+```
+
+### Test Types to Include
+
+| Type | When to use |
+|------|-------------|
+| **Smoke** | Quick sanity — does app launch, core screens load? |
+| **Functional** | Does feature X work correctly? |
+| **UI/Visual** | Are elements present, correctly labeled, accessible? |
+| **Edge Case** | Empty fields, special characters, very long strings |
+| **Regression** | After a change — did existing features break? |
+
+---
+
+## Phase 4 — Test Execution
+
+### Environment Setup
+
+Read `references/setup-appium.md` for full Appium + emulator setup.
+
+**Quick check:**
+```bash
+python3 scripts/check_environment.py
+```
+This verifies: adb, emulator, Appium server, Python client.
+
+### Running Tests
+
+```bash
+# Run all tests
+python3 scripts/run_tests.py --apk path/to/app.apk --output results/
+
+# Run smoke tests only
+python3 scripts/run_tests.py --apk path/to/app.apk --suite smoke --output results/
+
+# Run on specific device
+python3 scripts/run_tests.py --apk path/to/app.apk --device emulator-5554 --output results/
+```
+
+### Test Execution Without Emulator (Static Mode)
+
+If no emulator is available, Claude can:
+1. Analyze source code / screenshots statically
+2. Write all test scenarios
+3. Mark execution status as `MANUAL_REQUIRED`
+4. Generate a report with all test cases ready to be run manually
+
+Use `--static` flag:
+```bash
+python3 scripts/run_tests.py --static --output results/
+```
+
+---
+
+## Phase 5 — Report Generation
+
+```bash
+python3 scripts/generate_report.py --results results/ --output test_report.html
+```
+
+Report includes:
+- Summary: total tests, passed, failed, skipped
+- Per-test details: steps, assertions, actual vs expected, screenshots
+- Use case coverage matrix
+- Issues found (with severity: Critical / Major / Minor)
+- Environment info (device, OS, app version)
+
+Read `references/report-template.md` for report structure details.
+
+---
+
+## Workflow Summary
+
+```
+1. Receive app (APK / source / description / screenshots)
+        ↓
+2. Run analyze_apk.py OR inspect source code
+        ↓
+3. Generate use cases (UC-1...UC-N) — show to user, ask for feedback
+        ↓
+4. Write test scenarios (TEST-1...TEST-N) — derive from use cases
+        ↓
+5. Check environment (check_environment.py)
+        ↓
+6a. Emulator available → run_tests.py → capture results
+6b. No emulator → static mode → mark for manual execution
+        ↓
+7. generate_report.py → HTML report → present to user
+```
+
+---
+
+## Important Notes
+
+- **Always show use cases to the user before writing tests** — they know their app best.
+- **Locators**: Prefer `accessibility id` > `resource-id` > `xpath`. Never use index-based xpath.
+- **Waits**: Always use explicit waits (`WebDriverWait`), never `time.sleep`.
+- **Screenshots**: Capture on every assertion failure automatically.
+- **Crash detection**: After every interaction, check for crash dialogs (`scripts/crash_detector.py`).
+- **Language**: Generate use cases and reports in the language the user is using.

package/src/skills/test-mobile-app/references/report-template.md

@@ -0,0 +1,95 @@
+# Test Report Structure
+
+## tests.json Format
+
+This is the input format for `run_tests.py`:
+
+```json
+{
+  "app": "com.example.myapp",
+  "version": "1.2.3",
+  "generated_at": "2025-01-01T12:00:00",
+  "use_cases": [
+    {
+      "id": "UC-1",
+      "title": "User Login with valid credentials",
+      "priority": "High"
+    }
+  ],
+  "tests": [
+    {
+      "id": "TEST-001",
+      "title": "Successful login with valid email and password",
+      "related_uc": "UC-1",
+      "type": "smoke",
+      "steps": [
+        { "action": "Launch app", "type": "wait", "seconds": 2 },
+        { "action": "Tap Login button", "type": "tap", "locator": "Login" },
+        { "action": "Enter email", "type": "type", "locator": "Email field", "value": "user@test.com" },
+        { "action": "Enter password", "type": "type", "locator": "Password field", "value": "password123" },
+        { "action": "Tap Submit", "type": "tap", "locator": "Submit" },
+        { "action": "Assert home screen visible", "type": "assert_text", "expected": "Welcome" },
+        { "action": "Assert no errors", "type": "assert_no_error" }
+      ],
+      "assertions": [
+        "Home screen is displayed",
+        "User name is shown",
+        "No error messages"
+      ]
+    }
+  ]
+}
+```
+
+## Step Action Types
+
+| type | Required fields | Description |
+|------|----------------|-------------|
+| `tap` | `locator` | Tap by accessibility id |
+| `tap_id` | `locator` | Tap by resource-id |
+| `type` | `locator`, `value` | Type text into field (by accessibility id) |
+| `type_id` | `locator`, `value` | Type text into field (by resource-id) |
+| `scroll_down` | — | Swipe screen upward |
+| `back` | — | Press hardware back button |
+| `wait` | `seconds` | Pause execution |
+| `assert_visible` | `locator` | Assert element present by accessibility id |
+| `assert_text` | `expected` | Assert text exists anywhere on screen |
+| `assert_no_error` | — | Assert no error/crash text on screen |
+
+## results.json Format (output)
+
+```json
+{
+  "timestamp": "2025-01-01T12:05:00",
+  "mode": "automated",
+  "apk": "app.apk",
+  "total": 10,
+  "passed": 7,
+  "failed": 2,
+  "errors": 0,
+  "manual": 1,
+  "tests": [
+    {
+      "test_id": "TEST-001",
+      "title": "Successful login",
+      "status": "PASS",
+      "steps_log": ["Step 1: Launch app", "Step 2: Tap Login"],
+      "assertions": [
+        { "check": "Text present: 'Welcome'", "passed": true }
+      ],
+      "error": null,
+      "screenshot_path": null,
+      "duration_ms": 3420,
+      "issues_found": []
+    }
+  ]
+}
+```
+
+## Issue Severity Levels
+
+| Severity | Criteria |
+|----------|----------|
+| **Critical** | App crash, data loss, cannot complete core flow |
+| **Major** | Feature broken, incorrect data displayed, error not handled |
+| **Minor** | Visual glitch, misleading label, minor UX issue |