@codyswann/lisa 2.195.4 → 2.195.7

package/plugins/lisa-expo/.codex-plugin/skills/jira-journey/scripts/generate-templates.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+"""Generate evidence comment templates from captured screenshots.
+
+Scans an evidence directory for screenshots, reads the journey JSON,
+and produces comment.txt (JIRA wiki markup) and comment.md (GitHub markdown).
+
+Usage:
+    python3 generate-templates.py <TICKET_ID> <PR_NUMBER> <BRANCH_NAME> <EVIDENCE_DIR> [JOURNEY_JSON]
+
+Example:
+    python3 generate-templates.py SE-3820 1299 fix/SE-3820-mobile ./evidence journey.json
+
+If JOURNEY_JSON is not provided, reads from stdin.
+"""
+
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_jira_server():
+    """Read JIRA server URL from jira-cli config."""
+    config_path = Path.home() / ".config" / ".jira" / ".config.yml"
+    if not config_path.exists():
+        print(f"ERROR: jira-cli config not found at {config_path}", file=sys.stderr)
+        sys.exit(1)
+
+    server = ""
+    with open(config_path) as f:
+        for line in f:
+            if line.startswith("server:"):
+                server = line.split(":", 1)[1].strip()
+                break
+
+    if not server:
+        print("ERROR: Could not read server from jira-cli config", file=sys.stderr)
+        sys.exit(1)
+
+    return server
+
+
+def get_github_repo():
+    """Detect GitHub repo from gh CLI."""
+    try:
+        result = subprocess.run(
+            ["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"],
+            capture_output=True, text=True, timeout=10,
+        )
+        return result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return ""
+
+
+def collect_screenshots(evidence_dir):
+    """Collect screenshot files sorted by name."""
+    evidence_path = Path(evidence_dir)
+    screenshots = []
+    for ext in ("*.png", "*.jpg", "*.jpeg", "*.gif"):
+        screenshots.extend(evidence_path.glob(ext))
+    return sorted(screenshots, key=lambda p: p.name)
+
+
+def group_by_viewport(screenshots):
+    """Group screenshots by viewport suffix.
+
+    Expects filenames like: 01-search-step-desktop.png
+    The last segment before .ext is the viewport name.
+    """
+    groups = {}
+    for path in screenshots:
+        stem = path.stem  # e.g., "01-search-step-desktop"
+        parts = stem.rsplit("-", 1)
+        if len(parts) == 2:
+            viewport = parts[1]
+        else:
+            viewport = "unknown"
+
+        if viewport not in groups:
+            groups[viewport] = []
+        groups[viewport].append(path)
+
+    return groups
+
+
+def generate_jira_wiki(ticket_id, pr_number, branch, screenshots, journey, gh_repo):
+    """Generate JIRA wiki markup comment."""
+    lines = []
+    lines.append(f"h2. Evidence — PR #{pr_number}")
+    lines.append("")
+    lines.append(f"*Branch:* {{{{{branch}}}}}")
+    lines.append(f"*PR:* [PR #{pr_number}|https://github.com/{gh_repo}/pull/{pr_number}]")
+    lines.append("")
+
+    # Verification Results from assertions
+    if journey.get("assertions"):
+        lines.append("h3. Verification Results")
+        lines.append("")
+        for assertion in journey["assertions"]:
+            lines.append(f"* {assertion}")
+        lines.append("")
+
+    # Visual Evidence grouped by viewport
+    lines.append("h3. Visual Evidence")
+    lines.append("")
+
+    viewport_groups = group_by_viewport(screenshots)
+
+    for viewport_info in journey.get("viewports", []):
+        vp_name = viewport_info["name"]
+        vp_key = vp_name.lower()
+        vp_width = viewport_info["width"]
+        vp_height = viewport_info["height"]
+
+        vp_screenshots = viewport_groups.get(vp_key, [])
+        if not vp_screenshots:
+            continue
+
+        # Use viewport width for JIRA image display, capped at 700
+        display_width = min(vp_width, 700)
+
+        lines.append(f"h4. {vp_name} ({vp_width}x{vp_height})")
+        lines.append("")
+
+        for img_path in vp_screenshots:
+            filename = img_path.name
+            # Extract readable label from filename
+            stem = img_path.stem
+            # Remove NN- prefix and -viewport suffix
+            label_parts = stem.split("-")[1:-1]
+            label = " ".join(label_parts).title() if label_parts else stem
+
+            lines.append(f"*{label}:*")
+            lines.append(f"!{filename}|width={display_width}!")
+            lines.append("")
+
+    # Verification Journey steps
+    if journey.get("steps"):
+        lines.append("h3. Verification Journey")
+        lines.append("")
+        for step in journey["steps"]:
+            text = step["text"]
+            # Remove [SCREENSHOT: ...] and [EVIDENCE: ...] markers from display text
+            clean_text = re.sub(r'\s*\[(SCREENSHOT|EVIDENCE):\s*[^\]]+\]', '', text).strip()
+            lines.append(f"# {clean_text}")
+        lines.append("")
+
+    # Viewports table
+    if journey.get("viewports"):
+        lines.append("h3. Key Viewports")
+        lines.append("")
+        lines.append("||Viewport||Resolution||")
+        for vp in journey["viewports"]:
+            lines.append(f"|{vp['name']}|{vp['width']}x{vp['height']}|")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_github_md(ticket_id, pr_number, branch, screenshots, journey, gh_repo):
+    """Generate GitHub markdown comment."""
+    jira_server = get_jira_server()
+    release_base = f"https://github.com/{gh_repo}/releases/download/pr-assets"
+
+    lines = []
+    lines.append(f"## Evidence — PR #{pr_number}")
+    lines.append("")
+    lines.append(f"**Branch:** `{branch}`")
+    lines.append(f"**Ticket:** [{ticket_id}]({jira_server}/browse/{ticket_id})")
+    lines.append("")
+
+    # Verification Results
+    if journey.get("assertions"):
+        lines.append("### Verification Results")
+        lines.append("")
+        for assertion in journey["assertions"]:
+            lines.append(f"- {assertion}")
+        lines.append("")
+
+    # Visual Evidence grouped by viewport
+    lines.append("### Visual Evidence")
+    lines.append("")
+
+    viewport_groups = group_by_viewport(screenshots)
+
+    for viewport_info in journey.get("viewports", []):
+        vp_name = viewport_info["name"]
+        vp_key = vp_name.lower()
+        vp_width = viewport_info["width"]
+        vp_height = viewport_info["height"]
+
+        vp_screenshots = viewport_groups.get(vp_key, [])
+        if not vp_screenshots:
+            continue
+
+        lines.append(f"#### {vp_name} ({vp_width}x{vp_height})")
+        lines.append("")
+
+        for img_path in vp_screenshots:
+            filename = img_path.name
+            stem = img_path.stem
+            label_parts = stem.split("-")[1:-1]
+            label = " ".join(label_parts).title() if label_parts else stem
+
+            lines.append(f"**{label}:**")
+            lines.append("")
+            lines.append(f"![{label}]({release_base}/{filename})")
+            lines.append("")
+
+    # Verification Journey
+    if journey.get("steps"):
+        lines.append("### Verification Journey")
+        lines.append("")
+        for step in journey["steps"]:
+            text = step["text"]
+            clean_text = re.sub(r'\s*\[(SCREENSHOT|EVIDENCE):\s*[^\]]+\]', '', text).strip()
+            lines.append(f"{step['number']}. {clean_text}")
+        lines.append("")
+
+    # Viewports table
+    if journey.get("viewports"):
+        lines.append("### Key Viewports")
+        lines.append("")
+        lines.append("| Viewport | Resolution |")
+        lines.append("|----------|-----------|")
+        for vp in journey["viewports"]:
+            lines.append(f"| {vp['name']} | {vp['width']}x{vp['height']} |")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def main():
+    if len(sys.argv) < 5:
+        print(
+            "Usage: generate-templates.py <TICKET_ID> <PR_NUMBER> <BRANCH_NAME> <EVIDENCE_DIR> [JOURNEY_JSON]",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    ticket_id = sys.argv[1]
+    pr_number = sys.argv[2]
+    branch = sys.argv[3]
+    evidence_dir = sys.argv[4]
+    journey_file = sys.argv[5] if len(sys.argv) > 5 else None
+
+    # Read journey JSON
+    if journey_file:
+        with open(journey_file) as f:
+            journey = json.load(f)
+    else:
+        journey = json.load(sys.stdin)
+
+    gh_repo = get_github_repo()
+    if not gh_repo:
+        print("ERROR: Could not detect GitHub repo — ensure gh CLI is authenticated", file=sys.stderr)
+        sys.exit(1)
+
+    screenshots = collect_screenshots(evidence_dir)
+    if not screenshots:
+        print(f"ERROR: No screenshots found in {evidence_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    # Generate templates
+    jira_wiki = generate_jira_wiki(ticket_id, pr_number, branch, screenshots, journey, gh_repo)
+    github_md = generate_github_md(ticket_id, pr_number, branch, screenshots, journey, gh_repo)
+
+    # Write templates
+    evidence_path = Path(evidence_dir)
+    (evidence_path / "comment.txt").write_text(jira_wiki)
+    (evidence_path / "comment.md").write_text(github_md)
+
+    print(f"Generated {evidence_path / 'comment.txt'} ({len(jira_wiki)} bytes)")
+    print(f"Generated {evidence_path / 'comment.md'} ({len(github_md)} bytes)")
+    print(f"Screenshots: {len(screenshots)}")
+
+
+if __name__ == "__main__":
+    main()

package/plugins/lisa-expo/.codex-plugin/skills/jira-journey/scripts/parse-plan.py

@@ -0,0 +1,368 @@
+#!/usr/bin/env python3
+"""Parse the Validation Journey section from a JIRA ticket description.
+
+Fetches the ticket via REST API, extracts the Validation Journey section
+(ADF or wiki markup), and outputs structured JSON to stdout.
+
+Usage:
+    python3 parse-plan.py <TICKET_ID>
+
+Example:
+    python3 parse-plan.py SE-3820
+
+Output (JSON):
+    {
+      "ticket": "SE-3820",
+      "prerequisites": ["Backend running", "Admin user"],
+      "steps": [
+        {"number": 1, "text": "Navigate to page", "screenshot": null},
+        {"number": 2, "text": "Click button [SCREENSHOT: btn]", "screenshot": "btn"}
+      ],
+      "viewports": [
+        {"name": "Desktop", "width": 1512, "height": 768}
+      ],
+      "assertions": ["Modal fills screen"]
+    }
+"""
+
+import json
+import os
+import re
+import subprocess
+import sys
+import urllib.request
+from base64 import b64encode
+from pathlib import Path
+
+
+def get_jira_config():
+    """Read JIRA server and login from jira-cli config."""
+    config_path = Path.home() / ".config" / ".jira" / ".config.yml"
+    if not config_path.exists():
+        print(f"ERROR: jira-cli config not found at {config_path}", file=sys.stderr)
+        sys.exit(1)
+
+    server = ""
+    login = ""
+    with open(config_path) as f:
+        for line in f:
+            if line.startswith("server:"):
+                server = line.split(":", 1)[1].strip()
+            elif line.startswith("login:"):
+                login = line.split(":", 1)[1].strip()
+
+    token = os.environ.get("JIRA_API_TOKEN", "")
+    if not token:
+        print("ERROR: JIRA_API_TOKEN env var not set", file=sys.stderr)
+        sys.exit(1)
+
+    return server, login, token
+
+
+def fetch_ticket(server, login, token, ticket_id):
+    """Fetch JIRA ticket via REST API v3 (returns ADF description)."""
+    url = f"{server}/rest/api/3/issue/{ticket_id}?fields=description"
+    auth = b64encode(f"{login}:{token}".encode()).decode()
+
+    req = urllib.request.Request(url, headers={
+        "Authorization": f"Basic {auth}",
+        "Accept": "application/json",
+    })
+
+    try:
+        with urllib.request.urlopen(req) as resp:
+            return json.loads(resp.read().decode())
+    except urllib.error.HTTPError as e:
+        print(f"ERROR: JIRA API returned {e.code} for {ticket_id}", file=sys.stderr)
+        sys.exit(1)
+
+
+def extract_text_from_adf(node):
+    """Recursively extract plain text from an ADF node."""
+    if isinstance(node, str):
+        return node
+
+    if isinstance(node, dict):
+        node_type = node.get("type", "")
+
+        if node_type == "text":
+            return node.get("text", "")
+
+        if node_type == "hardBreak":
+            return "\n"
+
+        parts = []
+        for child in node.get("content", []):
+            parts.append(extract_text_from_adf(child))
+        return "".join(parts)
+
+    if isinstance(node, list):
+        return "".join(extract_text_from_adf(item) for item in node)
+
+    return ""
+
+
+def find_heading_index(content, heading_text, level=None):
+    """Find the index of a heading node matching the given text."""
+    for i, node in enumerate(content):
+        if node.get("type") != "heading":
+            continue
+        if level is not None and node.get("attrs", {}).get("level") != level:
+            continue
+        text = extract_text_from_adf(node).strip().lower()
+        if heading_text.lower() in text:
+            return i
+    return -1
+
+
+def extract_section_content(content, start_idx, same_level=True):
+    """Extract all nodes between a heading and the next heading of same or higher level."""
+    if start_idx < 0 or start_idx >= len(content):
+        return []
+
+    heading_level = content[start_idx].get("attrs", {}).get("level", 2)
+    nodes = []
+
+    for i in range(start_idx + 1, len(content)):
+        node = content[i]
+        if node.get("type") == "heading":
+            node_level = node.get("attrs", {}).get("level", 2)
+            if same_level and node_level <= heading_level:
+                break
+        nodes.append(node)
+
+    return nodes
+
+
+def parse_prerequisites(nodes):
+    """Extract prerequisite strings from ADF nodes (bullet lists or paragraphs)."""
+    prerequisites = []
+    for node in nodes:
+        if node.get("type") == "bulletList":
+            for item in node.get("content", []):
+                text = extract_text_from_adf(item).strip()
+                if text:
+                    prerequisites.append(text)
+        elif node.get("type") == "paragraph":
+            text = extract_text_from_adf(node).strip()
+            if text:
+                prerequisites.append(text)
+    return prerequisites
+
+
+def clean_step_text(text, screenshot_name):
+    """Remove [SCREENSHOT: ...] or [EVIDENCE: ...] marker from step text and deduplicate."""
+    # Remove the marker itself
+    cleaned = re.sub(r'\[(SCREENSHOT|EVIDENCE):\s*[^\]]+\]\s*', '', text).strip()
+
+    # Deduplicate: if the same phrase appears twice consecutively, keep one
+    # This handles ADF text node concatenation artifacts
+    words = cleaned.split()
+    mid = len(words) // 2
+    if mid > 2 and words[:mid] == words[mid:2 * mid]:
+        cleaned = " ".join(words[:mid] + words[2 * mid:])
+
+    return cleaned
+
+
+def parse_steps(nodes):
+    """Extract ordered steps with optional [SCREENSHOT: name] or [EVIDENCE: name] markers."""
+    steps = []
+    step_number = 0
+
+    for node in nodes:
+        if node.get("type") == "orderedList":
+            for item in node.get("content", []):
+                step_number += 1
+                text = extract_text_from_adf(item).strip()
+
+                screenshot = None
+                match = re.search(r'\[(SCREENSHOT|EVIDENCE):\s*([^\]]+)\]', text)
+                if match:
+                    screenshot = match.group(2).strip()
+
+                display_text = clean_step_text(text, screenshot) if screenshot else text
+
+                steps.append({
+                    "number": step_number,
+                    "text": display_text,
+                    "screenshot": screenshot,
+                })
+        elif node.get("type") == "paragraph":
+            text = extract_text_from_adf(node).strip()
+            if text and re.match(r'^\d+\.?\s', text):
+                step_number += 1
+                screenshot = None
+                match = re.search(r'\[(SCREENSHOT|EVIDENCE):\s*([^\]]+)\]', text)
+                if match:
+                    screenshot = match.group(2).strip()
+
+                clean_text = re.sub(r'^\d+\.?\s*', '', text)
+                display_text = clean_step_text(clean_text, screenshot) if screenshot else clean_text
+                steps.append({
+                    "number": step_number,
+                    "text": display_text,
+                    "screenshot": screenshot,
+                })
+
+    return steps
+
+
+def parse_viewports(nodes):
+    """Extract viewport definitions from ADF table nodes.
+
+    Supports two table formats:
+    - 3 columns: Name | Width | Height
+    - 2 columns: Name | Resolution (WxH)
+    """
+    viewports = []
+
+    for node in nodes:
+        if node.get("type") == "table":
+            rows = node.get("content", [])
+            for row in rows:
+                if row.get("type") != "tableRow":
+                    continue
+
+                cells = row.get("content", [])
+                if not cells:
+                    continue
+
+                # Skip header row (tableHeader cells)
+                if cells[0].get("type") == "tableHeader":
+                    continue
+
+                cell_texts = [extract_text_from_adf(c).strip() for c in cells]
+
+                # 3-column format: Name | Width | Height
+                if len(cell_texts) >= 3:
+                    name = cell_texts[0]
+                    try:
+                        width = int(cell_texts[1])
+                        height = int(cell_texts[2])
+                        viewports.append({
+                            "name": name,
+                            "width": width,
+                            "height": height,
+                        })
+                        continue
+                    except ValueError:
+                        pass
+
+                # 2-column format: Name | WxH (e.g., "1512x768")
+                if len(cell_texts) >= 2:
+                    name = cell_texts[0]
+                    resolution = cell_texts[1]
+                    match = re.match(r'(\d+)\s*[xX\u00d7]\s*(\d+)', resolution)
+                    if match:
+                        viewports.append({
+                            "name": name,
+                            "width": int(match.group(1)),
+                            "height": int(match.group(2)),
+                        })
+
+    return viewports
+
+
+def parse_assertions(nodes):
+    """Extract assertion strings from ADF nodes."""
+    assertions = []
+    for node in nodes:
+        if node.get("type") == "bulletList":
+            for item in node.get("content", []):
+                text = extract_text_from_adf(item).strip()
+                if text:
+                    assertions.append(text)
+        elif node.get("type") == "orderedList":
+            for item in node.get("content", []):
+                text = extract_text_from_adf(item).strip()
+                if text:
+                    assertions.append(text)
+        elif node.get("type") == "paragraph":
+            text = extract_text_from_adf(node).strip()
+            if text and text.startswith("-"):
+                assertions.append(text.lstrip("- ").strip())
+            elif text:
+                assertions.append(text)
+    return assertions
+
+
+def parse_adf_journey(description_adf):
+    """Parse the Validation Journey from an ADF description object."""
+    content = description_adf.get("content", [])
+
+    # Find the "Validation Journey" h2 heading
+    journey_idx = find_heading_index(content, "validation journey", level=2)
+    if journey_idx < 0:
+        # Try without level constraint
+        journey_idx = find_heading_index(content, "validation journey")
+
+    if journey_idx < 0:
+        print("ERROR: No 'Validation Journey' section found in ticket description", file=sys.stderr)
+        sys.exit(1)
+
+    # Extract sub-sections
+    prereq_idx = find_heading_index(content, "prerequisites", level=3)
+    steps_idx = find_heading_index(content, "steps", level=3)
+    viewports_idx = find_heading_index(content, "viewports", level=3)
+    assertions_idx = find_heading_index(content, "assertions", level=3)
+
+    prerequisites = []
+    if prereq_idx >= 0:
+        prereq_nodes = extract_section_content(content, prereq_idx)
+        prerequisites = parse_prerequisites(prereq_nodes)
+
+    steps = []
+    if steps_idx >= 0:
+        steps_nodes = extract_section_content(content, steps_idx)
+        steps = parse_steps(steps_nodes)
+
+    viewports = []
+    if viewports_idx >= 0:
+        viewport_nodes = extract_section_content(content, viewports_idx)
+        viewports = parse_viewports(viewport_nodes)
+
+    assertions = []
+    if assertions_idx >= 0:
+        assertion_nodes = extract_section_content(content, assertions_idx)
+        assertions = parse_assertions(assertion_nodes)
+
+    # Fallback: if no viewports defined, use Desktop as default
+    if not viewports:
+        viewports = [{"name": "Desktop", "width": 1512, "height": 768}]
+
+    return {
+        "prerequisites": prerequisites,
+        "steps": steps,
+        "viewports": viewports,
+        "assertions": assertions,
+    }
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: parse-plan.py <TICKET_ID>", file=sys.stderr)
+        sys.exit(1)
+
+    ticket_id = sys.argv[1]
+    server, login, token = get_jira_config()
+    ticket_data = fetch_ticket(server, login, token, ticket_id)
+
+    description = ticket_data.get("fields", {}).get("description")
+    if not description:
+        print(f"ERROR: Ticket {ticket_id} has no description", file=sys.stderr)
+        sys.exit(1)
+
+    # ADF description is a dict, wiki markup is a string
+    if isinstance(description, dict):
+        result = parse_adf_journey(description)
+    else:
+        print("ERROR: Wiki markup parsing not implemented. Use JIRA API v3 (ADF format).", file=sys.stderr)
+        sys.exit(1)
+
+    result["ticket"] = ticket_id
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/plugins/lisa-expo/.codex-plugin/skills/jira-verify/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: jira-verify
+description: "verifying that a JIRA ticket…"
+allowed-tools: ["Skill", "mcp__atlassian__getJiraIssue", "mcp__atlassian__getAccessibleAtlassianResources"]
+---
+
+# Verify JIRA Ticket: $ARGUMENTS
+
+Verify that the existing JIRA ticket `$ARGUMENTS` meets organizational standards. This skill is a thin post-write wrapper around `lisa:jira-validate-ticket`: it fetches the live ticket and asks `lisa:jira-validate-ticket` to run the gates against the fetched state.
+
+This indirection exists so the gate definitions live in exactly one place (`lisa:jira-validate-ticket`). When the bar changes, change it there — `lisa:jira-verify`, `lisa:jira-write-ticket` (Phase 5.5 pre-write), and `lisa:notion-to-tracker` (PRD dry-run) all pick it up.
+
+## Process
+
+1. Resolve cloud ID via `mcp__atlassian__getAccessibleAtlassianResources`.
+2. Fetch the ticket via `mcp__atlassian__getJiraIssue` for `$ARGUMENTS`.
+3. Invoke `lisa:jira-validate-ticket` and pass the ticket key. The validator runs every gate (Specification + Feasibility) against the live state, including the Validation Journey check (S11) which applies to any runtime-behavior change — UI tickets in Expo always qualify.
+4. Surface the validator's report verbatim.
+
+## Output
+
+Pass through `lisa:jira-validate-ticket`'s structured output unchanged. Downstream callers parse the gate lines.
+
+## Notes
+
+- This skill is read-only. It never edits the ticket, posts comments, or changes status.
+- For UI tickets that fail the Validation Journey gate, the validator's remediation will recommend `/lisa:jira-add-journey` — the Expo flavor of `lisa:jira-add-journey` produces the `[SCREENSHOT: ...]` + viewport block that the Playwright-based journey runner consumes.

package/plugins/lisa-expo/.codex-plugin/skills/jira-verify/agents/openai.yaml

@@ -0,0 +1,4 @@
+display_name: "Jira Verify"
+short_description: "verifying that a JIRA ticket…"
+default_prompt:
+  - "Use $jira-verify: verifying that a JIRA ticket…."

package/plugins/lisa-expo/.codex-plugin/skills/lisa-e2e-coverage-gaps/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: lisa-e2e-coverage-gaps
+description: "Explore gaps in the automated…"
+---
+## Lisa Command Compatibility
+
+- Original Claude command: `/lisa:e2e-coverage-gaps`
+- Codex invocation: `$lisa-e2e-coverage-gaps` or a plain-English request that matches this skill.
+- Treat the user's surrounding request as the command arguments.
+- Claude argument hint: `[target-url | env] [ready=true|false]`
+- Claude allowed tools: `Skill`. Codex tool access is governed by the active Codex runtime and project policy.
+
+Use the /lisa-expo:e2e-coverage-gaps skill to inventory the app's routes and the existing Playwright suite, find uncovered and happy-path-only paths, confirm each gap in the running app, and file one build-ready missing-test ticket per gap via lisa:tracker-write (build-ready per the ready flag, default true). For human usability/experience findings, use /lisa:exploratory-qa. Use the user's surrounding request as this command's arguments.