prizmkit 1.1.122 → 1.1.123

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.122",
-  "bundledAt": "2026-07-11T17:19:34.691Z",
-  "bundledFrom": "fbcb3f4"
+  "frameworkVersion": "1.1.123",
+  "bundledAt": "2026-07-11T17:38:07.991Z",
+  "bundledFrom": "9a8c719"
 }

package/bundled/dev-pipeline/prizmkit_runtime/runners.py

@@ -107,31 +107,39 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
     from .runner_models import PipelineRunResult
 
     processed = 0
-    details: list[str] = []
+    item_statuses: dict[str, str] = {}
     if invocation.item_id:
         try:
             status = _process_item(family, invocation, invocation.item_id, paths, initial_metadata={})
         except KeyboardInterrupt:
-            return PipelineRunResult(False, 1, "interrupted", "interrupted", tuple(details))
-        return PipelineRunResult(status == "completed", 1, "single_item_done", status, tuple(details))
+            return PipelineRunResult(False, 1, "interrupted", "interrupted")
+        return PipelineRunResult(status == "completed", 1, "single_item_done", status)
 
     while True:
         next_result = get_next(family, invocation, paths.project_root)
+        details = _render_item_statuses(item_statuses)
         if not next_result.ok:
             return PipelineRunResult(False, processed, "get_next_failed", details=(next_result.text,))
         marker = next_result.stdout.strip()
         if marker == "PIPELINE_COMPLETE":
-            if _has_non_terminal_details(details):
+            blocking_statuses = _blocking_statuses(family, item_statuses)
+            if blocking_statuses:
                 return PipelineRunResult(
                     False,
                     processed,
                     "pipeline_complete_with_non_terminal_history",
-                    _last_detail_status(details),
-                    tuple(details),
+                    blocking_statuses[-1],
+                    details,
                 )
-            return PipelineRunResult(True, processed, "pipeline_complete", details=tuple(details))
+            return PipelineRunResult(
+                True,
+                processed,
+                "pipeline_complete",
+                _last_item_status(item_statuses),
+                details,
+            )
         if marker == "PIPELINE_BLOCKED":
-            return PipelineRunResult(False, processed, "pipeline_blocked", details=tuple(details))
+            return PipelineRunResult(False, processed, "pipeline_blocked", details=details)
         if not isinstance(next_result.data, dict):
             return PipelineRunResult(False, processed, "invalid_get_next_output", details=(marker[:500],))
         item_id = str(next_result.data.get(f"{family.kind}_id") or next_result.data.get("feature_id") or next_result.data.get("bug_id") or next_result.data.get("refactor_id") or "")
@@ -141,50 +149,50 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
             final_status = _process_item(family, invocation, item_id, paths, initial_metadata=next_result.data)
         except KeyboardInterrupt:
             processed += 1
-            details.append(f"{item_id}:interrupted")
-            return PipelineRunResult(False, processed, "interrupted", "interrupted", tuple(details))
+            item_statuses[item_id] = "interrupted"
+            return PipelineRunResult(
+                False,
+                processed,
+                "interrupted",
+                "interrupted",
+                _render_item_statuses(item_statuses),
+            )
         processed += 1
-        details.append(f"{item_id}:{final_status}")
-        if final_status == "completed":
-            _emit_info(f"Pausing 5s before next {family.kind}...")
+        item_statuses[item_id] = final_status
+        if final_status in _completion_compatible_statuses(family):
+            if final_status == "completed":
+                _emit_info(f"Pausing 5s before next {family.kind}...")
             continue
         if final_status == "pending":
             continue
+        details = _render_item_statuses(item_statuses)
         if RunnerEnvironment.from_env().stop_on_failure:
-            return PipelineRunResult(False, processed, "stop_on_failure", final_status, tuple(details))
+            return PipelineRunResult(False, processed, "stop_on_failure", final_status, details)
         if final_status in {"failed", "needs_info"}:
-            return PipelineRunResult(False, processed, "item_failed", final_status, tuple(details))
+            return PipelineRunResult(False, processed, "item_failed", final_status, details)
+
 
+_COMPLETION_COMPATIBLE_STATUSES = {"completed", "skipped", "auto_skipped"}
 
-_NON_TERMINAL_DETAIL_STATUSES = {
-    "pending",
-    "retryable",
-    "in_progress",
-    "infra_error",
-    "context_overflow",
-    "stalled_context_continuation",
-    "crashed",
-    "timed_out",
-    "failed",
-    "needs_info",
-    "merge_conflict",
-    "interrupted",
-    "unknown",
-}
 
+def _completion_compatible_statuses(family: RunnerFamily) -> set[str]:
+    statuses = set(_COMPLETION_COMPATIBLE_STATUSES)
+    if family.kind == "feature":
+        statuses.add("split")
+    return statuses
 
-def _detail_status(detail: str) -> str:
-    return detail.rsplit(":", 1)[-1] if ":" in detail else detail
 
+def _render_item_statuses(item_statuses: Mapping[str, str]) -> tuple[str, ...]:
+    return tuple(f"{item_id}:{status}" for item_id, status in item_statuses.items())
 
-def _last_detail_status(details: list[str]) -> str:
-    if not details:
-        return ""
-    return _detail_status(details[-1])
+
+def _last_item_status(item_statuses: Mapping[str, str]) -> str:
+    return next(reversed(item_statuses.values()), "")
 
 
-def _has_non_terminal_details(details: list[str]) -> bool:
-    return any(_detail_status(detail) in _NON_TERMINAL_DETAIL_STATUSES for detail in details)
+def _blocking_statuses(family: RunnerFamily, item_statuses: Mapping[str, str]) -> tuple[str, ...]:
+    compatible = _completion_compatible_statuses(family)
+    return tuple(status for status in item_statuses.values() if status not in compatible)
 
 
 _SEPARATOR = "─" * 52

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

@@ -627,39 +627,194 @@ def test_status_bridge_passes_max_retries_from_invocation_or_environment(monkeyp
     assert second[second.index("--max-retries") + 1] == "6"
 
 
-def test_stop_on_failure_does_not_stop_on_retryable_pending(monkeypatch, tmp_path):
+@pytest.mark.parametrize(
+    ("kind", "item_key"),
+    (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
+)
+def test_pipeline_aggregate_replaces_same_item_status_in_first_seen_order(monkeypatch, tmp_path, kind, item_key):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
     paths = _make_paths(tmp_path)
-    family = family_for("feature", paths)
+    family = family_for(kind, paths)
     invocation = parse_invocation(family, "run", ())
-    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    statuses = iter(("completed", "pending", "completed"))
     queue = [
-        SimpleNamespace(ok=True, stdout=json.dumps({"feature_id": "F-001"}), data={"feature_id": "F-001"}, text=""),
-        SimpleNamespace(ok=True, stdout=json.dumps({"feature_id": "F-002"}), data={"feature_id": "F-002"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-049"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-050"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-050"}, text=""),
         SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
     ]
-    processed = []
 
-    monkeypatch.setenv("STOP_ON_FAILURE", "1")
     monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: next(statuses))
+    monkeypatch.setattr(runners, "_emit_info", lambda *args, **kwargs: None)
 
-    def fake_process(_family, _invocation, item_id, _paths, *, initial_metadata):
-        processed.append(item_id)
-        return "pending" if item_id == "F-001" else "completed"
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert result.processed == 3
+    assert result.completed is True
+    assert result.stopped_reason == "pipeline_complete"
+    assert result.last_status == "completed"
+    assert result.details == ("F-049:completed", "F-050:completed")
 
-    monkeypatch.setattr(runners, "_process_item", fake_process)
+
+@pytest.mark.parametrize(
+    ("kind", "item_key"),
+    (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
+)
+def test_pipeline_aggregate_keeps_distinct_unresolved_item_blocking(monkeypatch, tmp_path, kind, item_key):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    statuses = iter(("pending", "completed"))
+    queue = [
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-002"}, text=""),
+        SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
+    ]
+
+    monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: next(statuses))
+    monkeypatch.setattr(runners, "_emit_info", lambda *args, **kwargs: None)
 
     result = runners._run_pipeline(family, invocation, paths)
 
-    assert processed == ["F-001", "F-002"]
+    assert result.processed == 2
     assert result.completed is False
     assert result.stopped_reason == "pipeline_complete_with_non_terminal_history"
-    assert result.last_status == "completed"
+    assert result.last_status == "pending"
     assert result.details == ("F-001:pending", "F-002:completed")
 
 
+@pytest.mark.parametrize(
+    ("kind", "item_key"),
+    (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
+)
+def test_pipeline_aggregate_repeated_terminal_update_remains_unique(monkeypatch, tmp_path, kind, item_key):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    queue = [
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
+    ]
+
+    monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: "completed")
+    monkeypatch.setattr(runners, "_emit_info", lambda *args, **kwargs: None)
+
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert result.processed == 2
+    assert result.details == ("F-001:completed",)
+    assert result.last_status == "completed"
+
+
+@pytest.mark.parametrize("kind", ("feature", "bugfix", "refactor"))
+def test_pipeline_aggregate_empty_authoritative_completion(monkeypatch, tmp_path, kind):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    monkeypatch.setattr(
+        runners,
+        "get_next",
+        lambda *args, **kwargs: SimpleNamespace(
+            ok=True,
+            stdout="PIPELINE_COMPLETE\n",
+            data=None,
+            text="PIPELINE_COMPLETE",
+        ),
+    )
+
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert result.processed == 0
+    assert result.completed is True
+    assert result.stopped_reason == "pipeline_complete"
+    assert result.last_status == ""
+    assert result.details == ()
+
+
+@pytest.mark.parametrize(
+    ("kind", "status", "expected_completed"),
+    (
+        ("feature", "completed", True),
+        ("feature", "skipped", True),
+        ("feature", "auto_skipped", True),
+        ("feature", "split", True),
+        ("bugfix", "completed", True),
+        ("bugfix", "skipped", True),
+        ("bugfix", "auto_skipped", True),
+        ("bugfix", "split", False),
+        ("refactor", "completed", True),
+        ("refactor", "skipped", True),
+        ("refactor", "auto_skipped", True),
+        ("refactor", "split", False),
+    ),
+)
+def test_pipeline_aggregate_completion_compatible_statuses(monkeypatch, tmp_path, kind, status, expected_completed):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    item_key = {"feature": "feature_id", "bugfix": "bug_id", "refactor": "refactor_id"}[kind]
+    queue = [
+        SimpleNamespace(ok=True, stdout="", data={item_key: "X-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
+    ]
+
+    monkeypatch.setenv("STOP_ON_FAILURE", "0")
+    monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: status)
+
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert result.completed is expected_completed
+    assert result.stopped_reason == (
+        "pipeline_complete" if expected_completed else "pipeline_complete_with_non_terminal_history"
+    )
+    assert result.last_status == status
+    assert result.details == (f"X-001:{status}",)
+
+
+@pytest.mark.parametrize("kind", ("feature", "bugfix", "refactor"))
+def test_run_pipeline_command_omits_empty_last_status_detail(monkeypatch, tmp_path, kind):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import PipelineRunResult
+
+    paths = _make_paths(tmp_path)
+    plan_path = {
+        "feature": paths.feature_plan,
+        "bugfix": paths.bugfix_plan,
+        "refactor": paths.refactor_plan,
+    }[kind]
+    plan_path.write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(
+        runners,
+        "_run_pipeline",
+        lambda *args, **kwargs: PipelineRunResult(True, 0, "pipeline_complete"),
+    )
+
+    result = runners.run_pipeline_command(kind, "run", (), paths)
+
+    assert result.exit_code == 0
+    assert result.message == "processed=0 completed=True stopped_reason=pipeline_complete"
+    assert result.details == ()
+
+
 def test_pipeline_complete_rejects_retryable_detail(monkeypatch, tmp_path):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.122",
+  "version": "1.1.123",
   "skills": {
     "prizmkit": {
       "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.122",
+  "version": "1.1.123",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {