prizmkit 1.1.129 → 1.1.131

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

@@ -22,9 +22,11 @@ from prompt_framework import (
     merge_checkpoint_state,
     mode_agent_count,
     normalize_mode,
+    pipeline_checkpoint_metadata,
     read_text_file,
     render_from_sections,
     replace_placeholders,
+    route_pipeline_repair,
     validate_rendered,
     write_output,
 )
@@ -34,6 +36,30 @@ from utils import enrich_global_context, helper_replacements, load_json_file, re
 LOGGER = setup_logging("generate-refactor-prompt")
 
 
+def route_refactor_repair(stage_result, repair_scope=None, repair_round=0):
+    """Map Refactor review/test outcomes to the shared safe route contract."""
+    return route_pipeline_repair(stage_result, repair_scope, repair_round)
+
+
+def refactor_checkpoint_metadata(artifact_dir, evidence=None, stage="plan",
+                                 status="PLAN_READY", stage_result=None,
+                                 repair_scope=None, repair_round=0,
+                                 next_stage="prizmkit-implement",
+                                 resume_from="prizmkit-implement"):
+    """Build Refactor L4 handoff metadata while preserving Refactor L1 state."""
+    return pipeline_checkpoint_metadata(
+        artifact_dir,
+        evidence=evidence,
+        stage=stage,
+        status=status,
+        stage_result=stage_result,
+        repair_scope=repair_scope,
+        repair_round=repair_round,
+        next_stage=next_stage,
+        resume_from=resume_from,
+    )
+
+
 REFACTOR_SECTION_TO_SKILL = {
     "refactor-phase-init": checkpoint_step("prizmkit-init", "Initialize", [".prizmkit/refactor/{slug}"]),
     "refactor-phase-plan": checkpoint_step(
@@ -48,6 +74,14 @@ REFACTOR_SECTION_TO_SKILL = {
         "prizmkit-code-review", "Review — Code Review & Behavior Verification",
         [".prizmkit/refactor/{slug}/review-report.md"],
     ),
+    "refactor-phase-test": checkpoint_step(
+        "prizmkit-test", "Post-Review Test Gate",
+        [
+            ".prizmkit/test/evidence/*/manifest.json",
+            ".prizmkit/test/evidence/*/verdict.json",
+            ".prizmkit/test/evidence/*/validation.json",
+        ],
+    ),
     "phase-browser": checkpoint_step("browser-verification", "Browser Verification", []),
     "refactor-phase-commit-report": checkpoint_group([
         ("prizmkit-retrospective", "Retrospective", []),
@@ -383,7 +417,7 @@ def _refactor_header(pipeline_mode):
     return title + "\n" + desc + "\n"
 
 
-def assemble_refactor_sections(pipeline_mode, sections_dir, browser_enabled):
+def assemble_refactor_sections(pipeline_mode, sections_dir, browser_enabled, browser_tool="auto"):
     sections = [
         ("header", _refactor_header(pipeline_mode)),
         ("refactor-session-context", load_section(sections_dir, "refactor-session-context.md")),
@@ -399,10 +433,16 @@ def assemble_refactor_sections(pipeline_mode, sections_dir, browser_enabled):
     sections.extend([
         ("refactor-phase-implement", load_section(sections_dir, "refactor-phase-implement.md")),
         ("refactor-phase-review", load_section(sections_dir, "refactor-phase-review.md")),
+        ("refactor-phase-test", load_section(sections_dir, "refactor-phase-test.md")),
     ])
     if browser_enabled:
-        sections.append(("phase-browser", load_section(sections_dir, "phase-browser-verification-auto.md")))
+        browser_section_file = {
+            "playwright-cli": "phase-browser-verification.md",
+            "opencli": "phase-browser-verification-opencli.md",
+        }.get(browser_tool, "phase-browser-verification-auto.md")
+        sections.append(("phase-browser", load_section(sections_dir, browser_section_file)))
     sections.extend([
+        ("headless-commit-authorization", load_section(sections_dir, "headless-commit-authorization.md")),
         ("refactor-phase-commit-report", load_section(sections_dir, "refactor-phase-commit-report.md")),
         ("refactor-session-status", load_section(sections_dir, "refactor-session-status.md")),
         ("refactor-critical-paths", load_section(sections_dir, "refactor-critical-paths.md")),
@@ -419,6 +459,7 @@ def generate_refactor_checkpoint(refactor_id, session_id, pipeline_mode="standar
             ("refactor-phase-plan", ""),
             ("refactor-phase-implement", ""),
             ("refactor-phase-review", ""),
+            ("refactor-phase-test", ""),
             ("refactor-phase-commit-report", ""),
         ]
     return generate_checkpoint_from_sections(
@@ -434,7 +475,11 @@ def generate_refactor_checkpoint(refactor_id, session_id, pipeline_mode="standar
 
 
 def merge_refactor_checkpoint_state(existing, fresh, project_root):
-    return merge_checkpoint_state(existing, fresh, project_root, logger=LOGGER)
+    merged = merge_checkpoint_state(existing, fresh, project_root, logger=LOGGER)
+    existing_state = existing.get("refactor_state")
+    if isinstance(existing_state, dict):
+        merged["refactor_state"] = existing_state
+    return merged
 
 
 def emit_failure(message):
@@ -469,7 +514,10 @@ def main():
     sections = []
     if use_sections:
         try:
-            sections = assemble_refactor_sections(pipeline_mode, sections_dir, browser_enabled)
+            sections = assemble_refactor_sections(
+                pipeline_mode, sections_dir, browser_enabled,
+                browser_tool=replacements["{{BROWSER_TOOL}}"],
+            )
             rendered = render_from_sections(sections, replacements)
         except FileNotFoundError as exc:
             LOGGER.warning("Refactor section assembly failed (%s), falling back to legacy template", exc)
@@ -504,6 +552,18 @@ def main():
     checkpoint = generate_refactor_checkpoint(
         args.refactor_id, args.session_id, pipeline_mode, sections if use_sections else None,
     )
+    if not any(step.get("skill") == "prizmkit-test" for step in checkpoint["steps"]):
+        emit_failure("Refactor checkpoint is missing the mandatory prizmkit-test stage")
+    checkpoint["refactor_state"] = refactor_checkpoint_metadata(
+        replacements["{{ARTIFACT_DIR}}"],
+        stage="plan",
+        status="PLAN_READY",
+        stage_result=None,
+        repair_scope=None,
+        repair_round=0,
+        next_stage="prizmkit-implement",
+        resume_from="prizmkit-implement",
+    )
 
     if (args.resume_phase != "null" or is_continuation(args)) and os.path.exists(checkpoint_path):
         try:

package/bundled/dev-pipeline/scripts/prompt_framework.py

@@ -10,6 +10,137 @@ import os
 import re
 
 
+MAX_OUTER_REPAIR_ROUNDS = 3
+REPAIR_SCOPES_REQUIRING_REVIEW = {
+    "production",
+    "runtime",
+    "schema",
+    "dependency",
+    "public-interface",
+}
+
+
+def route_pipeline_repair(stage_result, repair_scope=None, repair_round=0):
+    """Map review/test outcomes to bounded, safe L4 continuation routes."""
+    try:
+        current_round = int(repair_round)
+    except (TypeError, ValueError):
+        current_round = MAX_OUTER_REPAIR_ROUNDS
+    if current_round < 0:
+        current_round = MAX_OUTER_REPAIR_ROUNDS
+
+    result = {
+        "stage_result": stage_result,
+        "repair_scope": repair_scope,
+        "repair_round": current_round,
+        "blocked": False,
+        "resumable": False,
+        "next_stage": None,
+        "resume_from": None,
+        "route": [],
+        "reason": "",
+        "blocked_reason": None,
+        "terminal_status": None,
+    }
+    if stage_result == "TEST_PASS":
+        result.update(
+            next_stage="prizmkit-retrospective",
+            resume_from="prizmkit-retrospective",
+            reason="authoritative test evidence passed",
+        )
+        return result
+    if stage_result == "TEST_BLOCKED":
+        result.update(
+            blocked=True,
+            resumable=False,
+            reason="bounded automatic recovery cannot safely edit production",
+            blocked_reason="test_blocked",
+            terminal_status="WORKFLOW_BLOCKED",
+        )
+        return result
+    if stage_result not in {"REVIEW_NEEDS_FIXES", "TEST_FAIL"}:
+        result.update(
+            blocked=True,
+            reason="unknown stage result is unsafe",
+            blocked_reason="unknown_stage_result",
+            terminal_status="WORKFLOW_BLOCKED",
+        )
+        return result
+    if current_round >= MAX_OUTER_REPAIR_ROUNDS:
+        result.update(
+            blocked=True,
+            reason="maximum outer repair rounds reached",
+            blocked_reason="repair_round_limit",
+            terminal_status="WORKFLOW_BLOCKED",
+        )
+        return result
+
+    result["repair_round"] = current_round + 1
+    if stage_result == "REVIEW_NEEDS_FIXES":
+        result.update(
+            next_stage="prizmkit-implement",
+            resume_from="prizmkit-implement",
+            route=["prizmkit-implement", "prizmkit-code-review", "prizmkit-test"],
+            reason="review findings require implementation and fresh review",
+        )
+        return result
+    if repair_scope == "test-infrastructure":
+        result.update(
+            next_stage="prizmkit-implement",
+            resume_from="prizmkit-implement",
+            route=["prizmkit-implement", "prizmkit-test"],
+            reason="test infrastructure failure must not edit production speculatively",
+        )
+        return result
+    if repair_scope in REPAIR_SCOPES_REQUIRING_REVIEW:
+        result.update(
+            next_stage="prizmkit-implement",
+            resume_from="prizmkit-implement",
+            route=["prizmkit-implement", "prizmkit-code-review", "prizmkit-test"],
+            reason="production-facing failure requires review before retesting",
+        )
+        return result
+    result.update(
+        blocked=True,
+        reason="unknown repair scope has no safe automatic route",
+        blocked_reason="unsafe_repair_scope",
+        terminal_status="WORKFLOW_BLOCKED",
+    )
+    return result
+
+
+def pipeline_checkpoint_metadata(artifact_dir, evidence=None, stage="plan",
+                                 status="PLAN_READY", stage_result=None,
+                                 repair_scope=None, repair_round=0,
+                                 next_stage="prizmkit-implement",
+                                 resume_from="prizmkit-implement",
+                                 blocked_reason=None, terminal_status=None):
+    """Build family-neutral semantic L4 metadata without replacing L1 state."""
+    evidence = evidence or {}
+    current_stage = None if terminal_status else stage
+    semantic_next_stage = None if terminal_status else next_stage
+    return {
+        "schema_version": 1,
+        "artifact_dir": artifact_dir,
+        "orchestrator": "prizmkit-l4",
+        "stage": stage,
+        "current_stage": current_stage,
+        "status": status,
+        "stage_result": stage_result,
+        "repair_scope": repair_scope,
+        "repair_round": repair_round,
+        "authoritative_evidence_paths": {
+            "manifest": evidence.get("manifest_path"),
+            "verdict": evidence.get("verdict_path"),
+            "validation": evidence.get("validation_path"),
+        },
+        "next_stage": semantic_next_stage,
+        "resume_from": resume_from,
+        "blocked_reason": blocked_reason,
+        "terminal_status": terminal_status,
+    }
+
+
 def read_text_file(path):
     """Read and return the text content of a file, plus an error string."""
     abs_path = os.path.abspath(path)
@@ -257,8 +388,19 @@ def merge_checkpoint_state(existing, fresh, project_root, validator=None, logger
         previous_status = previous.get("status", "pending") if isinstance(previous, dict) else "pending"
         if previous_status == "completed":
             artifacts = step.get("required_artifacts", [])
-            if validator(step.get("skill", ""), artifacts):
+            skill = step.get("skill", "")
+            stage_result = previous.get("stage_result") if isinstance(previous, dict) else None
+            verdict_valid = (
+                (skill != "prizmkit-code-review" or stage_result == "REVIEW_PASS")
+                and (skill != "prizmkit-test" or stage_result == "TEST_PASS")
+            )
+            if verdict_valid and validator(skill, artifacts):
                 step["status"] = "completed"
+                if stage_result:
+                    step["stage_result"] = stage_result
+                evidence = previous.get("authoritative_evidence_paths")
+                if isinstance(evidence, dict):
+                    step["authoritative_evidence_paths"] = evidence
                 continue
             if logger is not None:
                 logger.warning(
@@ -271,6 +413,15 @@ def merge_checkpoint_state(existing, fresh, project_root, validator=None, logger
         chain_broken = True
         step["status"] = "pending"
 
+    workflow_type = fresh.get("workflow_type", "")
+    state_key = {
+        "feature-pipeline": "feature_state",
+        "bugfix-pipeline": "bugfix_state",
+        "refactor-pipeline": "refactor_state",
+    }.get(workflow_type)
+    if state_key and isinstance(existing.get(state_key), dict):
+        fresh[state_key] = dict(existing[state_key])
+
     return fresh
 
 
@@ -327,21 +478,19 @@ def detect_dev_server_port(project_root):
 
 
 def browser_enabled_from_item(item):
-    """Return browser enabled/tool/steps with mandatory-attempt defaults."""
+    """Return browser enabled/tool/steps with explicit opt-in semantics."""
     browser_interaction = item.get("browser_interaction") if isinstance(item, dict) else None
     env_value = os.environ.get("BROWSER_VERIFY", "").lower()
     if env_value == "false":
         return False, "auto", "", False
 
-    enabled = True
+    enabled = False
     tool = "auto"
     blocking = False
     steps = []
 
-    if isinstance(browser_interaction, bool):
-        enabled = browser_interaction
-    elif isinstance(browser_interaction, dict):
-        enabled = browser_interaction.get("enabled", True)
+    if isinstance(browser_interaction, dict):
+        enabled = True
         tool = browser_interaction.get("tool", "auto")
         blocking = bool(browser_interaction.get("blocking", False))
         steps = browser_interaction.get("verify_steps", []) or []

package/bundled/dev-pipeline/scripts/update-bug-status.py

@@ -46,6 +46,7 @@ SESSION_STATUS_VALUES = [
     "infra_error",
     "context_overflow",
     "stalled_context_continuation",
+    "workflow_blocked",
     "commit_missing",
     "docs_missing",
     "merge_conflict",
@@ -88,6 +89,7 @@ def parse_args():
     parser.add_argument("--continuation-summary-path", default=None, help="Optional continuation summary artifact path.")
     parser.add_argument("--no-progress-count", type=int, default=None, help="Consecutive context-overflow sessions without objective progress.")
     parser.add_argument("--progress-fingerprint", default=None, help="JSON progress fingerprint captured after the session.")
+    parser.add_argument("--checkpoint-state", default=None, help="JSON semantic L4 checkpoint snapshot captured after the session.")
     return parser.parse_args()
 
 
@@ -253,6 +255,37 @@ def _load_progress_fingerprint(raw):
         return {"unparsed": str(raw)}
 
 
+SEMANTIC_CHECKPOINT_FIELDS = (
+    "current_stage",
+    "next_stage",
+    "stage_result",
+    "repair_scope",
+    "repair_round",
+    "authoritative_evidence_paths",
+    "blocked_reason",
+    "terminal_status",
+)
+
+
+def _load_checkpoint_state(raw):
+    if not raw:
+        return {}
+    try:
+        data = json.loads(raw)
+    except (TypeError, ValueError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return {key: data.get(key) for key in SEMANTIC_CHECKPOINT_FIELDS}
+
+
+def _sync_semantic_checkpoint(status_data, args):
+    semantic = _load_checkpoint_state(getattr(args, "checkpoint_state", None))
+    if semantic:
+        status_data.update(semantic)
+    return {key: status_data.get(key) for key in SEMANTIC_CHECKPOINT_FIELDS}
+
+
 def _set_continuation_common(status_data, args, session_id):
     if args.active_dev_branch:
         status_data["active_dev_branch"] = args.active_dev_branch
@@ -494,6 +527,7 @@ def action_update(args, bug_list_path, state_dir):
     fingerprint = _load_progress_fingerprint(args.progress_fingerprint)
     if fingerprint is not None:
         bs["last_progress_fingerprint"] = fingerprint
+    semantic_checkpoint = _sync_semantic_checkpoint(bs, args)
 
 
     if session_status == "success":
@@ -560,6 +594,19 @@ def action_update(args, bug_list_path, state_dir):
             if err:
                 error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
                 return
+    elif session_status == "workflow_blocked":
+        # Semantic terminal state: preserve partial work without consuming any retry budget.
+        new_status = "needs_info"
+        bs["continuation_pending"] = False
+        bs["needs_attention"] = True
+        bs["terminal_status"] = "WORKFLOW_BLOCKED"
+        bs["blocked_reason"] = (
+            semantic_checkpoint.get("blocked_reason") or "workflow_blocked"
+        )
+        err = update_bug_in_list(bug_list_path, bug_id, new_status)
+        if err:
+            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
+            return
     elif session_status == "stalled_context_continuation":
         # No-progress context-overflow stall pauses automation without consuming retry budgets.
         set_stalled_context_continuation_metadata(bs, args, session_id)
@@ -616,6 +663,7 @@ def action_update(args, bug_list_path, state_dir):
         "infra_error_count": bs.get("infra_error_count", 0),
         "max_infra_retries": max_infra_retries,
         "resume_from_phase": bs.get("resume_from_phase"),
+        "checkpoint_state": semantic_checkpoint,
         "updated_at": bs["updated_at"],
     }
     if session_status in ("commit_missing", "docs_missing", "merge_conflict"):
@@ -630,6 +678,11 @@ def action_update(args, bug_list_path, state_dir):
         summary["restart_policy"] = "context_overflow_continuation"
         summary.update(continuation_metadata_summary(bs))
         summary["artifacts_preserved"] = True
+    elif session_status == "workflow_blocked":
+        summary["restart_policy"] = "terminal_blocked"
+        summary.update(continuation_metadata_summary(bs))
+        summary["checkpoint_state"] = semantic_checkpoint
+        summary["artifacts_preserved"] = True
     elif session_status == "stalled_context_continuation":
         summary["restart_policy"] = "needs_attention"
         summary.update(continuation_metadata_summary(bs))