prizmkit 1.1.99 → 1.1.101

package/bundled/skills-windows/prizmkit-test/references/test-generation-steps.md

@@ -1,109 +0,0 @@
-# Test Generation Steps (Phase 5)
-
-## Scope Guard
-
-Before generating any test, determine whether the run is `scope=this-change`.
-
-For `scope=this-change`, use `generation_policy=in-scope-only` by default. Generate tests only for the in-scope source/test set built from the feature artifact directory and changed files. If a missing test is unrelated to the feature, record it in `Out of Scope Gaps` and do not generate it. Do not infer this-change scope from `.prizmkit/bugfix/` or `.prizmkit/refactor/`.
-
-
-Generate tests from the Phase 4 Boundary Coverage Matrix in priority order: unit → integration → E2E. After each batch, run immediately.
-
-When generated tests fail, distinguish two cases:
-- **Test bug** (syntax error, wrong import, wrong mock, wrong framework API usage) → fix the test and re-run
-- **Assertion failure** (test is valid but code returns unexpected result) → mark as "needs review" in report; do NOT modify production code. This is a potential bug discovered by the generated test.
-
-If a test fails repeatedly after 2 fix attempts, skip it and mark as "unresolved" in the report.
-
-## 5a. Boundary Matrix First
-
-Before writing any new test, create or update the per-interface Boundary Test Matrix from `references/boundary-coverage-protocol.md`. This step matters because a test suite with broad happy-path coverage can still miss the conditions that cause production failures: invalid input, unauthorized access, ownership mistakes, state transitions, dependency errors, and product-specific invariants.
-
-For each in-scope interface or endpoint:
-- Identify existing happy-path coverage.
-- Identify existing boundary coverage by reading test assertions, not just test names.
-- Classify applicable categories: request validation, auth/permission/ownership, domain invariants, collection/pagination, date/time, state transitions, dependency failure, and response contract.
-- Mark non-applicable categories as `N/A` with a concrete reason.
-- Mark applicable uncovered categories as `boundary-missing`.
-
-Do not generate only happy-path tests. If happy path is missing, generate it, then continue with applicable boundary tests in the same batch.
-
-### Existing Test Evaluation
-
-An existing test counts as boundary coverage only when it:
-- targets the same interface/endpoint,
-- sends the relevant boundary input or creates the relevant state/dependency failure,
-- asserts the expected business code, exception, response shape, state change, or side effect,
-- verifies behavior beyond "HTTP 200" or "non-empty response".
-
-A test that only checks the route returns successfully is happy-path coverage, not boundary coverage.
-
-### API Endpoint Boundary Discovery
-
-For API endpoints, derive boundary cases from:
-- OpenAPI request schemas and response schemas,
-- handler binding tags and request parsing behavior,
-- service validation logic,
-- repository/service error handling,
-- Prizm L2 TRAPS and DECISIONS,
-- existing tests and source behavior,
-- product rules in project brief/specs.
-
-Map each endpoint to business-specific cases. Examples:
-- `POST /auth/refresh`: missing token, malformed token, reused/rotated token, revoked token, token-version race if testable.
-- `POST /meals/update`: missing ID, missing foods, invalid meal type, invalid timestamp, not found, wrong owner, recomputed totals, confirmed state transition.
-- `POST /stats/trends`: invalid type, invalid period, invalid date range, empty data, each supported trend type, inclusive end date behavior.
-- `POST /upload/sign-url`: unsupported content type, file_count 0/default/max/max+1, scene handling, storage provider failure.
-
-## 5b. Unit Tests (always applicable)
-
-For each in-scope uncovered interface:
-- Read the source file to understand function signature, branch logic, dependencies, state changes, side effects, and failure paths.
-- Classify the function/class method by service responsibility using names, module path, parameters, dependencies, and related Prizm docs/spec acceptance criteria.
-- Read `references/service-boundary-test-catalog.md` when the unit is service-like or has business-specific inputs — it maps service responsibilities to boundary cases such as auth/session, payment/wallet, repository, pagination, file storage, notification, queue, cache/idempotency, API client, and date/expiration behavior.
-- Build a Unit Test Case Matrix before writing tests. Include generic boundaries plus every applicable service-specific boundary; mark non-applicable categories as `N/A` with a short reason instead of silently skipping them.
-- Generate test file matching project conventions (framework, naming, directory, import style, mock/fixture patterns)
-- Common naming patterns to match:
-  - `src/foo.ts` → `src/__tests__/foo.test.ts` or `src/foo.spec.ts` or `tests/foo_test.py`
-  - Mirror the existing pattern; if no tests exist, use the framework's default convention
-- Cover: happy path, service-specific boundary cases, edge cases (null/undefined/empty), error conditions, branch paths, boundary values, state/side effects, and dependency failures.
-- Verify mocks for dependency method calls, call count/order/arguments when the behavior depends on collaborators.
-- Do NOT test framework internals or third-party library behavior
-- Run tests immediately after generating
-
-## 5c. Integration Tests
-
-For each in-scope module with dependencies:
-- Generate tests for the module's primary interface exercising its real dependencies.
-- If API endpoints exist, generate request/response tests for every applicable boundary category in the Boundary Matrix, not only valid input. Cover auth, missing params, invalid formats/enums, ownership/not-found, state transitions, and response envelope or schema.
-- If database operations exist, generate CRUD tests using the project's existing test database config when available. Cover transactions, duplicate keys, soft-delete visibility, rollback, and query boundary behavior when applicable.
-- If a dependency failure is not practical at integration level, mark it `N/A` with the reason and cover it in a unit test where mocks are available.
-- Run tests immediately after generating.
-
-## 5d. E2E Tests (conditional)
-
-Preconditions (ALL must be met):
-- Playwright is available (`@playwright/test` or `playwright` in package.json dependencies, or `npx playwright --version` succeeds as fallback)
-- Playwright browsers are installed (check `npx playwright install --dry-run 2>/dev/null` exits cleanly, or `node_modules/.cache/ms-playwright/` directory exists; if missing, warn in report and skip E2E)
-- Project has a UI layer
-- Project can be started (start/dev script in package.json)
-- Acceptance criteria exist in spec.md files
-
-If ALL met:
-- **Before starting dev server**: detect whether it's already running: (1) check `package.json` scripts for port flags (`--port`, `-p`, `PORT=`), (2) fall back to framework defaults (3000 for React/Next/Express, 5173 for Vite, 8000 for Django, 5000 for Flask), (3) if still unknown, ask the user. Use the detected port in `lsof -i :<port>` to check. If running, tell user: "Dev server appears to be already running on port {N}. Use this running instance for E2E tests?" If user confirms, use existing instance. If user declines, skip E2E.
-- Start the project dev server (only if not already running). Wait for it to be ready.
-- For each in-scope uncovered acceptance criterion, generate a Playwright test script.
-- Include boundary user journeys when acceptance criteria mention validation, permissions, empty states, error messages, or lifecycle transitions.
-- Run generated E2E tests, capture screenshots of failure.
-- **Only stop dev server if you started it.** Never stop a server that was already running.
-
-If NOT met:
-- Note what was skipped and why in the report
-- If only the server wasn't startable: still generate E2E script files but mark as "not run — manual execution needed"
-
-## 5e. Boundary Completion Check
-
-After generating and running tests:
-- Update the Boundary Matrix statuses based on passing tests and `needs-review` findings.
-- If any interface remains `boundary-missing` or happy-path-only, run another targeted generation pass for those categories before final reporting.
-- Stop only when all in-scope interfaces are `boundary-covered`, `generated-needs-review`, or `skipped-with-reason`, or when remaining gaps are explicitly listed as unresolved.

package/bundled/skills-windows/prizmkit-test/references/test-report-template.md

@@ -1,111 +0,0 @@
-# Test Report Output Template
-
-Used in Phase 6 of `/prizmkit-test`. Create `.prizmkit/test/{YYYY_MM_DD_HH_MM_SS}_testresult/` directory and write `test-report.md`.
-
-## test-report.md Format
-
-```markdown
-# Test Report — {timestamp}
-
-## Summary
-- Scope: {full / module: name / feature: ###-name}
-- Architecture: {frontend / backend / fullstack}
-- Test framework: {name}
-- Mode: {interactive / headless}
-
-## Scope
-- Mode: {full-project / module:<name> / feature:<slug> / this-change}
-- Artifact Dir: {none / .prizmkit/specs/<FEATURE_SLUG>/}
-- Diff Base: {ref or none}
-- Changed Files Source: {changed_files / diff_base / plan.md / context-snapshot.md / spec.md / not applicable}
-- Generation Policy: {in-scope-only / full-project}
-- In-Scope Source Files:
-  - {...}
-- In-Scope Test Files:
-  - {...}
-
-
-## Existing Tests Run
-- Total: {N} | Passed: {N} | Failed: {N}
-{failed test details or "All passing"}
-{or "No existing tests found — generated first batch"}
-
-## Coverage Gaps Found
-| Module | Interface | Type | Status |
-|--------|-----------|------|--------|
-| ... | ... | unit/integration/e2e | covered / generated / needs-review / unresolved / skipped / boundary-missing |
-
-## Boundary Matrix
-| Module | Interface | Service Type | Happy Path | Request Validation | Auth / Permission / Ownership | Domain Invariants | Collection / Pagination | Date / Time | State Transitions | Dependency Failure | Response Contract | N/A Reasons | Final Status |
-|--------|-----------|--------------|------------|--------------------|-------------------------------|-------------------|-------------------------|-------------|-------------------|-------------------|-------------------|-------------|--------------|
-| ... | ... | auth/repository/upload/etc. | covered/generated/skipped | covered/generated/needs-review/skipped/boundary-missing | ... | ... | ... | ... | ... | ... | ... | category — reason | boundary-covered / generated-needs-review / skipped-with-reason / boundary-missing |
-
-## Boundary Completion Gate
-- Interfaces total: {N}
-- Boundary-covered: {N}
-- Generated-needs-review: {N}
-- Skipped-with-reason: {N}
-- Boundary-missing: {N}
-- Happy-path-only: {N}
-- Completion gate passed: {yes / no}
-
-If `Boundary-missing > 0` or `Happy-path-only > 0`, write:
-`Tests may pass, but boundary coverage is incomplete.`
-
-## Boundary Coverage Notes
-| Module | Interface | Boundary Categories Covered | Missing Applicable Boundaries | N/A Categories with Reasons |
-|--------|-----------|-----------------------------|-------------------------------|-----------------------------|
-| ... | ... | request validation, ownership, dependency failure | invalid timestamp, repo failure | pagination — endpoint has no list semantics |
-
-## Generated / Updated Tests
-- Unit: {N} generated, {N} needs-review, {N} unresolved
-- Integration: {N} generated, {N} needs-review, {N} unresolved
-- E2E: {N} generated, {N} skipped ({reason})
-
-## Boundary Validation
-- Validator command: `{command or "not run — reason"}`
-- Validator result: {passed / failed / skipped}
-- Validator output: {summary or path to raw output}
-
-## In-Scope Failures
-- {failures caused by this-change scope, or "None"}
-
-## Baseline Failures
-- {pre-existing failures, or "None"}
-
-## Out of Scope Gaps
-- {unrelated historical gaps; informational only for scope=this-change}
-
-## Verdict
-PASS | NEEDS_FIXES | BLOCKED
-
-## Final Status
-- All tests passing: {yes / no}
-- Boundary completion gate passed: {yes / no}
-- Ready for commit: {yes / no — include reason}
-- Needs human review: {list of tests/interfaces marked needs-review}
-{remaining failures if any}
-```
-
-## Artifacts
-
-Also save alongside `test-report.md`:
-- `existing-test-output.txt` — raw output from Phase 2
-- `generated-tests/` — copies of all generated test files
-- `e2e-output/` — E2E logs and failure screenshots (if applicable)
-- `boundary-validation-output.txt` — output from `scripts/validate_boundary_report.py` when run
-
-## Final Status Rules
-
-Use these rules so the report does not overstate quality:
-
-| Tests Passing | Boundary Gate | Needs Review | Ready for Commit |
-|---------------|---------------|--------------|------------------|
-| yes | yes | no | yes |
-| yes | yes | yes | no — human review required |
-| yes | no | any | no — boundary coverage incomplete |
-| no | any | any | no — tests failing |
-
-Do not write "All tests passing. Ready for commit." if any interface is `boundary-missing`, `happy-path-only`, `unresolved`, or `needs-review`.
-
-Out-of-scope gaps are informational only. They must not trigger generated tests and must not fail a `scope=this-change` run.

package/bundled/skills-windows/prizmkit-test/scripts/validate_boundary_report.py

@@ -1,347 +0,0 @@
-#!/usr/bin/env python3
-"""
-Validate a prizmkit-test report's boundary coverage gate.
-
-Usage:
-  python3 scripts/validate_boundary_report.py --report .prizmkit/test/.../test-report.md
-  python3 scripts/validate_boundary_report.py --report .prizmkit/test/.../test-report.md --openapi openapi.yaml
-
-The script intentionally performs deterministic structural checks only. It cannot prove that every
-business boundary is semantically correct, but it prevents reports from silently claiming completion
-when interfaces are missing from the Boundary Matrix or remain happy-path-only / boundary-missing.
-"""
-
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from pathlib import Path
-from typing import Dict, List, Set, Tuple
-
-ALLOWED_FINAL_STATUSES = {
-    "boundary-covered",
-    "generated-needs-review",
-    "skipped-with-reason",
-}
-INCOMPLETE_MARKERS = {
-    "boundary-missing",
-    "happy-path-only",
-    "unresolved",
-}
-REQUIRED_SECTIONS = [
-    "## Boundary Matrix",
-    "## Boundary Completion Gate",
-    "## Final Status",
-]
-REQUIRED_BOUNDARY_COLUMNS = [
-    "Module",
-    "Interface",
-    "Service Type",
-    "Happy Path",
-    "Request Validation",
-    "Auth / Permission / Ownership",
-    "Domain Invariants",
-    "Collection / Pagination",
-    "Date / Time",
-    "State Transitions",
-    "Dependency Failure",
-    "Response Contract",
-    "N/A Reasons",
-    "Final Status",
-]
-BOUNDARY_CATEGORY_COLUMNS = [
-    "Happy Path",
-    "Request Validation",
-    "Auth / Permission / Ownership",
-    "Domain Invariants",
-    "Collection / Pagination",
-    "Date / Time",
-    "State Transitions",
-    "Dependency Failure",
-    "Response Contract",
-]
-
-
-def read_text(path: Path) -> str:
-    try:
-        return path.read_text(encoding="utf-8")
-    except FileNotFoundError:
-        raise SystemExit(f"FAIL: file not found: {path}")
-
-
-HTTP_METHODS = {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "TRACE"}
-
-
-def extract_openapi_paths(openapi_text: str) -> List[str]:
-    """Extract OpenAPI path keys without requiring PyYAML.
-
-    Supports common YAML forms inside the `paths:` mapping:
-    - /users:
-    - "/users/{id}":
-    - '/users/{id}':
-    """
-    return [path for _method, path in extract_openapi_operations(openapi_text)]
-
-
-def extract_openapi_operations(openapi_text: str) -> List[Tuple[str, str]]:
-    """Extract OpenAPI method+path operations without requiring PyYAML."""
-    operations: List[Tuple[str, str]] = []
-    in_paths = False
-    paths_indent = 0
-    current_path = ""
-    current_path_indent = 0
-    path_key_re = re.compile(
-        r"^\s*(?:(['\"])(/.*?)\1|(/[^:\s]+))\s*:\s*(?:#.*)?$"
-    )
-    method_re = re.compile(r"^\s*([A-Za-z]+)\s*:\s*(?:#.*)?$")
-
-    for raw_line in openapi_text.splitlines():
-        stripped = raw_line.strip()
-        if not stripped or stripped.startswith("#"):
-            continue
-
-        indent = len(raw_line) - len(raw_line.lstrip())
-        if not in_paths:
-            if re.match(r"^\s*paths\s*:\s*(?:#.*)?$", raw_line):
-                in_paths = True
-                paths_indent = indent
-            continue
-
-        if indent <= paths_indent:
-            break
-
-        path_match = path_key_re.match(raw_line)
-        if path_match:
-            current_path = path_match.group(2) or path_match.group(3) or ""
-            current_path_indent = indent
-            continue
-
-        method_match = method_re.match(raw_line)
-        if current_path and method_match and indent > current_path_indent:
-            method = method_match.group(1).upper()
-            if method in HTTP_METHODS:
-                operations.append((method, current_path))
-
-    return operations
-
-
-def extract_section(text: str, heading: str) -> str:
-    start = text.find(heading)
-    if start == -1:
-        return ""
-    rest = text[start + len(heading) :]
-    match = re.search(r"\n## ", rest)
-    if not match:
-        return rest
-    return rest[: match.start()]
-
-
-def split_markdown_row(line: str) -> List[str]:
-    return [cell.strip() for cell in line.strip().strip("|").split("|")]
-
-
-def parse_boundary_matrix(text: str) -> Tuple[List[str], List[Dict[str, str]]]:
-    section = extract_section(text, "## Boundary Matrix")
-    if not section:
-        return [], []
-
-    lines = [line.strip() for line in section.splitlines() if line.strip().startswith("|")]
-    header_index = -1
-    for idx, line in enumerate(lines):
-        cells = split_markdown_row(line)
-        if "Interface" in cells and "Final Status" in cells:
-            header_index = idx
-            break
-    if header_index == -1:
-        return [], []
-
-    headers = split_markdown_row(lines[header_index])
-    rows: List[Dict[str, str]] = []
-    for line in lines[header_index + 1 :]:
-        cells = split_markdown_row(line)
-        if all(re.fullmatch(r":?-{3,}:?", cell) for cell in cells):
-            continue
-        if len(cells) < len(headers):
-            cells.extend([""] * (len(headers) - len(cells)))
-        row = {header: cells[i] if i < len(cells) else "" for i, header in enumerate(headers)}
-        # Ignore example placeholder rows that were accidentally left in templates.
-        if row.get("Interface", "").strip(".` ") in {"...", ""}:
-            continue
-        rows.append(row)
-    return headers, rows
-
-
-def has_inline_reason(value: str) -> bool:
-    normalized = value.strip().lower()
-    if not normalized:
-        return False
-    if "—" in value or " - " in value or ":" in value:
-        return True
-    # Accept phrases longer than a bare status marker.
-    bare = {"n/a", "na", "skipped", "skip"}
-    return normalized not in bare and (normalized.startswith("n/a ") or normalized.startswith("skipped "))
-
-
-def extract_matrix_operations(interface_values: List[str]) -> Tuple[Set[Tuple[str, str]], Set[str]]:
-    """Extract method+path and path-only tokens from Boundary Matrix Interface cells."""
-    operations: Set[Tuple[str, str]] = set()
-    path_only: Set[str] = set()
-    token_re = re.compile(
-        r"(?:(\b(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\b)\s+)?(/[^\s,`|)]+)",
-        flags=re.IGNORECASE,
-    )
-    for value in interface_values:
-        for match in token_re.finditer(value):
-            method = match.group(1).upper() if match.group(1) else ""
-            path = normalize_path(match.group(2))
-            if not path:
-                continue
-            if method:
-                operations.add((method, path))
-            else:
-                path_only.add(path)
-    return operations, path_only
-
-
-def normalize_path(path: str) -> str:
-    normalized = path.strip().strip("'\"`")
-    if len(normalized) > 1:
-        normalized = normalized.rstrip("/")
-    return normalized
-
-
-def validate_report(report_text: str, openapi_paths: List[str] | None,
-                    openapi_operations: List[Tuple[str, str]] | None = None) -> List[str]:
-    errors: List[str] = []
-
-    for section in REQUIRED_SECTIONS:
-        if section not in report_text:
-            errors.append(f"missing required section: {section}")
-
-    headers, rows = parse_boundary_matrix(report_text)
-    if not rows:
-        errors.append("Boundary Matrix table is missing or empty")
-        return errors
-
-    for column in REQUIRED_BOUNDARY_COLUMNS:
-        if column not in headers:
-            errors.append(f"Boundary Matrix missing required column: {column}")
-
-    final_statuses = []
-    interface_values = []
-    for idx, row in enumerate(rows, start=1):
-        interface = row.get("Interface", "").strip()
-        interface_values.append(interface)
-
-        final_status = row.get("Final Status", "").strip().lower()
-        final_statuses.append(final_status)
-        if not final_status:
-            errors.append(f"row {idx} ({interface}) missing Final Status")
-        elif final_status not in ALLOWED_FINAL_STATUSES:
-            errors.append(
-                f"row {idx} ({interface}) has invalid/incomplete Final Status: {row.get('Final Status', '')}"
-            )
-
-        for column in BOUNDARY_CATEGORY_COLUMNS:
-            if column in headers and not row.get(column, "").strip():
-                errors.append(f"row {idx} ({interface}) missing boundary category value: {column}")
-
-        for header, value in row.items():
-            normalized = value.strip().lower()
-            if any(marker in normalized for marker in INCOMPLETE_MARKERS):
-                errors.append(f"row {idx} ({interface}) has incomplete marker in {header}: {value}")
-
-        n_a_reasons = row.get("N/A Reasons", "").strip()
-        for header, value in row.items():
-            if header in {"Module", "Interface", "Service Type", "Final Status", "N/A Reasons"}:
-                continue
-            normalized = value.strip().lower()
-            if normalized in {"n/a", "na", "skipped", "skip"} and not n_a_reasons:
-                errors.append(f"row {idx} ({interface}) marks {header} as {value} without N/A reason")
-            if ("skipped" in normalized or normalized.startswith("n/a")) and not (n_a_reasons or has_inline_reason(value)):
-                errors.append(f"row {idx} ({interface}) marks {header} as {value} without concrete reason")
-
-    if openapi_operations is not None:
-        matrix_operations, matrix_path_only = extract_matrix_operations(interface_values)
-        for method, path in openapi_operations:
-            normalized_path = normalize_path(path)
-            if (method, normalized_path) not in matrix_operations:
-                if normalized_path in matrix_path_only:
-                    errors.append(
-                        "OpenAPI operation missing from Boundary Matrix: "
-                        f"{method} {path} (path-only row is ambiguous)"
-                    )
-                else:
-                    errors.append(
-                        f"OpenAPI operation missing from Boundary Matrix: {method} {path}"
-                    )
-    elif openapi_paths is not None:
-        _matrix_operations, matrix_path_only = extract_matrix_operations(interface_values)
-        missing_paths = [path for path in openapi_paths
-                         if normalize_path(path) not in matrix_path_only]
-        for path in missing_paths:
-            errors.append(f"OpenAPI path missing from Boundary Matrix: {path}")
-
-    gate_section = extract_section(report_text, "## Boundary Completion Gate")
-    if gate_section:
-        for label in ["Interfaces total", "Boundary-covered", "Boundary-missing", "Happy-path-only", "Completion gate passed"]:
-            if label not in gate_section:
-                errors.append(f"Boundary Completion Gate missing metric: {label}")
-        for label in ["Boundary-missing", "Happy-path-only"]:
-            match = re.search(rf"{re.escape(label)}:\s*(\d+)", gate_section)
-            if match and int(match.group(1)) > 0:
-                errors.append(f"Boundary Completion Gate reports {label}: {match.group(1)}")
-        if re.search(r"Completion gate passed:\s*no", gate_section, flags=re.IGNORECASE):
-            errors.append("Boundary Completion Gate reports failure")
-
-    final_section = extract_section(report_text, "## Final Status")
-    if final_section:
-        if re.search(r"Ready for commit:\s*yes", final_section, flags=re.IGNORECASE):
-            if any(status != "boundary-covered" for status in final_statuses):
-                errors.append("Final Status says ready for commit but not every interface is boundary-covered")
-            review_match = re.search(r"Needs human review:\s*(.+)", final_section, flags=re.IGNORECASE)
-            if review_match and review_match.group(1).strip().lower() not in {"none", "no", "n/a", ""}:
-                errors.append("Final Status says ready for commit while human review is still needed")
-
-    return errors
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Validate prizmkit-test boundary coverage report")
-    parser.add_argument("--report", required=True, help="Path to test-report.md")
-    parser.add_argument("--openapi", help="Optional OpenAPI file whose paths must appear in Boundary Matrix")
-    args = parser.parse_args()
-
-    report_path = Path(args.report)
-    report_text = read_text(report_path)
-
-    openapi_paths = None
-    openapi_operations = None
-    if args.openapi:
-        openapi_path = Path(args.openapi)
-        if openapi_path.exists():
-            openapi_text = read_text(openapi_path)
-            openapi_operations = extract_openapi_operations(openapi_text)
-            openapi_paths = [path for _method, path in openapi_operations]
-        else:
-            print(f"WARN: OpenAPI file not found, skipping path coverage check: {openapi_path}")
-
-    errors = validate_report(report_text, openapi_paths, openapi_operations)
-    if errors:
-        print("Boundary report validation: FAIL")
-        for error in errors:
-            print(f"- {error}")
-        return 1
-
-    print("Boundary report validation: PASS")
-    print(f"Report: {report_path}")
-    if openapi_operations is not None:
-        print(f"OpenAPI operations checked: {len(openapi_operations)}")
-    elif openapi_paths is not None:
-        print(f"OpenAPI paths checked: {len(openapi_paths)}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())