prizmkit 1.1.87 → 1.1.89

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.87",
-  "bundledAt": "2026-07-01T13:22:59.563Z",
-  "bundledFrom": "3ecfd63"
+  "frameworkVersion": "1.1.89",
+  "bundledAt": "2026-07-01T15:42:06.738Z",
+  "bundledFrom": "4e9108f"
 }

package/bundled/dev-pipeline/run-bugfix.sh

@@ -483,19 +483,6 @@ run_one() {
         local bugs_count
         bugs_count=$(echo "$init_result" | python3 -c "import sys,json; print(json.load(sys.stdin).get('bugs_count', 0))" 2>/dev/null || echo "0")
         log_success "Bugfix pipeline initialized with $bugs_count bugs"
-
-        # Ensure state directory is gitignored
-        local _gitignore_path
-        _gitignore_path="$PROJECT_ROOT/.gitignore"
-        local _state_rel
-        _state_rel=$(python3 -c "import os; print(os.path.relpath('$STATE_DIR', '$PROJECT_ROOT'))" 2>/dev/null || echo ".prizmkit/state/bugfix")
-        if [[ -f "$_gitignore_path" ]]; then
-            if ! grep -qF "$_state_rel" "$_gitignore_path" 2>/dev/null; then
-                printf '\n# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" >> "$_gitignore_path"
-            fi
-        else
-            printf '# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" > "$_gitignore_path"
-        fi
     fi
 
     # Verify bug exists
@@ -843,19 +830,6 @@ main() {
         local bugs_count
         bugs_count=$(echo "$init_result" | python3 -c "import sys,json; print(json.load(sys.stdin).get('bugs_count', 0))" 2>/dev/null || echo "0")
         log_success "Bugfix pipeline initialized with $bugs_count bugs"
-
-        # Ensure state directory is gitignored
-        local _gitignore_path
-        _gitignore_path="$PROJECT_ROOT/.gitignore"
-        local _state_rel
-        _state_rel=$(python3 -c "import os; print(os.path.relpath('$STATE_DIR', '$PROJECT_ROOT'))" 2>/dev/null || echo ".prizmkit/state/bugfix")
-        if [[ -f "$_gitignore_path" ]]; then
-            if ! grep -qF "$_state_rel" "$_gitignore_path" 2>/dev/null; then
-                printf '\n# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" >> "$_gitignore_path"
-            fi
-        else
-            printf '# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" > "$_gitignore_path"
-        fi
     else
         log_info "Resuming existing bugfix pipeline..."
     fi

package/bundled/dev-pipeline/run-feature.sh

@@ -1084,21 +1084,6 @@ main() {
         local features_count
         features_count=$(echo "$init_result" | python3 -c "import sys,json; print(json.load(sys.stdin).get('features_count', 0))" 2>/dev/null || echo "0")
         log_success "Pipeline initialized with $features_count features"
-
-        # Ensure state directory is gitignored (prevents branch-switch state loss)
-        local _gitignore_path
-        _gitignore_path="$PROJECT_ROOT/.gitignore"
-        local _state_rel
-        _state_rel=$(python3 -c "import os; print(os.path.relpath('$STATE_DIR', '$PROJECT_ROOT'))" 2>/dev/null || echo ".prizmkit/state/features")
-        if [[ -f "$_gitignore_path" ]]; then
-            if ! grep -qF "$_state_rel" "$_gitignore_path" 2>/dev/null; then
-                printf '\n# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" >> "$_gitignore_path"
-                log_info "Added $_state_rel/ to .gitignore"
-            fi
-        else
-            printf '# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" > "$_gitignore_path"
-            log_info "Created .gitignore with $_state_rel/"
-        fi
     else
         log_info "Resuming existing pipeline..."
     fi

package/bundled/dev-pipeline/run-refactor.sh

@@ -510,19 +510,6 @@ run_one() {
         local refactors_count
         refactors_count=$(echo "$init_result" | python3 -c "import sys,json; print(json.load(sys.stdin).get('refactors_count', 0))" 2>/dev/null || echo "0")
         log_success "Refactor pipeline initialized with $refactors_count refactors"
-
-        # Ensure state directory is gitignored
-        local _gitignore_path
-        _gitignore_path="$PROJECT_ROOT/.gitignore"
-        local _state_rel
-        _state_rel=$(python3 -c "import os; print(os.path.relpath('$STATE_DIR', '$PROJECT_ROOT'))" 2>/dev/null || echo ".prizmkit/state/refactor")
-        if [[ -f "$_gitignore_path" ]]; then
-            if ! grep -qF "$_state_rel" "$_gitignore_path" 2>/dev/null; then
-                printf '\n# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" >> "$_gitignore_path"
-            fi
-        else
-            printf '# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" > "$_gitignore_path"
-        fi
     fi
 
     # Verify refactor exists
@@ -873,19 +860,6 @@ main() {
         local refactors_count
         refactors_count=$(echo "$init_result" | python3 -c "import sys,json; print(json.load(sys.stdin).get('refactors_count', 0))" 2>/dev/null || echo "0")
         log_success "Refactor pipeline initialized with $refactors_count refactors"
-
-        # Ensure state directory is gitignored
-        local _gitignore_path
-        _gitignore_path="$PROJECT_ROOT/.gitignore"
-        local _state_rel
-        _state_rel=$(python3 -c "import os; print(os.path.relpath('$STATE_DIR', '$PROJECT_ROOT'))" 2>/dev/null || echo ".prizmkit/state/refactor")
-        if [[ -f "$_gitignore_path" ]]; then
-            if ! grep -qF "$_state_rel" "$_gitignore_path" 2>/dev/null; then
-                printf '\n# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" >> "$_gitignore_path"
-            fi
-        else
-            printf '# Pipeline runtime state (auto-added by dev-pipeline)\n%s/\n' "$_state_rel" > "$_gitignore_path"
-        fi
     else
         log_info "Resuming existing refactor pipeline..."
     fi

package/bundled/dev-pipeline/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())