prizmkit 1.1.153 → 1.1.155

package/bundled/dev-pipeline/templates/sections/runtime-commit-handoff.md

@@ -0,0 +1,35 @@
+### Runtime Commit Handoff
+
+The Python runtime, not the AI session, executes the pipeline's local Git commit. This stage contains no prompt-level commit authorization.
+
+After Code Review, all configured verification, `TEST_PASS`, family reports/summaries, and retrospective have completed:
+
+1. As the session orchestrator, validate every required stage artifact and result first. Atomic Skills do not perform this sequencing check.
+2. Invoke `/prizmkit-committer` with the same artifact root, exact readiness evidence, and request path:
+
+   ```text
+   /prizmkit-committer operation=prepare-runtime-commit artifact_dir={{ARTIFACT_DIR}} evidence_paths=<exact validated artifact paths> excluded_paths={{ARTIFACT_DIR}}/workflow-checkpoint.json request_path={{ARTIFACT_DIR}}/runtime-commit-request.json
+   ```
+
+3. The committer validates only the supplied evidence and final diff, then classifies paths before writing the request:
+   - all `.prizmkit/**` paths are PrizmKit-internal and stay outside the task commit, including config, plans, Prizm docs, lifecycle Artifacts, Runtime files, and state;
+   - `AGENTS.md`, `skills-lock.json`, installed platform directories, and local platform settings are support data and stay outside the task commit;
+   - project-specific transient data must already be covered by Git ignore rules;
+   - every other Git-visible path must be justified task output and included exactly, otherwise the handoff blocks.
+
+   It then rejects sensitive/unrelated/unknown paths, generates one Conventional Commit message, and writes this request without staging or committing:
+
+   ```json
+   {
+     "schema_version": 1,
+     "artifact_dir": "{{ARTIFACT_DIR}}",
+     "base_head": "<current HEAD commit hash>",
+     "commit_message": "<type>(<scope>): <description>",
+     "intended_paths": ["<exact project-relative changed path>"]
+   }
+   ```
+
+4. Require the stage-local result `COMMIT_REQUEST_READY`. Then this injected session—not the Skill—marks `prizmkit-committer` `in_progress` with `stage_result=COMMIT_PENDING` through the checkpoint helper. Do not mark it completed or write `COMMITTED`.
+5. Stop normal work after the valid request and checkpoint handoff exist. Do not run `git add`, `git commit`, `git commit --amend`, merge, push, or create additional files.
+
+The runtime validates exact task-owned path coverage outside recognized internal/support namespaces, rejects a request that explicitly names one of those namespaces, stages only the requested literal paths, executes and verifies the local commit, finalizes the Runtime-owned checkpoint to `COMMITTED`, and then performs its configured merge/publication behavior. Unknown Git-visible paths are not silently ignored: they produce a mismatch and preserve the task checkout for recovery. A malformed, stale, unsafe, incomplete, or contradictory request also blocks without deleting user data.

package/bundled/dev-pipeline/templates/session-status-schema.json

@@ -1,83 +1,66 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Dev-Pipeline Session Status",
-  "description": "Schema for session-status.json written by agent at session end",
+  "title": "Dev-Pipeline Runtime Session Status",
+  "description": "Schema for runner-owned session-status.json written after an AI process exits",
   "type": "object",
-  "required": ["session_id", "feature_id", "status", "timestamp"],
+  "required": [
+    "session_id",
+    "task_id",
+    "task_type",
+    "status",
+    "base_branch",
+    "active_dev_branch"
+  ],
   "properties": {
     "session_id": {
       "type": "string",
       "minLength": 1
     },
-    "feature_id": {
+    "task_id": {
       "type": "string",
-      "pattern": "^F-\\d{3}(-[A-Z])?$"
+      "pattern": "^[FBR]-\\d{3}(?:-[A-Z])?$"
     },
-    "status": {
+    "task_type": {
       "type": "string",
-      "enum": ["success", "partial", "failed", "crashed", "timed_out", "infra_error", "commit_missing", "docs_missing", "merge_conflict", "context_overflow", "stalled_context_continuation", "workflow_blocked", "workflow_skipped"]
-    },
-    "completed_phases": {
-      "type": "array",
-      "items": {
-        "type": "integer",
-        "minimum": 0,
-        "maximum": 7
-      }
-    },
-    "current_phase": {
-      "type": "integer",
-      "minimum": 0,
-      "maximum": 7
+      "enum": ["feature", "bugfix", "refactor"]
     },
-    "checkpoint_reached": {
+    "status": {
       "type": "string",
-      "pattern": "^CP-[0-3]$"
-    },
-    "tasks_completed": {
-      "type": "integer",
-      "minimum": 0
-    },
-    "tasks_total": {
-      "type": "integer",
-      "minimum": 0
+      "enum": [
+        "success",
+        "failed",
+        "crashed",
+        "timed_out",
+        "infra_error",
+        "commit_missing",
+        "docs_missing",
+        "merge_conflict",
+        "context_overflow",
+        "stalled_context_continuation",
+        "workflow_blocked",
+        "workflow_skipped"
+      ]
     },
-    "errors": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": ["message"],
-        "properties": {
-          "phase": { "type": "integer" },
-          "type": { "type": "string" },
-          "message": { "type": "string" },
-          "recoverable": { "type": "boolean" }
-        }
-      }
-    },
-    "can_resume": {
-      "type": "boolean"
+    "base_branch": {
+      "type": "string",
+      "minLength": 1
     },
-    "docs_maintained": {
-      "type": "boolean"
+    "active_dev_branch": {
+      "type": "string",
+      "minLength": 1
     },
-    "retrospective_done": {
-      "type": "boolean"
+    "worktree_path": {
+      "type": "string"
     },
-    "resume_from_phase": {
-      "type": ["integer", "null"]
+    "reason": {
+      "type": "string"
     },
-    "artifacts": {
-      "type": "object",
-      "properties": {
-        "spec_path": { "type": "string" },
-        "plan_path": { "type": "string" },
-        "context_snapshot_path": { "type": "string" }
-      }
+    "fatal_error_code": {
+      "type": "string"
     },
-    "timestamp": {
-      "type": "string",
-      "format": "date-time"
+    "checkpoint_state": {
+      "type": "object"
     }
-  }
+  },
+  "additionalProperties": false
 }

package/bundled/dev-pipeline/tests/test_auto_skip.py

@@ -1,4 +1,4 @@
-"""Tests for auto-skip and unskip functionality in update-feature-status.py."""
+"""Tests for auto-skip and reset_state functionality in update-feature-status.py."""
 
 import json
 import os
@@ -221,6 +221,76 @@ class TestContextOverflowRetrySemantics:
         ]:
             assert key not in status
 
+    def test_start_and_update_persist_effective_retry_budgets_without_charging_workflow_skip(self, tmp_path):
+        scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
+
+        for case in self._script_cases(scripts_dir):
+            case_dir = tmp_path / f"budgets-{case['id']}"
+            state_dir = case_dir / "state"
+            list_path = case_dir / case["list_name"]
+            payload = json.loads(json.dumps(case["list_payload"]))
+            payload[case["collection"]][0]["status"] = "pending"
+            write_json_file(str(list_path), payload)
+
+            start = subprocess.run(
+                [
+                    "python3",
+                    str(case["script"]),
+                    case["list_option"],
+                    str(list_path),
+                    "--state-dir",
+                    str(state_dir),
+                    case["id_option"],
+                    case["id"],
+                    "--action",
+                    "start",
+                    "--max-retries",
+                    "7",
+                    "--max-infra-retries",
+                    "4",
+                ],
+                text=True,
+                capture_output=True,
+                check=True,
+            )
+            assert json.loads(start.stdout)["new_status"] == "in_progress"
+            started = self._runtime_status(state_dir, case["id"])
+            assert started["max_retries"] == 7
+            assert started["max_infra_retries"] == 4
+
+            skipped = subprocess.run(
+                [
+                    "python3",
+                    str(case["script"]),
+                    case["list_option"],
+                    str(list_path),
+                    "--state-dir",
+                    str(state_dir),
+                    case["id_option"],
+                    case["id"],
+                    "--session-id",
+                    "sess-skip",
+                    "--session-status",
+                    "workflow_skipped",
+                    "--action",
+                    "update",
+                    "--max-retries",
+                    "5",
+                    "--max-infra-retries",
+                    "2",
+                ],
+                text=True,
+                capture_output=True,
+                check=True,
+            )
+            summary = json.loads(skipped.stdout)
+            runtime = self._runtime_status(state_dir, case["id"])
+            assert summary["new_status"] == "skipped"
+            assert runtime["max_retries"] == 5
+            assert runtime["max_infra_retries"] == 2
+            assert runtime["retry_count"] == 0
+            assert runtime["infra_error_count"] == 0
+
     def test_context_overflow_consumes_retry_and_records_bounded_continuation_metadata(self, tmp_path):
         scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
 
@@ -441,10 +511,10 @@ class TestContextOverflowRetrySemantics:
             assert runtime["context_overflow_count"] == 2
             assert runtime["continuation_count"] == 2
 
-    def test_manual_reset_clean_and_unskip_clear_all_continuation_state(self, tmp_path):
+    def test_manual_reset_clean_and_reset_state_clear_all_continuation_state(self, tmp_path):
         scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
 
-        for action in ["reset", "clean", "unskip"]:
+        for action in ["reset", "clean", "reset_state"]:
             for case in self._script_cases(scripts_dir):
                 case_dir = tmp_path / f"{action}-{case['id']}"
                 state_dir = case_dir / "state"
@@ -503,7 +573,7 @@ class TestContextOverflowRetrySemantics:
                 ]
                 if action in ("reset", "clean"):
                     cmd.extend([case["id_option"], case["id"]])
-                elif action == "unskip":
+                elif action == "reset_state":
                     cmd.extend([case["id_option"], case["id"]])
                 if action == "clean":
                     cmd.extend(["--project-root", str(case_dir)])
@@ -515,7 +585,15 @@ class TestContextOverflowRetrySemantics:
                 for continuation_file in continuation_files:
                     assert not continuation_file.exists()
                 runtime = self._runtime_status(state_dir, case["id"])
-                self._assert_no_continuation_runtime_state(runtime)
+                if action == "reset_state":
+                    assert runtime["active_dev_branch"] == "dev/existing-branch"
+                    assert runtime["base_branch"] == "main"
+                    continuation_only = dict(runtime)
+                    continuation_only.pop("active_dev_branch")
+                    continuation_only.pop("base_branch")
+                    self._assert_no_continuation_runtime_state(continuation_only)
+                else:
+                    self._assert_no_continuation_runtime_state(runtime)
                 assert runtime["retry_count"] == 0
                 assert runtime["infra_error_count"] == 0
                 assert runtime["last_infra_error_session_id"] is None
@@ -601,6 +679,7 @@ class TestContextOverflowRetrySemantics:
                     "reset",
                     case["target"],
                     case["item_id"],
+                    "--fresh-checkout",
                     str(prizmkit_dir / "plans" / case["list_name"]),
                 ],
                 cwd=case_dir,
@@ -758,7 +837,7 @@ def _run_status_snapshot_action(case, list_path, state_dir, action, session_stat
         "--action",
         action,
     ]
-    if action in {"update", "reset", "clean", "unskip"}:
+    if action in {"update", "reset", "clean", "reset_state"}:
         cmd.extend([case["id_option"], case["id"]])
     if action == "update":
         cmd.extend([
@@ -1200,7 +1279,7 @@ class TestAutoSkipEdgeCases:
 
 
 # ---------------------------------------------------------------------------
-# action_unskip — via subprocess (tests the full CLI interface)
+# action_reset_state — via subprocess (tests the full CLI interface)
 # ---------------------------------------------------------------------------
 
 import subprocess
@@ -1210,12 +1289,12 @@ _SCRIPT = os.path.join(
 )
 
 
-def _run_unskip(fl_path, state_dir, feature_id=None):
+def _run_reset_state(fl_path, state_dir, feature_id=None):
     cmd = [
         "python3", _SCRIPT,
         "--feature-list", fl_path,
         "--state-dir", state_dir,
-        "--action", "unskip",
+        "--action", "reset_state",
     ]
     if feature_id:
         cmd += ["--feature-id", feature_id]
@@ -1344,7 +1423,7 @@ class TestInfraErrorUpdate:
         assert fs["last_infra_error_session_id"] is None
         assert _read_statuses(fl_path)["F-001"] == "pending"
 
-    def test_unskip_clears_infra_retry_counters(self, tmp_path):
+    def test_reset_state_clears_infra_retry_counters(self, tmp_path):
         features = [_make_feature("F-001", "Root", status="failed")]
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001"])
@@ -1355,7 +1434,7 @@ class TestInfraErrorUpdate:
         fs["last_infra_error_session_id"] = "session-infra-final"
         write_json_file(status_path, fs)
 
-        _run_unskip(fl_path, state_dir, "F-001")
+        _run_reset_state(fl_path, state_dir, "F-001")
 
         fs = load_feature_status(state_dir, "F-001")
         assert fs["retry_count"] == 0
@@ -1363,10 +1442,10 @@ class TestInfraErrorUpdate:
         assert fs["last_infra_error_session_id"] is None
         assert _read_statuses(fl_path)["F-001"] == "pending"
 
-class TestUnskipByFeatureId:
-    """Unskip with --feature-id targets a specific failed feature + downstream."""
+class TestResetStateByFeatureId:
+    """ResetState with --feature-id targets a specific failed feature + downstream."""
 
-    def test_unskip_failed_root_resets_all(self, tmp_path):
+    def test_reset_state_failed_root_resets_all(self, tmp_path):
         features = [
             _make_feature("F-001", "Root", status="failed"),
             _make_feature("F-002", "Mid", deps=["F-001"], status="auto_skipped"),
@@ -1375,14 +1454,14 @@ class TestUnskipByFeatureId:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
 
-        result = _run_unskip(fl_path, state_dir, "F-001")
+        result = _run_reset_state(fl_path, state_dir, "F-001")
 
         assert result["reset_count"] == 3
         statuses = _read_statuses(fl_path)
         assert all(s == "pending" for s in statuses.values())
 
-    def test_unskip_auto_skipped_leaf_resets_upstream(self, tmp_path):
-        """C2 fix: unskip F-003 must also find and reset F-001 (failed root)."""
+    def test_reset_state_auto_skipped_leaf_resets_upstream(self, tmp_path):
+        """C2 fix: reset_state F-003 must also find and reset F-001 (failed root)."""
         features = [
             _make_feature("F-001", "Root", status="failed"),
             _make_feature("F-002", "Mid", deps=["F-001"], status="auto_skipped"),
@@ -1391,14 +1470,14 @@ class TestUnskipByFeatureId:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
 
-        result = _run_unskip(fl_path, state_dir, "F-003")
+        result = _run_reset_state(fl_path, state_dir, "F-003")
 
         assert result["reset_count"] == 3
         reset_ids = {f["feature_id"] for f in result["features"]}
         assert "F-001" in reset_ids  # transitive upstream reset
         assert all(s == "pending" for s in _read_statuses(fl_path).values())
 
-    def test_unskip_preserves_completed_features(self, tmp_path):
+    def test_reset_state_preserves_completed_features(self, tmp_path):
         features = [
             _make_feature("F-001", "Done", status="completed"),
             _make_feature("F-002", "Failed", deps=["F-001"], status="failed"),
@@ -1407,7 +1486,7 @@ class TestUnskipByFeatureId:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
 
-        result = _run_unskip(fl_path, state_dir, "F-002")
+        result = _run_reset_state(fl_path, state_dir, "F-002")
 
         assert result["reset_count"] == 2
         statuses = _read_statuses(fl_path)
@@ -1415,8 +1494,8 @@ class TestUnskipByFeatureId:
         assert statuses["F-002"] == "pending"
         assert statuses["F-003"] == "pending"
 
-    def test_unskip_skipped_feature_resets_downstream(self, tmp_path):
-        """Unskip a manually-skipped feature should also reset its auto_skipped downstream."""
+    def test_reset_state_skipped_feature_resets_downstream(self, tmp_path):
+        """ResetState a manually-skipped feature should also reset its auto_skipped downstream."""
         features = [
             _make_feature("F-001", "Skipped", status="skipped"),
             _make_feature("F-002", "Child", deps=["F-001"], status="auto_skipped"),
@@ -1424,7 +1503,7 @@ class TestUnskipByFeatureId:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002"])
 
-        result = _run_unskip(fl_path, state_dir, "F-001")
+        result = _run_reset_state(fl_path, state_dir, "F-001")
 
         assert result["reset_count"] == 2
         statuses = _read_statuses(fl_path)
@@ -1432,8 +1511,8 @@ class TestUnskipByFeatureId:
         assert statuses["F-002"] == "pending"
 
 
-class TestUnskipAll:
-    """Unskip without --feature-id resets all failed + auto_skipped."""
+class TestResetStateAll:
+    """ResetState without --feature-id resets all failed + auto_skipped."""
 
     def test_resets_all_failed_and_auto_skipped(self, tmp_path):
         features = [
@@ -1445,7 +1524,7 @@ class TestUnskipAll:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003", "F-004"])
 
-        result = _run_unskip(fl_path, state_dir)
+        result = _run_reset_state(fl_path, state_dir)
 
         assert result["reset_count"] == 2
         statuses = _read_statuses(fl_path)
@@ -1456,11 +1535,11 @@ class TestUnskipAll:
 
 
 # ---------------------------------------------------------------------------
-# Integration: auto-skip → get_next → unskip → get_next
+# Integration: auto-skip → get_next → reset_state → get_next
 # ---------------------------------------------------------------------------
 
 class TestAutoSkipIntegration:
-    """Full lifecycle: fail → auto-skip → pipeline complete → unskip → resume."""
+    """Full lifecycle: fail → auto-skip → pipeline complete → reset_state → resume."""
 
     def test_full_lifecycle(self, tmp_path):
         features = [
@@ -1477,8 +1556,8 @@ class TestAutoSkipIntegration:
         # 2. get_next should return PIPELINE_COMPLETE
         assert _run_get_next(fl_path, state_dir) == "PIPELINE_COMPLETE"
 
-        # 3. Unskip recovers everything
-        _run_unskip(fl_path, state_dir, "F-001")
+        # 3. ResetState recovers everything
+        _run_reset_state(fl_path, state_dir, "F-001")
         statuses = _read_statuses(fl_path)
         assert statuses["F-001"] == "pending"
         assert statuses["F-002"] == "pending"
@@ -1488,7 +1567,7 @@ class TestAutoSkipIntegration:
         data = json.loads(output)
         assert data["feature_id"] == "F-001"
 
-    def test_retry_count_reset_after_unskip(self, tmp_path):
+    def test_retry_count_reset_after_reset_state(self, tmp_path):
         features = [
             _make_feature("F-001", "Root", status="failed"),
         ]
@@ -1502,7 +1581,7 @@ class TestAutoSkipIntegration:
         with open(fs_path, "w") as f:
             json.dump(fs, f)
 
-        _run_unskip(fl_path, state_dir, "F-001")
+        _run_reset_state(fl_path, state_dir, "F-001")
 
         with open(fs_path) as f:
             fs = json.load(f)