prizmkit 1.1.152 → 1.1.154

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

@@ -38,8 +38,11 @@ class ResetOptions:
     item_id: str = ""
     item_range: tuple[str, str] | None = None
     filter_mode: str = ""
+    state_only: bool = False
+    fresh_checkout: bool = False
     clean: bool = False
     preserve_runtime: bool = False
+    all_items: bool = False
     help_requested: bool = False
     unknown_args: tuple[str, ...] = ()
 
@@ -112,7 +115,7 @@ def run_reset_command(kind: str, legacy_args: tuple[str, ...], paths) -> Command
     list_path = _resolve_list_path(options.list_path, paths.project_root)
     if not list_path.is_file():
         return CommandResult(1, f"Python {kind} reset", f"{kind} list not found: {list_path}")
-    if not options.preserve_runtime and not (family.state_dir / "pipeline.json").is_file():
+    if (options.fresh_checkout or options.clean) and not (family.state_dir / "pipeline.json").is_file():
         return CommandResult(1, f"Python {kind} reset", f"No pipeline state found. Run the {kind} pipeline first to initialize.")
 
     options = ResetOptions(
@@ -120,8 +123,11 @@ def run_reset_command(kind: str, legacy_args: tuple[str, ...], paths) -> Command
         item_id=options.item_id,
         item_range=options.item_range,
         filter_mode=options.filter_mode,
+        state_only=options.state_only,
+        fresh_checkout=options.fresh_checkout,
         clean=options.clean,
         preserve_runtime=options.preserve_runtime,
+        all_items=options.all_items,
         help_requested=options.help_requested,
         unknown_args=options.unknown_args,
     )
@@ -140,6 +146,16 @@ def run_reset_command(kind: str, legacy_args: tuple[str, ...], paths) -> Command
             text,
             stdout=text,
         )
+    if options.state_only:
+        state_result = _run_state_only_updater(family, options, paths.project_root)
+        text = state_result.stdout.strip() or state_result.stderr.strip() or "State-only reset failed"
+        ok = state_result.returncode == 0 and _json_without_error(state_result.stdout)
+        return CommandResult(
+            0 if ok else 1,
+            f"Python {kind} reset --state-only",
+            text,
+            stdout=text,
+        )
 
     try:
         items = _resolve_items(family, options)
@@ -174,8 +190,11 @@ def _parse_reset_args(family: RunnerFamily, legacy_args: Sequence[str]) -> Reset
     item_id = ""
     item_range: tuple[str, str] | None = None
     filter_mode = ""
+    state_only = False
+    fresh_checkout = False
     clean = False
     preserve_runtime = False
+    all_items = False
     help_requested = False
     unknown: list[str] = []
     positional: list[str] = []
@@ -183,16 +202,22 @@ def _parse_reset_args(family: RunnerFamily, legacy_args: Sequence[str]) -> Reset
     index = 0
     while index < len(args):
         arg = args[index]
-        if arg in {"--help", "-h", "help"}:
+        if arg in {"--help", "-h"}:
             help_requested = True
+        elif arg == "--state-only":
+            state_only = True
+        elif arg == "--fresh-checkout":
+            fresh_checkout = True
         elif arg == "--clean":
             clean = True
         elif arg == "--preserve-runtime":
             preserve_runtime = True
+        elif arg == "--all":
+            all_items = True
         elif arg == "--run":
             raise ValueError(
                 "Reset no longer accepts --run. Run reset first, then execute "
-                f"`{family.kind} run` as a separate command."
+                f"`run {family.kind}` as a separate command."
             )
         elif arg in FILTER_FLAGS:
             next_filter = FILTER_FLAGS[arg]
@@ -208,9 +233,15 @@ def _parse_reset_args(family: RunnerFamily, legacy_args: Sequence[str]) -> Reset
 
     for value in positional:
         if _looks_like_range(value, family.id_prefix):
-            item_range = _normalize_range(value, family.id_prefix)
-        elif _looks_like_item_id(value, family.id_prefix) and not item_id:
-            item_id = _normalize_item_id(value, family.id_prefix)
+            if item_range is None and not item_id:
+                item_range = _normalize_range(value, family.id_prefix)
+            else:
+                unknown.append(value)
+        elif _looks_like_item_id(value, family.id_prefix):
+            if not item_id and item_range is None:
+                item_id = _normalize_item_id(value, family.id_prefix)
+            else:
+                unknown.append(value)
         elif list_path == family.plan_path:
             list_path = Path(value).expanduser()
         else:
@@ -221,8 +252,11 @@ def _parse_reset_args(family: RunnerFamily, legacy_args: Sequence[str]) -> Reset
         item_id=item_id,
         item_range=item_range,
         filter_mode=filter_mode,
+        state_only=state_only,
+        fresh_checkout=fresh_checkout,
         clean=clean,
         preserve_runtime=preserve_runtime,
+        all_items=all_items,
         help_requested=help_requested,
         unknown_args=tuple(unknown),
     )
@@ -231,14 +265,51 @@ def _parse_reset_args(family: RunnerFamily, legacy_args: Sequence[str]) -> Reset
 def _reset_option_error(family: RunnerFamily, options: ResetOptions) -> str:
     if options.unknown_args:
         return "Unsupported reset arguments: " + " ".join(options.unknown_args)
-    if not options.preserve_runtime:
+
+    selected_modes = [
+        name
+        for name, enabled in (
+            ("--state-only", options.state_only),
+            ("--fresh-checkout", options.fresh_checkout),
+            ("--clean", options.clean),
+            ("--preserve-runtime", options.preserve_runtime),
+        )
+        if enabled
+    ]
+    if len(selected_modes) != 1:
+        return (
+            "Exactly one reset mode is required: --state-only, --fresh-checkout, "
+            "--clean, or --preserve-runtime.\n" + _help_text(family)
+        )
+
+    selectors = sum(
+        bool(value)
+        for value in (
+            options.item_id,
+            options.item_range,
+            options.filter_mode,
+            options.all_items,
+        )
+    )
+    if options.state_only:
+        if options.item_range or options.filter_mode:
+            return "--state-only accepts only one item ID or explicit --all; ranges and status filters are unsupported."
+        if selectors != 1 or not (options.item_id or options.all_items):
+            return "--state-only requires exactly one item ID or explicit --all."
+        return ""
+
+    if options.fresh_checkout or options.clean:
+        if options.all_items:
+            return "--all is supported only with --state-only."
+        if selectors != 1:
+            mode = "--clean" if options.clean else "--fresh-checkout"
+            return f"{mode} requires exactly one item ID, range, or supported status filter."
         return ""
+
     if options.filter_mode != "failed":
         return "--preserve-runtime requires --failed and cannot be used with another reset filter."
-    if options.clean:
-        return "--preserve-runtime and --clean are mutually exclusive."
-    if options.item_id or options.item_range:
-        return "--preserve-runtime is a whole-list failed-chain reset and cannot target an ID or range."
+    if options.item_id or options.item_range or options.all_items:
+        return "--preserve-runtime is a whole-list failed-chain reset and cannot target an ID, range, or --all."
     return ""
 
 
@@ -282,6 +353,8 @@ def _resolve_items(family: RunnerFamily, options: ResetOptions) -> tuple[ResetIt
     for item_id in ids:
         item = by_id.get(item_id)
         if not isinstance(item, dict):
+            if options.item_id:
+                raise ValueError(f"{FAMILY_LABELS[family.kind].title()} '{item_id}' not found in {options.list_path}")
             continue
         title = str(item.get(TITLE_FIELD_BY_KIND[family.kind]) or "")
         resolved.append(ResetItem(item_id=item_id, title=title, slug=_slug_for_item(family, item_id, title), status=str(item.get("status") or "unknown")))
@@ -339,6 +412,8 @@ def _reset_one(family: RunnerFamily, item: ResetItem, options: ResetOptions, pro
         except RuntimeError as exc:
             lines.append(f"ERROR: Reset {item.item_id} checkout identity failed: {exc}")
             return False
+        if options.fresh_checkout:
+            lines.append(f"Fresh-checkout boundary published for {item.item_id}")
         lines.append(f"{item.item_id} {action} complete: status -> pending, retry count -> 0")
         return True
     error = _error_text(result.stdout) or result.stderr.strip() or "unknown"
@@ -346,6 +421,33 @@ def _reset_one(family: RunnerFamily, item: ResetItem, options: ResetOptions, pro
     return False
 
 
+def _run_state_only_updater(
+    family: RunnerFamily,
+    options: ResetOptions,
+    project_root: Path,
+) -> subprocess.CompletedProcess[str]:
+    command = [
+        sys.executable,
+        str(family.updater_script),
+        family.list_arg,
+        str(options.list_path),
+        "--state-dir",
+        str(family.state_dir),
+        "--action",
+        "reset_state",
+    ]
+    if options.item_id:
+        command.extend([family.item_id_arg, options.item_id])
+    return subprocess.run(
+        command,
+        cwd=str(project_root),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        check=False,
+    )
+
+
 def _run_updater(family: RunnerFamily, action: str, options: ResetOptions, item: ResetItem, project_root: Path) -> subprocess.CompletedProcess[str]:
     command = [
         sys.executable,
@@ -455,9 +557,14 @@ def _numeric_suffix(value: str, prefix: str) -> int:
 def _help_text(family: RunnerFamily) -> str:
     label = FAMILY_LABELS[family.kind]
     return (
-        f"Usage: prizmkit-runtime reset {family.kind} <{label}-id|range> [--clean] "
-        "[--auto-skipped|--failed|--stalled] [list-path]\n"
+        f"Usage: prizmkit-runtime reset {family.kind} <{label}-id> --state-only [list-path]\n"
+        f"       prizmkit-runtime reset {family.kind} --state-only --all [list-path]\n"
+        f"       prizmkit-runtime reset {family.kind} <{label}-id|range> --fresh-checkout [list-path]\n"
+        f"       prizmkit-runtime reset {family.kind} <--auto-skipped|--failed|--stalled> --fresh-checkout [list-path]\n"
+        f"       prizmkit-runtime reset {family.kind} <{label}-id|range> --clean [list-path]\n"
+        f"       prizmkit-runtime reset {family.kind} <--auto-skipped|--failed|--stalled> --clean [list-path]\n"
         f"       prizmkit-runtime reset {family.kind} --failed --preserve-runtime [list-path]\n"
-        "Reset changes state only and never accepts --run; execute the matching family run command separately.\n"
-        "Standard/clean reset abandons the active checkout boundary. Preserve-runtime reset keeps task runtime and work."
+        "Exactly one reset mode is required. State-only preserves checkout, Git, checkpoints, and artifacts; "
+        "fresh-checkout publishes a new checkout boundary; clean is destructive; preserve-runtime is whole-list failed recovery.\n"
+        "Reset never accepts --run; execute the matching run <family> command separately."
     )

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

@@ -126,7 +126,7 @@ class PreserveRuntimeResetResult:
                 "Existing sessions, checkpoints, artifacts, branches, worktrees, and task work were not deleted.",
                 "Reset did not start a runner. Run separately:",
                 "python3 ./.prizmkit/dev-pipeline/cli.py "
-                f"{family.kind} run {shlex.quote(str(list_path))}",
+                f"run {family.kind} {shlex.quote(str(list_path))}",
             )
         )
         return tuple(lines)

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

@@ -285,7 +285,7 @@ def parse_invocation(
     index = 0
     while index < len(args):
         arg = args[index]
-        if arg in {"--help", "-h", "help"}:
+        if arg in {"--help", "-h"}:
             help_requested = True
         elif arg == "--dry-run":
             dry_run = True

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

@@ -1,4 +1,4 @@
-"""Python foreground runner dispatch for feature, bugfix, refactor, and recovery."""
+"""Python foreground runner dispatch for feature, bugfix, and refactor pipelines."""
 
 from __future__ import annotations
 
@@ -43,8 +43,7 @@ from .runner_bookkeeping import (
 from .runner_classification import classify_session, has_branch_completion_evidence, has_completed_artifact_path
 from .runner_models import RunnerEnvironment, RunnerFamily, RunnerInvocation, SessionPaths, family_for, parse_invocation
 from .runner_prompts import PromptGenerationResult, generate_prompt
-from .runner_recovery import run_recovery, run_recovery_detect
-from .runner_status import get_next, run_status_action, start_item, status_text, update_item
+from .runner_status import get_next, start_item, status_text, update_item
 from .sessions import AISessionConfig, AISessionLauncher, detect_stream_json_support
 from .task_checkout import (
     CHECKOUT_MODE_BRANCH,
@@ -95,21 +94,6 @@ def run_pipeline_command(kind: str, action: str, legacy_args: tuple[str, ...], p
     if action == "status":
         status = status_text(family, invocation, paths.project_root)
         return CommandResult(status.return_code, f"Python {kind} status", status.stdout.strip() or status.stderr.strip())
-    if action == "unskip":
-        status = run_status_action(
-            family,
-            "unskip",
-            invocation,
-            item_id=invocation.item_id,
-            project_root=paths.project_root,
-        )
-        return CommandResult(
-            status.return_code,
-            f"Python {kind} unskip",
-            status.stdout.strip() or status.stderr.strip(),
-        )
-    if action == "test-cli":
-        return _test_cli(kind, paths)
     if action != "run":
         return CommandResult(1, "Unsupported Python runner action", f"Unsupported action: {kind} {action}")
     if not invocation.list_path.is_file():
@@ -128,17 +112,6 @@ def run_pipeline_command(kind: str, action: str, legacy_args: tuple[str, ...], p
     )
 
 
-def run_recovery_command(action: str, legacy_args: tuple[str, ...], paths) -> CommandResult:
-    """Dispatch a Python recovery command."""
-    if action == "detect":
-        code, stdout, stderr, _data = run_recovery_detect(paths)
-        return CommandResult(code, "Python recovery detect", stdout.strip() or stderr.strip())
-    if action == "run":
-        code, stdout, stderr = run_recovery(paths, legacy_args)
-        return CommandResult(code, "Python recovery run", stdout.strip() or stderr.strip())
-    return CommandResult(1, "Unsupported Python recovery action", f"Unsupported action: {action}")
-
-
 def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) -> "PipelineRunResult":
     from .runner_models import PipelineRunResult
 
@@ -182,6 +155,14 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
         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 "")
         if not item_id:
             return PipelineRunResult(False, processed, "missing_item_id", details=(marker[:500],))
+        if item_id in item_statuses:
+            return PipelineRunResult(
+                False,
+                processed,
+                "reselected_item",
+                item_statuses[item_id],
+                _render_item_statuses(item_statuses),
+            )
         try:
             final_status = _process_item(family, invocation, item_id, paths, initial_metadata=next_result.data)
         except KeyboardInterrupt:
@@ -197,6 +178,14 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
                 )
         processed += 1
         item_statuses[item_id] = final_status
+        if final_status == "skipped":
+            return PipelineRunResult(
+                False,
+                processed,
+                "item_skipped",
+                final_status,
+                _render_item_statuses(item_statuses),
+            )
         if final_status in _completion_compatible_statuses(family):
             if final_status == "completed":
                 _emit_info(f"Pausing 5s before next {family.kind}...")
@@ -210,7 +199,7 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
             return PipelineRunResult(False, processed, "item_failed", final_status, details)
 
 
-_COMPLETION_COMPATIBLE_STATUSES = {"completed", "skipped", "auto_skipped"}
+_COMPLETION_COMPATIBLE_STATUSES = {"completed", "auto_skipped"}
 
 
 def _completion_compatible_statuses(family: RunnerFamily) -> set[str]:
@@ -1165,28 +1154,6 @@ def _record_setup_failure(
         branch_ensure_return(project_root, base_branch, branch_name)
     return new_status
 
-def _test_cli(kind: str, paths) -> CommandResult:
-    """Report the AI CLI resolution used by Python runner commands."""
-    config = load_runtime_config(paths)
-    cli = config.ai_client.command or "(not found)"
-    platform = config.ai_client.platform or "unresolved"
-    details = [
-        f"detected_cli: {cli}",
-        f"platform: {platform}",
-        f"source: {config.ai_client.source}",
-        f"runtime_mode: {config.runtime_mode}",
-    ]
-    if config.model:
-        details.append(f"model: {config.model}")
-    details.extend(f"note: {note}" for note in config.ai_client.notes)
-    return CommandResult(
-        0 if config.ai_client.command else 1,
-        f"Python {kind} AI CLI test",
-        "AI CLI resolution for the canonical Python runtime.",
-        tuple(details),
-    )
-
-
 def _use_worktree_for_family(env: RunnerEnvironment, family: RunnerFamily) -> bool:
     return env.use_worktree and family.kind in {"feature", "bugfix"}
 

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

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+import json
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -69,3 +70,107 @@ def default_status_targets(paths: RuntimePaths) -> dict[str, StatusTarget]:
         "bugfix": StatusTarget("bugfix", paths.bugfix_plan, paths.bugfix_state_dir),
         "refactor": StatusTarget("refactor", paths.refactor_plan, paths.refactor_state_dir),
     }
+
+
+@dataclass(frozen=True)
+class AggregateStatusResult:
+    """Deterministic read-only status output across every pipeline family."""
+
+    exit_code: int
+    output: str
+
+
+_FAMILY_PLAN_KEYS = {
+    "feature": "features",
+    "bugfix": "bugs",
+    "refactor": "refactors",
+}
+
+
+def _load_json_object(path: Path, label: str) -> dict[str, object]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"malformed {label}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ValueError(f"malformed {label}: expected a JSON object")
+    return data
+
+
+def _validate_status_inputs(target: StatusTarget) -> None:
+    """Validate only state consumed by status, without creating or repairing it."""
+    plan = _load_json_object(target.plan_path, "plan list")
+    items = plan.get(_FAMILY_PLAN_KEYS[target.kind])
+    if not isinstance(items, list):
+        raise ValueError(
+            f"malformed plan list: {_FAMILY_PLAN_KEYS[target.kind]} must be an array"
+        )
+
+    pipeline_state = target.state_dir / "pipeline.json"
+    if pipeline_state.exists():
+        if not pipeline_state.is_file():
+            raise ValueError("malformed runtime state: pipeline.json is not a file")
+        _load_json_object(pipeline_state, "runtime state pipeline.json")
+
+    for item in items:
+        if not isinstance(item, dict):
+            raise ValueError("malformed plan list: every task must be a JSON object")
+        item_id = item.get("id")
+        if not isinstance(item_id, str) or not item_id.strip():
+            raise ValueError("malformed plan list: every task requires a non-empty id")
+        status_path = target.state_dir / item_id / "status.json"
+        if status_path.exists():
+            if not status_path.is_file():
+                raise ValueError(
+                    f"malformed runtime state: {item_id}/status.json is not a file"
+                )
+            _load_json_object(status_path, f"runtime state {item_id}/status.json")
+
+
+def _render_family_result(result: object) -> tuple[int, str]:
+    exit_code = getattr(result, "exit_code", None)
+    render = getattr(result, "render", None)
+    if not isinstance(exit_code, int) or not callable(render):
+        raise ValueError("unparseable configured family result")
+    try:
+        rendered = render()
+    except Exception as exc:  # isolate one broken family result
+        raise ValueError(f"unparseable configured family result: {exc}") from exc
+    if not isinstance(rendered, str) or not rendered.strip():
+        raise ValueError("unparseable configured family result: empty output")
+    return exit_code, rendered.strip()
+
+
+def aggregate_family_status(
+    paths: RuntimePaths,
+    status_handler: Callable[[str], object],
+) -> AggregateStatusResult:
+    """Aggregate canonical family status handlers without mutating runtime state."""
+    targets = default_status_targets(paths)
+    sections: list[str] = []
+    failed = False
+
+    for family in ("feature", "bugfix", "refactor"):
+        target = targets[family]
+        label = family.upper()
+        body: str
+        if not target.plan_path.exists():
+            body = "not configured: plan list not found"
+        elif not target.plan_path.is_file():
+            failed = True
+            body = "error: malformed plan list: path is not a file"
+        else:
+            try:
+                _validate_status_inputs(target)
+                family_exit, rendered = _render_family_result(status_handler(family))
+                if family_exit != 0:
+                    failed = True
+                    body = f"error: {rendered}"
+                else:
+                    body = rendered
+            except Exception as exc:  # render remaining family sections truthfully
+                failed = True
+                body = f"error: {exc}"
+        sections.append(f"{label}\n{'=' * len(label)}\n{body}")
+
+    return AggregateStatusResult(1 if failed else 0, "\n\n".join(sections))

package/bundled/dev-pipeline/scripts/init-bugfix-pipeline.py

@@ -36,9 +36,9 @@ VALID_SEVERITIES = ["critical", "high", "medium", "low"]
 VALID_VERIFICATION_TYPES = ["automated", "manual", "hybrid"]
 VALID_STATUSES = [
     "pending", "in_progress", "completed", "failed",
-    "skipped", "needs_info",
+    "skipped", "needs_info", "auto_skipped",
 ]
-TERMINAL_STATUSES = {"completed", "failed", "skipped", "needs_info"}
+TERMINAL_STATUSES = {"completed", "failed", "skipped", "needs_info", "auto_skipped"}
 VALID_ERROR_SOURCE_TYPES = [
     "stack_trace", "user_report", "failed_test", "log_pattern", "monitoring_alert",
 ]

package/bundled/dev-pipeline/scripts/parse-stream-progress.py

@@ -820,24 +820,22 @@ class ProgressTracker:
                 self.message_count += 1
             elif event_type in {"message_update", "message_end"}:
                 assistant_event = event.get("assistantMessageEvent")
+                message = event.get("message")
                 text = ""
                 if isinstance(assistant_event, dict):
                     text = str(assistant_event.get("delta") or assistant_event.get("text") or "")
-                if not text:
-                    message = event.get("message")
-                    if isinstance(message, dict):
-                        content = message.get("content")
-                        if isinstance(content, str):
-                            text = content
-                        elif isinstance(content, list):
-                            text = "\n".join(
-                                str(item.get("text") or "")
-                                for item in content if isinstance(item, dict)
-                            )
+                if not text and isinstance(message, dict):
+                    content = message.get("content")
+                    if isinstance(content, str):
+                        text = content
+                    elif isinstance(content, list):
+                        text = "\n".join(
+                            str(item.get("text") or "")
+                            for item in content if isinstance(item, dict)
+                        )
                 if text.strip():
                     self.last_text_snippet = text.strip()[-120:]
                     self._detect_phase(text)
-                    self._detect_terminal_error(text, require_error_context=True)
                 if (
                     event_type == "message_end"
                     and isinstance(message, dict)