prizmkit 1.1.87 → 1.1.89

package/bundled/dev-pipeline-windows/scripts/prizmkit-test-gate.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python3
+"""Scoped PrizmKit test gate for feature pipeline prompts.
+
+The feature bootstrap prompt calls this script instead of embedding the full
+Bash/PowerShell report validation logic inline.  It intentionally prints compact
+`GATE:*` lines so the AI session can decide whether to continue, retry, or stop.
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+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_VALIDATOR_CANDIDATES = [
+    ".claude/command-assets/prizmkit-test/scripts/validate_boundary_report.py",
+    ".codebuddy/skills/prizmkit-test/scripts/validate_boundary_report.py",
+    ".agents/skills/prizmkit-test/scripts/validate_boundary_report.py",
+]
+
+OPENAPI_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",
+]
+
+IGNORED_SCOPE_VALUES = {"none", "n/a", "not applicable", "(none)", "{...}", "..."}
+
+
+def default_artifact_dir(feature_slug):
+    return ".prizmkit/specs/{}/".format(feature_slug)
+
+
+def marker_path(feature_slug):
+    return os.path.join(default_artifact_dir(feature_slug), ".prizmkit-test-started")
+
+
+def pointer_path(feature_slug):
+    return os.path.join(default_artifact_dir(feature_slug), "test-report-path.txt")
+
+
+def normalize_artifact_dir(path):
+    return str(path or "").strip().replace("\\", "/").rstrip("/")
+
+
+def read_text(path):
+    with open(path, "r", encoding="utf-8") as fh:
+        return fh.read()
+
+
+def start_gate(feature_slug):
+    marker = marker_path(feature_slug)
+    os.makedirs(os.path.dirname(marker), exist_ok=True)
+    Path(marker).touch()
+    return {"gate": "GATE:START", "marker": marker}
+
+
+def newest_report_after_marker(marker):
+    if not os.path.isfile(marker):
+        return ""
+    try:
+        marker_mtime = os.path.getmtime(marker)
+    except OSError:
+        return ""
+
+    matches = []
+    for root, _dirs, files in os.walk(os.path.join(".prizmkit", "test")):
+        if "test-report.md" not in files:
+            continue
+        path = os.path.join(root, "test-report.md")
+        try:
+            report_mtime = os.path.getmtime(path)
+        except OSError:
+            continue
+        if report_mtime >= marker_mtime:
+            matches.append((report_mtime, path))
+
+    if not matches:
+        return ""
+    return sorted(matches)[-1][1]
+
+
+def extract_section(report_text, 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 lines
+
+
+def extract_scope_field(report_text, field_name):
+    prefix = "- {}:".format(field_name)
+    for raw_line in extract_section(report_text, "## Scope"):
+        line = raw_line.strip()
+        if line.startswith(prefix):
+            return line[len(prefix):].strip()
+    return ""
+
+
+def extract_verdict(report_text):
+    for raw_line in extract_section(report_text, "## Verdict"):
+        line = raw_line.strip()
+        if line:
+            return line
+    return ""
+
+
+def extract_key_value(section_lines, field_name):
+    prefix = "{}:".format(field_name).lower()
+    for raw_line in section_lines:
+        line = raw_line.strip()
+        if line.startswith("-"):
+            line = line[1:].strip()
+        if line.lower().startswith(prefix):
+            return line[len(prefix):].strip()
+    return ""
+
+
+def parse_markdown_cells(line):
+    stripped = line.strip()
+    if not stripped.startswith("|"):
+        return []
+    return [cell.strip() for cell in stripped.strip("|").split("|")]
+
+
+def boundary_columns_ok(matrix_lines):
+    for line in matrix_lines:
+        cells = parse_markdown_cells(line)
+        if cells and all(column in cells for column in REQUIRED_BOUNDARY_COLUMNS):
+            return True
+    return False
+
+
+def boundary_incomplete(matrix_lines):
+    text = "\n".join(matrix_lines).lower()
+    return any(token in text for token in ["boundary-missing", "happy-path-only", "unresolved"])
+
+
+def discover_openapi_file():
+    for candidate in OPENAPI_CANDIDATES:
+        if os.path.isfile(candidate):
+            return candidate
+    return ""
+
+
+def boundary_validator_passed(report_path, openapi_file):
+    for validator in BOUNDARY_VALIDATOR_CANDIDATES:
+        if not os.path.isfile(validator):
+            continue
+        args = [sys.executable, validator, "--report", report_path]
+        if openapi_file:
+            args.extend(["--openapi", openapi_file])
+        result = subprocess.run(
+            args,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        if result.returncode == 0:
+            return True
+    return False
+
+
+def scope_list(report_text, name):
+    values = []
+    in_list = False
+    marker = "- {}:".format(name)
+    for raw_line in extract_section(report_text, "## Scope"):
+        line = raw_line.strip()
+        if line == marker:
+            in_list = True
+            continue
+        if not in_list:
+            continue
+        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 path_is_inside_project(project_root, candidate):
+    try:
+        return os.path.commonpath([project_root, candidate]) == project_root
+    except ValueError:
+        return False
+
+
+def scope_fresh_ok(report_path, marker, report_text):
+    try:
+        report_mtime = os.path.getmtime(report_path)
+        marker_mtime = os.path.getmtime(marker)
+    except OSError:
+        return False
+    if report_mtime < marker_mtime:
+        return False
+
+    source_files = scope_list(report_text, "In-Scope Source Files")
+    test_files = scope_list(report_text, "In-Scope Test Files")
+    if not source_files or not test_files:
+        return False
+
+    project_root = os.path.realpath(os.getcwd())
+    for listed_file in source_files + test_files:
+        normalized = listed_file.strip().strip("`")
+        if not normalized or normalized.lower() in IGNORED_SCOPE_VALUES:
+            return False
+        candidate = normalized if os.path.isabs(normalized) else os.path.join(os.getcwd(), normalized)
+        candidate_real = os.path.realpath(candidate)
+        if not path_is_inside_project(project_root, candidate_real):
+            return False
+        if not os.path.isfile(candidate_real):
+            return False
+        if os.path.getmtime(candidate_real) > report_mtime:
+            return False
+    return True
+
+
+def write_report_pointer(feature_slug, report_path):
+    path = pointer_path(feature_slug)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as fh:
+        fh.write(report_path + "\n")
+    return path
+
+
+def update_checkpoint(checkpoint_path):
+    script_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "update-checkpoint.py")
+    if not checkpoint_path:
+        return True, ""
+    result = subprocess.run(
+        [
+            sys.executable,
+            script_path,
+            "--checkpoint-path",
+            checkpoint_path,
+            "--step",
+            "prizmkit-test",
+            "--status",
+            "completed",
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        check=False,
+    )
+    if result.returncode == 0:
+        return True, ""
+    output = " ".join((result.stdout or "").split())
+    return False, output[:500]
+
+
+def validate_report(report_path, marker, feature_slug, expected_artifact_dir):
+    try:
+        report_text = read_text(report_path)
+    except OSError as exc:
+        return {
+            "status": "FAIL",
+            "reason": "unreadable_report",
+            "error": str(exc),
+            "report": report_path,
+        }
+
+    report_mode = extract_scope_field(report_text, "Mode")
+    report_artifact_dir = extract_scope_field(report_text, "Artifact Dir")
+    report_verdict = extract_verdict(report_text)
+
+    boundary_gate = extract_section(report_text, "## Boundary Completion Gate")
+    boundary_matrix = extract_section(report_text, "## Boundary Matrix")
+    boundary_validation = extract_section(report_text, "## Boundary Validation")
+
+    gate_passed = extract_key_value(boundary_gate, "Completion gate passed")
+    boundary_missing = extract_key_value(boundary_gate, "Boundary-missing")
+    happy_path_only = extract_key_value(boundary_gate, "Happy-path-only")
+    validation_result = extract_key_value(boundary_validation, "Validator result").lower()
+
+    columns_ok = boundary_columns_ok(boundary_matrix)
+    incomplete = boundary_incomplete(boundary_matrix)
+    openapi_file = discover_openapi_file()
+    validator_ok = boundary_validator_passed(report_path, openapi_file)
+    fresh_ok = scope_fresh_ok(report_path, marker, report_text)
+
+    artifact_ok = normalize_artifact_dir(report_artifact_dir) == normalize_artifact_dir(expected_artifact_dir)
+    boundary_ok = (
+        columns_ok
+        and not incomplete
+        and gate_passed == "yes"
+        and boundary_missing == "0"
+        and happy_path_only == "0"
+        and validation_result == "passed"
+        and validator_ok
+        and fresh_ok
+    )
+
+    result = {
+        "status": "PASS" if report_mode == "this-change" and artifact_ok and report_verdict == "PASS" and boundary_ok else "FAIL",
+        "verdict": report_verdict,
+        "mode": report_mode,
+        "artifact_dir": report_artifact_dir,
+        "boundary_gate": gate_passed,
+        "boundary_missing": boundary_missing,
+        "happy_path_only": happy_path_only,
+        "boundary_validation": validation_result,
+        "validator_passed": "1" if validator_ok else "0",
+        "scope_fresh": "1" if fresh_ok else "0",
+        "openapi": openapi_file,
+        "report": report_path,
+        "feature_slug": feature_slug,
+    }
+    if not columns_ok:
+        result["reason"] = "boundary_columns_missing"
+    elif incomplete:
+        result["reason"] = "boundary_incomplete"
+    elif not fresh_ok:
+        result["reason"] = "scope_not_fresh"
+    elif not artifact_ok:
+        result["reason"] = "wrong_artifact_dir"
+    elif report_mode != "this-change":
+        result["reason"] = "wrong_mode"
+    elif report_verdict != "PASS":
+        result["reason"] = "verdict_not_pass"
+    elif not validator_ok:
+        result["reason"] = "validator_failed"
+    elif not boundary_ok:
+        result["reason"] = "boundary_gate_failed"
+    return result
+
+
+def check_gate(feature_slug, artifact_dir=None, checkpoint_path=None):
+    expected_artifact_dir = artifact_dir or default_artifact_dir(feature_slug)
+    marker = marker_path(feature_slug)
+    report_path = newest_report_after_marker(marker)
+    if not report_path:
+        return {"status": "MISSING", "marker": marker}
+
+    result = validate_report(report_path, marker, feature_slug, expected_artifact_dir)
+    if result["status"] != "PASS":
+        return result
+
+    write_report_pointer(feature_slug, report_path)
+    checkpoint_ok, checkpoint_error = update_checkpoint(checkpoint_path)
+    if not checkpoint_ok:
+        result["status"] = "FAIL"
+        result["reason"] = "checkpoint_update_failed"
+        result["checkpoint_error"] = checkpoint_error
+    return result
+
+
+def format_result(result):
+    status = result.get("status") or result.get("gate", "")
+    if status == "GATE:START":
+        return "GATE:START marker={}".format(result.get("marker", ""))
+    if status == "MISSING":
+        return "GATE:MISSING marker={}".format(result.get("marker", ""))
+    if status == "PASS":
+        return "GATE:PASS {}".format(result.get("report", ""))
+
+    ordered = [
+        "reason",
+        "verdict",
+        "mode",
+        "artifact_dir",
+        "boundary_gate",
+        "boundary_missing",
+        "happy_path_only",
+        "boundary_validation",
+        "validator_passed",
+        "scope_fresh",
+        "openapi",
+        "report",
+        "checkpoint_error",
+        "error",
+    ]
+    parts = []
+    for key in ordered:
+        value = result.get(key)
+        if value is not None and value != "":
+            parts.append("{}={}".format(key, value))
+    return "GATE:FAIL {}".format(" ".join(parts)).rstrip()
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        description="Run the scoped PrizmKit feature test gate.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    start = subparsers.add_parser("start", help="Create the test gate marker")
+    start.add_argument("--feature-slug", required=True)
+
+    check = subparsers.add_parser("check", help="Validate the latest scoped test report")
+    check.add_argument("--feature-slug", required=True)
+    check.add_argument("--artifact-dir", default="")
+    check.add_argument("--checkpoint-path", default="")
+    return parser
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.command == "start":
+        result = start_gate(args.feature_slug)
+    else:
+        result = check_gate(args.feature_slug, args.artifact_dir, args.checkpoint_path)
+    print(format_result(result))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bundled/dev-pipeline-windows/templates/sections/phase-prizmkit-test.md

@@ -1,13 +1,12 @@
 ### Scoped Feature Test Gate — PrizmKit Test
 
-**Goal**: Generate and verify tests for this feature's changed scope before code review.
+**Goal**: Generate and verify tests for this feature's changed scope before code review without embedding the full gate implementation in this prompt.
 
 Create a start marker immediately before invoking the skill so the gate can reject stale reports from older sessions:
 
 ```powershell
-New-Item -ItemType Directory -Force -Path ".prizmkit/specs/{{FEATURE_SLUG}}" | Out-Null
-$testGateMarker = ".prizmkit/specs/{{FEATURE_SLUG}}/.prizmkit-test-started"
-New-Item -ItemType File -Force -Path $testGateMarker | Out-Null
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\prizmkit-test-gate.py start `
+  --feature-slug "{{FEATURE_SLUG}}"
 ```
 
 Run `/prizmkit-test` with the feature artifact directory:
@@ -24,163 +23,17 @@ Rules:
 - If failures are baseline or unrelated to this feature, document them in the report and continue only when no in-scope failure remains unexplained.
 
 **Gate Check — Test Report**:
-After `/prizmkit-test` returns, locate the newest test report created after the start marker and validate that it belongs to this feature scope, has a PASS verdict, and has passed the boundary completion/validation gates before writing the checkpoint pointer:
-```powershell
-$featureArtifactDir = ".prizmkit/specs/{{FEATURE_SLUG}}/"
-$latestTestReport = Get-ChildItem -Path ".prizmkit/test" -Filter "test-report.md" -Recurse -ErrorAction SilentlyContinue |
-  Where-Object { $_.LastWriteTime -ge (Get-Item -LiteralPath $testGateMarker).LastWriteTime } |
-  Sort-Object FullName |
-  Select-Object -Last 1
+After `/prizmkit-test` returns, run the gate script to locate the newest current-run report, validate scope/freshness/boundary coverage, write `test-report-path.txt`, and mark the `prizmkit-test` checkpoint completed only on `GATE:PASS`:
 
-if ($latestTestReport) {
-  $lines = Get-Content -LiteralPath $latestTestReport.FullName -ErrorAction SilentlyContinue
-  $inScope = $false
-  $reportMode = ""
-  $reportArtifactDir = ""
-  $reportVerdict = ""
-  $inBoundaryGate = $false
-  $inBoundaryValidation = $false
-  $inBoundaryMatrix = $false
-  $boundaryGatePassed = ""
-  $boundaryMissing = ""
-  $happyPathOnly = ""
-  $boundaryValidationResult = ""
-  $boundaryColumnsOk = $false
-  $boundaryIncomplete = $false
-  for ($i = 0; $i -lt $lines.Count; $i++) {
-    $line = $lines[$i]
-    if ($line -match '^## Scope\s*$') { $inScope = $true; $inBoundaryGate = $false; $inBoundaryValidation = $false; $inBoundaryMatrix = $false; continue }
-    if ($line -match '^## Boundary Matrix\s*$') { $inBoundaryMatrix = $true; $inScope = $false; $inBoundaryGate = $false; $inBoundaryValidation = $false; continue }
-    if ($line -match '^## Boundary Completion Gate\s*$') { $inBoundaryGate = $true; $inScope = $false; $inBoundaryValidation = $false; $inBoundaryMatrix = $false; continue }
-    if ($line -match '^## Boundary Validation\s*$') { $inBoundaryValidation = $true; $inScope = $false; $inBoundaryGate = $false; $inBoundaryMatrix = $false; continue }
-    if ($line -match '^## ' -and $inScope) { $inScope = $false }
-    if ($line -match '^## ' -and $inBoundaryMatrix) { $inBoundaryMatrix = $false }
-    if ($line -match '^## ' -and $inBoundaryGate) { $inBoundaryGate = $false }
-    if ($line -match '^## ' -and $inBoundaryValidation) { $inBoundaryValidation = $false }
-    if ($inScope -and $line -match '^- Mode:\s*(.+)$') { $reportMode = $Matches[1].Trim() }
-    if ($inScope -and $line -match '^- Artifact Dir:\s*(.+)$') { $reportArtifactDir = $Matches[1].Trim() }
-    if ($inBoundaryMatrix -and $line -match '^\|') {
-      $hasRequiredColumns =
-        $line -match '\|\s*Module\s*\|' -and
-        $line -match '\|\s*Interface\s*\|' -and
-        $line -match '\|\s*Service Type\s*\|' -and
-        $line -match '\|\s*Happy Path\s*\|' -and
-        $line -match '\|\s*Request Validation\s*\|' -and
-        $line -match '\|\s*Auth / Permission / Ownership\s*\|' -and
-        $line -match '\|\s*Domain Invariants\s*\|' -and
-        $line -match '\|\s*Collection / Pagination\s*\|' -and
-        $line -match '\|\s*Date / Time\s*\|' -and
-        $line -match '\|\s*State Transitions\s*\|' -and
-        $line -match '\|\s*Dependency Failure\s*\|' -and
-        $line -match '\|\s*Response Contract\s*\|' -and
-        $line -match '\|\s*N/A Reasons\s*\|' -and
-        $line -match '\|\s*Final Status\s*\|'
-      if ($hasRequiredColumns) { $boundaryColumnsOk = $true }
-      if ($line -match 'boundary-missing|happy-path-only|unresolved') { $boundaryIncomplete = $true }
-    }
-    if ($inBoundaryGate -and $line -match '^-?\s*Completion gate passed:\s*yes\s*$') { $boundaryGatePassed = "yes" }
-    if ($inBoundaryGate -and $line -match '^-?\s*Boundary-missing:\s*(\d+)\s*$') { $boundaryMissing = $Matches[1].Trim() }
-    if ($inBoundaryGate -and $line -match '^-?\s*Happy-path-only:\s*(\d+)\s*$') { $happyPathOnly = $Matches[1].Trim() }
-    if ($inBoundaryValidation -and $line -match '^-?\s*Validator result:\s*(\S+)') { $boundaryValidationResult = $Matches[1].Trim().ToLowerInvariant() }
-    if ($line -match '^## Verdict\s*$') {
-      for ($j = $i + 1; $j -lt $lines.Count; $j++) {
-        if ($lines[$j].Trim()) { $reportVerdict = $lines[$j].Trim(); break }
-      }
-      break
-    }
-  }
-  $openapiFile = ""
-  $openapiCandidates = @(
-    "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"
-  )
-  foreach ($openapiCandidate in $openapiCandidates) {
-    if (Test-Path -LiteralPath $openapiCandidate) { $openapiFile = $openapiCandidate; break }
-  }
-  $boundaryValidatorPassed = $false
-  $boundaryValidators = @(
-    ".claude/command-assets/prizmkit-test/scripts/validate_boundary_report.py",
-    ".codebuddy/skills/prizmkit-test/scripts/validate_boundary_report.py",
-    ".agents/skills/prizmkit-test/scripts/validate_boundary_report.py"
-  )
-  foreach ($boundaryValidator in $boundaryValidators) {
-    if (Test-Path -LiteralPath $boundaryValidator) {
-      $boundaryValidatorArgs = @($boundaryValidator, "--report", $latestTestReport.FullName)
-      if ($openapiFile) { $boundaryValidatorArgs += @("--openapi", $openapiFile) }
-      Invoke-PrizmPython @boundaryValidatorArgs *> $null
-      if ($LASTEXITCODE -eq 0) { $boundaryValidatorPassed = $true; break }
-    }
-  }
-  $scopeFreshOk = $false
-  try {
-    $reportMtime = (Get-Item -LiteralPath $latestTestReport.FullName).LastWriteTimeUtc
-    $markerMtime = (Get-Item -LiteralPath $testGateMarker).LastWriteTimeUtc
-    if ($reportMtime -ge $markerMtime) {
-      function Get-ScopedFileList($sectionName) {
-        $inScopeSection = $false
-        $inList = $false
-        $values = @()
-        foreach ($rawLine in $lines) {
-          $line = $rawLine.Trim()
-          if ($line -match '^## Scope\s*$') { $inScopeSection = $true; continue }
-          if ($inScopeSection -and $line -match '^## ') { break }
-          if (-not $inScopeSection) { continue }
-          if ($line -eq "- ${sectionName}:") { $inList = $true; continue }
-          if ($inList) {
-            if ($rawLine -match '^\s{2,}-\s+(.+)$') {
-              $value = $Matches[1].Trim().Trim('`')
-              if ($value -and $value -ne '{...}' -and $value -ne '...') { $values += $value }
-              continue
-            }
-            if ($line -match '^- ') { break }
-          }
-        }
-        return $values
-      }
-      $sourceFiles = @(Get-ScopedFileList "In-Scope Source Files")
-      $testFiles = @(Get-ScopedFileList "In-Scope Test Files")
-      if ($sourceFiles.Count -gt 0 -and $testFiles.Count -gt 0) {
-        $scopeFreshOk = $true
-        $projectRoot = (Resolve-Path ".").Path
-        $ignored = @('none', 'n/a', 'not applicable', '(none)', '{...}', '...')
-        foreach ($listedFile in $sourceFiles + $testFiles) {
-          $normalized = $listedFile.Trim().Trim('`')
-          if (-not $normalized -or $ignored -contains $normalized.ToLowerInvariant()) { $scopeFreshOk = $false; break }
-          if ([System.IO.Path]::IsPathRooted($normalized)) { $candidate = $normalized } else { $candidate = Join-Path $projectRoot $normalized }
-          if (-not (Test-Path -LiteralPath $candidate -PathType Leaf)) { $scopeFreshOk = $false; break }
-          $candidatePath = (Resolve-Path -LiteralPath $candidate).Path
-          if (-not ($candidatePath -eq $projectRoot -or $candidatePath.StartsWith($projectRoot + [System.IO.Path]::DirectorySeparatorChar))) { $scopeFreshOk = $false; break }
-          if ((Get-Item -LiteralPath $candidatePath).LastWriteTimeUtc -gt $reportMtime) { $scopeFreshOk = $false; break }
-        }
-      }
-    }
-  } catch {
-    $scopeFreshOk = $false
-  }
-  $artifactOk = $reportArtifactDir -eq $featureArtifactDir -or $reportArtifactDir -eq $featureArtifactDir.TrimEnd('/')
-  $boundaryOk = $boundaryColumnsOk -and -not $boundaryIncomplete -and $boundaryGatePassed -eq "yes" -and $boundaryMissing -eq "0" -and $happyPathOnly -eq "0" -and $boundaryValidationResult -eq "passed" -and $boundaryValidatorPassed -and $scopeFreshOk
-  if ($reportMode -eq "this-change" -and $artifactOk -and $reportVerdict -eq "PASS" -and $boundaryOk) {
-    Set-Content -LiteralPath ".prizmkit/specs/{{FEATURE_SLUG}}/test-report-path.txt" -Value $latestTestReport.FullName
-    "GATE:PASS $($latestTestReport.FullName)"
-  } else {
-    "GATE:FAIL verdict=$reportVerdict mode=$reportMode artifact_dir=$reportArtifactDir boundary_gate=$boundaryGatePassed boundary_missing=$boundaryMissing happy_path_only=$happyPathOnly boundary_validation=$boundaryValidationResult validator_passed=$boundaryValidatorPassed scope_fresh=$scopeFreshOk openapi=$openapiFile report=$($latestTestReport.FullName)"
-  }
-} else {
-  "GATE:MISSING"
-}
+```powershell
+Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\prizmkit-test-gate.py check `
+  --feature-slug "{{FEATURE_SLUG}}" `
+  --artifact-dir ".prizmkit/specs/{{FEATURE_SLUG}}/" `
+  --checkpoint-path "{{CHECKPOINT_PATH}}"
 ```
 
 Gate outcomes:
-- `GATE:PASS` → append the report path and a 3-5 bullet summary to `context-snapshot.md` under `## PrizmKit Test Gate`, then update the checkpoint.
+- `GATE:PASS` → append the report path and a 3-5 bullet summary to `context-snapshot.md` under `## PrizmKit Test Gate`, then proceed to the next checkpoint step. The gate script already wrote `test-report-path.txt` and marked `prizmkit-test` completed.
 - `GATE:FAIL` with `NEEDS_FIXES` → read the report's `In-Scope Failures`, fix the feature implementation or generated tests within this feature scope, rerun `/prizmkit-test`, and repeat the gate check. Do not proceed to code review while the verdict is not `PASS`.
-- `GATE:FAIL` with `BLOCKED`, wrong mode, wrong artifact dir, or unreadable report → write `.prizmkit/specs/{{FEATURE_SLUG}}/failure-log.md` with the scoped test failure and stop for recovery.
+- `GATE:FAIL` with `BLOCKED`, wrong mode, wrong artifact dir, unreadable report, stale scope, boundary failure, validator failure, or checkpoint update failure → write `.prizmkit/specs/{{FEATURE_SLUG}}/failure-log.md` with the scoped test failure and stop for recovery.
 - `GATE:MISSING` → perform one bounded status check: inspect `/prizmkit-test` output and `.prizmkit/test/` for a report directory. If no current-run report exists, write `failure-log.md` and stop for recovery.
-
-Only after `GATE:PASS`, run the update script to set step `prizmkit-test` to `"completed"`:
-```powershell
-Invoke-PrizmPython {{PIPELINE_DIR}}\scripts\update-checkpoint.py `
-  --checkpoint-path {{CHECKPOINT_PATH}} `
-  --step prizmkit-test `
-  --status completed
-```

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.87",
+  "version": "1.1.89",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.87",
+  "version": "1.1.89",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {