prizmkit 1.1.86 → 1.1.88

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.86",
-  "bundledAt": "2026-06-30T15:38:43.553Z",
-  "bundledFrom": "d83ca7c"
+  "frameworkVersion": "1.1.88",
+  "bundledAt": "2026-07-01T15:23:58.266Z",
+  "bundledFrom": "2512a9a"
 }

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -21,6 +21,7 @@ Usage:
 """
 
 import argparse
+import glob
 import json
 import os
 import re
@@ -623,6 +624,11 @@ SECTION_TO_SKILL = {
                    [".prizmkit/specs/{slug}/plan.md"]),
     "phase-critic-plan": ("critic-plan-review", "Critic: Plan Review", []),
     "phase-implement": ("prizmkit-implement", "Implement + Test", []),
+    "phase-prizmkit-test": (
+        "prizmkit-test", "Scoped Feature Test Gate",
+        [".prizmkit/specs/{slug}/test-report-path.txt",
+         ".prizmkit/test/*/test-report.md"],
+    ),
     "phase-review": ("prizmkit-code-review", "Code Review", []),
     "phase-browser": ("browser-verification", "Browser Verification", []),
     "phase-commit": None,  # special: split into retrospective + committer
@@ -640,6 +646,446 @@ def _resolve_artifacts(artifact_templates, slug):
     return [a.replace("{slug}", slug) for a in artifact_templates]
 
 
+def _artifact_exists(project_root, artifact):
+    """Return whether an artifact path or glob exists under project_root."""
+    full_path = os.path.join(project_root, artifact)
+    if glob.has_magic(full_path):
+        return bool(glob.glob(full_path))
+    return os.path.exists(full_path)
+
+
+def _read_text(path):
+    """Read a UTF-8 text file, returning an empty string on IO errors."""
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    except IOError:
+        return ""
+
+
+def _normalize_artifact_dir(path):
+    """Normalize report artifact_dir values for comparison."""
+    return path.strip().replace("\\", "/").rstrip("/")
+
+
+def _report_path_matches_artifacts(project_root, report_path, artifacts):
+    """Return whether report_path is an in-project test report artifact."""
+    test_root = os.path.realpath(
+        os.path.join(project_root, ".prizmkit", "test")
+    )
+    resolved_report = os.path.realpath(report_path)
+
+    try:
+        if os.path.commonpath([test_root, resolved_report]) != test_root:
+            return False
+    except ValueError:
+        return False
+
+    report_artifacts = [a for a in artifacts if a.endswith("test-report.md")]
+    for artifact in report_artifacts:
+        artifact_path = os.path.join(project_root, artifact)
+        if glob.has_magic(artifact_path):
+            candidates = glob.glob(artifact_path)
+        else:
+            candidates = [artifact_path]
+        for candidate in candidates:
+            if os.path.realpath(candidate) == resolved_report:
+                return True
+    return False
+
+
+def _extract_scope_field(report_text, field_name):
+    """Extract a '- Field: value' entry from the report Scope section."""
+    in_scope = False
+    prefix = "- {}:".format(field_name)
+    for raw_line in report_text.splitlines():
+        line = raw_line.strip()
+        if line == "## Scope":
+            in_scope = True
+            continue
+        if in_scope and line.startswith("## "):
+            break
+        if in_scope and line.startswith(prefix):
+            return line[len(prefix):].strip()
+    return ""
+
+
+def _extract_report_verdict(report_text):
+    """Extract the first non-empty line after the report Verdict heading."""
+    in_verdict = False
+    for raw_line in report_text.splitlines():
+        line = raw_line.strip()
+        if line == "## Verdict":
+            in_verdict = True
+            continue
+        if in_verdict:
+            if line.startswith("## "):
+                break
+            if line:
+                return line
+    return ""
+
+
+def _extract_report_section(report_text, heading):
+    """Extract text under a level-2 markdown heading."""
+    in_section = False
+    lines = []
+    for raw_line in report_text.splitlines():
+        line = raw_line.strip()
+        if line == heading:
+            in_section = True
+            continue
+        if in_section and line.startswith("## "):
+            break
+        if in_section:
+            lines.append(raw_line)
+    return "\n".join(lines)
+
+
+def _discover_openapi_file(project_root):
+    """Return the first common OpenAPI/Swagger file under project_root."""
+    candidates = [
+        "openapi.yaml", "openapi.yml", "swagger.yaml", "swagger.yml",
+        "docs/openapi.yaml", "docs/openapi.yml",
+        "docs/swagger.yaml", "docs/swagger.yml",
+        "api/openapi.yaml", "api/openapi.yml",
+        "api/swagger.yaml", "api/swagger.yml",
+    ]
+    for candidate in candidates:
+        full_path = os.path.join(project_root, candidate)
+        if os.path.isfile(full_path):
+            return full_path
+    return ""
+
+
+def _normalize_api_path(path):
+    """Normalize API path tokens for exact comparison."""
+    normalized = path.strip().strip("'\"`")
+    if len(normalized) > 1:
+        normalized = normalized.rstrip("/")
+    return normalized
+
+
+def _extract_openapi_operations(openapi_text):
+    """Extract OpenAPI method+path operations without requiring PyYAML."""
+    methods = {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "TRACE"}
+    operations = []
+    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 methods:
+                operations.append((method, _normalize_api_path(current_path)))
+
+    return operations
+
+
+def _extract_matrix_operations(rows):
+    """Extract exact method+path tokens from Boundary Matrix rows."""
+    operations = set()
+    path_only = set()
+    token_re = re.compile(
+        r"(?:(\b(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\b)\s+)?(/[^\s,`|)]+)",
+        flags=re.IGNORECASE,
+    )
+    for row in rows:
+        interface = row.get("Interface", "")
+        for match in token_re.finditer(interface):
+            method = match.group(1).upper() if match.group(1) else ""
+            path = _normalize_api_path(match.group(2))
+            if not path:
+                continue
+            if method:
+                operations.add((method, path))
+            else:
+                path_only.add(path)
+    return operations, path_only
+
+
+def _boundary_report_sections_valid(project_root, report_text):
+    """Return whether required boundary sections do not report failure."""
+    required_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",
+    ]
+    category_columns = [
+        "Happy Path",
+        "Request Validation",
+        "Auth / Permission / Ownership",
+        "Domain Invariants",
+        "Collection / Pagination",
+        "Date / Time",
+        "State Transitions",
+        "Dependency Failure",
+        "Response Contract",
+    ]
+    allowed_final_statuses = {
+        "boundary-covered",
+        "generated-needs-review",
+        "skipped-with-reason",
+    }
+    incomplete_markers = {
+        "boundary-missing",
+        "happy-path-only",
+        "unresolved",
+    }
+
+    matrix_section = _extract_report_section(report_text, "## Boundary Matrix")
+    if not matrix_section:
+        return False
+    matrix_lines = [line.strip() for line in matrix_section.splitlines()
+                    if line.strip().startswith("|")]
+    headers = []
+    rows = []
+    for line in matrix_lines:
+        cells = [cell.strip() for cell in line.strip().strip("|").split("|")]
+        if not headers:
+            if "Interface" in cells and "Final Status" in cells:
+                headers = cells
+            continue
+        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)}
+        if row.get("Interface", "").strip(".` ") in {"", "..."}:
+            continue
+        rows.append(row)
+
+    if not headers or not rows:
+        return False
+    if any(column not in headers for column in required_columns):
+        return False
+
+    for row in rows:
+        final_status = row.get("Final Status", "").strip().lower()
+        if final_status not in allowed_final_statuses:
+            return False
+        for column in category_columns:
+            if not row.get(column, "").strip():
+                return False
+        for value in row.values():
+            normalized = value.strip().lower()
+            if any(marker in normalized for marker in incomplete_markers):
+                return False
+
+    openapi_file = _discover_openapi_file(project_root)
+    if openapi_file:
+        operations = _extract_openapi_operations(_read_text(openapi_file))
+        matrix_operations, _matrix_path_only = _extract_matrix_operations(rows)
+        for method, path in operations:
+            if (method, path) not in matrix_operations:
+                return False
+
+    gate_section = _extract_report_section(report_text,
+                                           "## Boundary Completion Gate")
+    if not gate_section:
+        return False
+    completion_gate_passed = False
+    boundary_missing_seen = False
+    happy_path_only_seen = False
+    for raw_line in gate_section.splitlines():
+        line = raw_line.strip()
+        match = re.match(r"-?\s*(Boundary-missing|Happy-path-only):\s*(\d+)\s*$",
+                         line, re.IGNORECASE)
+        if match:
+            if match.group(1).lower() == "boundary-missing":
+                boundary_missing_seen = True
+            if match.group(1).lower() == "happy-path-only":
+                happy_path_only_seen = True
+            if int(match.group(2)) > 0:
+                return False
+        if re.match(r"-?\s*Completion gate passed:\s*yes\s*$",
+                    line, re.IGNORECASE):
+            completion_gate_passed = True
+        if re.match(r"-?\s*Completion gate passed:\s*no\b",
+                    line, re.IGNORECASE):
+            return False
+    if not (completion_gate_passed and boundary_missing_seen and
+            happy_path_only_seen):
+        return False
+
+    validation_section = _extract_report_section(report_text,
+                                                 "## Boundary Validation")
+    if not validation_section:
+        return False
+    validator_result = ""
+    for raw_line in validation_section.splitlines():
+        line = raw_line.strip()
+        match = re.match(r"-?\s*Validator result:\s*(\S+)",
+                         line, re.IGNORECASE)
+        if match:
+            validator_result = match.group(1).strip().lower()
+            break
+
+    return validator_result == "passed"
+
+
+def _extract_scope_list(report_text, list_name):
+    """Extract a nested file list from the report Scope section."""
+    in_scope = False
+    in_list = False
+    list_marker = "- {}:".format(list_name)
+    values = []
+    for raw_line in report_text.splitlines():
+        line = raw_line.strip()
+        if line == "## Scope":
+            in_scope = True
+            continue
+        if in_scope and line.startswith("## "):
+            break
+        if not in_scope:
+            continue
+        if line == list_marker:
+            in_list = True
+            continue
+        if in_list:
+            if raw_line.startswith("  -") or raw_line.startswith("\t-"):
+                value = line[2:].strip().strip("`")
+                if value and value not in {"{...}", "..."}:
+                    values.append(value)
+                continue
+            if line.startswith("- "):
+                break
+    return values
+
+
+def _scoped_report_fresh(project_root, pointer_artifact, report_path, report_text):
+    """Return whether the report is newer than the gate marker and in-scope files."""
+    marker_path = os.path.join(
+        project_root,
+        os.path.dirname(pointer_artifact),
+        ".prizmkit-test-started",
+    )
+    if not os.path.exists(marker_path):
+        return False
+
+    try:
+        report_mtime = os.path.getmtime(report_path)
+        marker_mtime = os.path.getmtime(marker_path)
+    except OSError:
+        return False
+
+    if report_mtime < marker_mtime:
+        return False
+
+    project_root_real = os.path.realpath(project_root)
+    source_files = _extract_scope_list(report_text, "In-Scope Source Files")
+    test_files = _extract_scope_list(report_text, "In-Scope Test Files")
+    if not source_files or not test_files:
+        return False
+
+    ignored = {"none", "n/a", "not applicable", "(none)", "{...}", "..."}
+    for listed_file in source_files + test_files:
+        normalized = listed_file.strip().strip("`")
+        if not normalized or normalized.lower() in ignored:
+            return False
+        candidate = (normalized if os.path.isabs(normalized)
+                     else os.path.join(project_root, normalized))
+        candidate_real = os.path.realpath(candidate)
+        try:
+            if os.path.commonpath([project_root_real, candidate_real]) != project_root_real:
+                return False
+        except ValueError:
+            return False
+        if not os.path.isfile(candidate_real):
+            return False
+        if os.path.getmtime(candidate_real) > report_mtime:
+            return False
+
+    return True
+
+
+def _validate_scoped_test_report(project_root, artifacts):
+    """Validate the feature prizmkit-test pointer and scoped PASS report."""
+    pointer_artifacts = [a for a in artifacts
+                         if a.endswith("/test-report-path.txt")]
+    if not pointer_artifacts:
+        return False
+
+    pointer_artifact = pointer_artifacts[0]
+    pointer_path = os.path.join(project_root, pointer_artifact)
+    pointed_report = _read_text(pointer_path).strip().splitlines()
+    if not pointed_report:
+        return False
+
+    report_path = pointed_report[0].strip()
+    if not os.path.isabs(report_path):
+        report_path = os.path.join(project_root, report_path)
+    if not os.path.exists(report_path):
+        return False
+    if not _report_path_matches_artifacts(project_root, report_path, artifacts):
+        return False
+
+    report_text = _read_text(report_path)
+    mode = _extract_scope_field(report_text, "Mode")
+    artifact_dir = _extract_scope_field(report_text, "Artifact Dir")
+    verdict = _extract_report_verdict(report_text)
+
+    expected_artifact_dir = _normalize_artifact_dir(
+        os.path.dirname(pointer_artifact)
+    )
+    actual_artifact_dir = _normalize_artifact_dir(artifact_dir)
+
+    return (mode == "this-change" and
+            actual_artifact_dir == expected_artifact_dir and
+            verdict == "PASS" and
+            _boundary_report_sections_valid(project_root, report_text) and
+            _scoped_report_fresh(project_root, pointer_artifact,
+                                 report_path, report_text))
+
+
+def _completed_step_artifacts_valid(project_root, skill_key, artifacts):
+    """Return whether a completed checkpoint step can be preserved."""
+    if not all(_artifact_exists(project_root, a) for a in artifacts):
+        return False
+    if skill_key == "prizmkit-test":
+        return _validate_scoped_test_report(project_root, artifacts)
+    return True
+
+
 def generate_checkpoint_definition(sections, pipeline_mode, workflow_type,
                                    item_id, item_slug, session_id,
                                    init_done=False):
@@ -727,17 +1173,24 @@ def merge_checkpoint_state(existing, fresh, project_root):
     """
     existing_status = {}
     existing_artifacts = {}
+    fresh_artifacts = {step["skill"]: step.get("required_artifacts", [])
+                       for step in fresh.get("steps", [])}
     for step in existing.get("steps", []):
         existing_status[step["skill"]] = step["status"]
         existing_artifacts[step["skill"]] = step.get("required_artifacts", [])
 
-    # Determine which completed steps have valid artifacts
+    # Determine which completed steps have valid artifacts. Prefer the freshly
+    # generated artifact contract so newly added gates invalidate older
+    # checkpoint entries that only satisfied a weaker contract.
     valid_completed = set()
     for skill_key, status in existing_status.items():
         if status == "completed":
-            artifacts = existing_artifacts.get(skill_key, [])
-            if all(os.path.exists(os.path.join(project_root, a))
-                   for a in artifacts):
+            artifacts = fresh_artifacts.get(
+                skill_key, existing_artifacts.get(skill_key, [])
+            )
+            if _completed_step_artifacts_valid(project_root,
+                                               skill_key,
+                                               artifacts):
                 valid_completed.add(skill_key)
             else:
                 LOGGER.warning(
@@ -1045,6 +1498,11 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
                           load_section(sections_dir,
                                        "test-failure-recovery-agent.md")))
 
+    # --- Scoped Feature Test Gate ---
+    sections.append(("phase-prizmkit-test",
+                      load_section(sections_dir,
+                                   "phase-prizmkit-test.md")))
+
     # Verification Gates are included in Task Contract. Keep AC in one place so
     # background context and implementation prompts cannot redefine scope.
     # --- Review (only for agent tiers) ---