prizmkit 1.1.152 → 1.1.154

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

@@ -1,4 +1,4 @@
-"""Command contracts for the canonical PrizmKit Python runtime."""
+"""Executing command registry for the canonical operation-first runtime."""
 
 from __future__ import annotations
 
@@ -11,18 +11,19 @@ from .paths import RuntimePaths, resolve_runtime_paths
 RUNTIME_STATUS = "python-runtime-canonical"
 CANONICAL_RUNTIME_NOTE = "The Python CLI and prizmkit_runtime modules are the canonical runtime."
 PYTHON_CLI = "dev-pipeline/cli.py"
+_FAMILIES = ("feature", "bugfix", "refactor")
 
 
 @dataclass(frozen=True)
 class RuntimeCommand:
-    """Unified CLI command mapped to the Python behavior provider."""
+    """One public CLI command mapped to an executing or diagnostic handler."""
 
     group: str
     action: str
     target: str | None
-    current_entrypoint: str | None
-    entrypoint_kind: str | None
-    entrypoint_name: str | None
+    current_entrypoint: str
+    entrypoint_kind: str = "python-cli"
+    entrypoint_name: str = ""
     transition_status: str = RUNTIME_STATUS
     notes: tuple[str, ...] = (CANONICAL_RUNTIME_NOTE,)
 
@@ -54,12 +55,16 @@ class CommandResult:
 
 def _runtime_invocation(group: str, action: str, target: str | None = None) -> str:
     if group == "daemon" and target is not None:
-        return f"python3 {PYTHON_CLI} daemon {target} {action}"
-    if group == "reset" and target is not None and action == "reset":
-        return f"python3 {PYTHON_CLI} reset {target}"
-    if group == "status" and target is not None:
-        return f"python3 {PYTHON_CLI} status {target}"
-    return f"python3 {PYTHON_CLI} {group} {action}"
+        command = f"daemon {target} {action}"
+    elif group in {"run", "status", "reset"} and target is not None:
+        command = f"{group} {target}"
+    elif group == "diagnostics":
+        command = f"diagnostics {action}"
+    elif group == "helper":
+        command = "helper"
+    else:
+        command = f"{group} {action}"
+    return f"python3 {PYTHON_CLI} {command}"
 
 
 def _command(
@@ -74,74 +79,24 @@ def _command(
         target=target,
         action=action,
         current_entrypoint=_runtime_invocation(group, action, target),
-        entrypoint_kind="python-cli",
         entrypoint_name=group if target is None else f"{group}:{target}",
         notes=notes,
     )
 
 
-def _pipeline_commands() -> tuple[RuntimeCommand, ...]:
-    commands: list[RuntimeCommand] = []
-    action_matrix = {
-        "feature": ("run", "status", "reset", "unskip", "test-cli", "describe"),
-        "bugfix": ("run", "status", "reset", "unskip", "describe"),
-        "refactor": ("run", "status", "reset", "unskip", "describe"),
-        "recovery": ("run", "detect", "describe"),
-    }
-    for group, actions in action_matrix.items():
-        for action in actions:
-            commands.append(
-                _command(
-                    group,
-                    action,
-                    notes=(
-                        CANONICAL_RUNTIME_NOTE,
-                        "Foreground and recovery behavior is implemented in Python runtime modules.",
-                    ),
-                )
-            )
-    return tuple(commands)
-
-
-def _reset_commands() -> tuple[RuntimeCommand, ...]:
-    commands = [
+def _run_commands() -> tuple[RuntimeCommand, ...]:
+    return tuple(
         _command(
-            "reset",
-            "reset",
-            target=target,
+            "run",
+            "run",
+            target=family,
             notes=(
                 CANONICAL_RUNTIME_NOTE,
-                "Reset actions are explicit manual operations and are not part of automatic continuation recovery.",
+                "Foreground pipeline behavior is implemented in Python runtime modules.",
             ),
         )
-        for target in ("feature", "bugfix", "refactor")
-    ]
-    commands.append(
-        _command(
-            "reset",
-            "describe",
-            notes=(CANONICAL_RUNTIME_NOTE, "Lists destructive Python reset commands without running them."),
-        )
+        for family in _FAMILIES
     )
-    return tuple(commands)
-
-
-def _daemon_commands() -> tuple[RuntimeCommand, ...]:
-    commands: list[RuntimeCommand] = []
-    for target in ("feature", "bugfix", "refactor"):
-        for action in ("start", "stop", "status", "logs", "restart", "describe"):
-            commands.append(
-                _command(
-                    "daemon",
-                    action,
-                    target=target,
-                    notes=(
-                        CANONICAL_RUNTIME_NOTE,
-                        "Daemon lifecycle behavior is implemented by the Python daemon runtime.",
-                    ),
-                )
-            )
-    return tuple(commands)
 
 
 def _status_commands() -> tuple[RuntimeCommand, ...]:
@@ -149,44 +104,80 @@ def _status_commands() -> tuple[RuntimeCommand, ...]:
         _command(
             "status",
             "status",
-            target=target,
-            notes=(CANONICAL_RUNTIME_NOTE, "Status is resolved by the Python foreground runtime."),
+            target=family,
+            notes=(CANONICAL_RUNTIME_NOTE, "Status is resolved by the canonical family status handler."),
         )
-        for target in ("feature", "bugfix", "refactor")
+        for family in _FAMILIES
     ]
     commands.append(
         _command(
             "status",
             "status",
             target="all",
-            notes=(CANONICAL_RUNTIME_NOTE, "Aggregated status is represented at the Python CLI boundary."),
+            notes=(CANONICAL_RUNTIME_NOTE, "Aggregates configured family status handlers without mutation."),
         )
     )
     return tuple(commands)
 
 
+def _reset_commands() -> tuple[RuntimeCommand, ...]:
+    return tuple(
+        _command(
+            "reset",
+            "reset",
+            target=family,
+            notes=(
+                CANONICAL_RUNTIME_NOTE,
+                "Reset requires one explicit mode and never starts execution.",
+            ),
+        )
+        for family in _FAMILIES
+    )
+
+
+def _daemon_commands() -> tuple[RuntimeCommand, ...]:
+    return tuple(
+        _command(
+            "daemon",
+            action,
+            target=family,
+            notes=(
+                CANONICAL_RUNTIME_NOTE,
+                "Daemon lifecycle behavior is implemented by the Python daemon runtime.",
+            ),
+        )
+        for family in _FAMILIES
+        for action in ("start", "stop", "status", "logs", "restart")
+    )
+
+
 def _diagnostic_commands() -> tuple[RuntimeCommand, ...]:
     return tuple(
         _command(
             "diagnostics",
             action,
-            notes=(CANONICAL_RUNTIME_NOTE, "Diagnostic commands are implemented in the Python runtime."),
+            notes=(CANONICAL_RUNTIME_NOTE, "Diagnostic behavior is implemented in the Python runtime."),
         )
-        for action in ("paths", "entrypoints", "version")
+        for action in ("paths", "entrypoints", "version", "ai-cli")
     )
 
 
 COMMAND_REGISTRY: tuple[RuntimeCommand, ...] = (
-    *_pipeline_commands(),
+    *_run_commands(),
+    *_status_commands(),
     *_reset_commands(),
     *_daemon_commands(),
-    *_status_commands(),
     *_diagnostic_commands(),
+    _command(
+        "helper",
+        "run",
+        notes=(CANONICAL_RUNTIME_NOTE, "Low-level helper behavior is implemented by runtime_helper.py."),
+    ),
 )
 
 
 def list_runtime_commands() -> tuple[RuntimeCommand, ...]:
-    """Return the unified CLI command inventory."""
+    """Return the public executing/diagnostic command inventory."""
     return COMMAND_REGISTRY
 
 
@@ -199,23 +190,6 @@ def find_runtime_command(group: str, action: str, target: str | None = None) ->
     raise KeyError(f"Unknown runtime command: group={group}{target_text} action={action}")
 
 
-def describe_command(command: RuntimeCommand, paths: RuntimePaths | None = None) -> CommandResult:
-    """Describe a Python runtime command contract without running behavior."""
-    _ = paths or resolve_runtime_paths()
-    details = [
-        f"command: {command.group} {command.target or ''} {command.action}".replace("  ", " ").strip(),
-        f"runtime status: {command.transition_status}",
-        f"current entrypoint: {command.current_entrypoint or PYTHON_CLI}",
-    ]
-    details.extend(f"note: {note}" for note in command.notes)
-    return CommandResult(
-        exit_code=0,
-        title="Python runtime command contract",
-        message="This command is available in the canonical PrizmKit Python runtime.",
-        details=tuple(details),
-    )
-
-
 def handle_runtime_command(
     group: str,
     action: str,
@@ -224,33 +198,60 @@ def handle_runtime_command(
     paths: RuntimePaths | None = None,
     legacy_args: tuple[str, ...] = (),
 ) -> CommandResult:
-    """Handle runtime commands, dispatching ported Python runtime behavior where available."""
+    """Dispatch one registered public runtime command to real behavior."""
+    find_runtime_command(group, action, target)
     runtime_paths = paths or resolve_runtime_paths()
-    if group in {"feature", "bugfix", "refactor"} and action in {"run", "status", "unskip", "test-cli"}:
+
+    if group == "run" and target in _FAMILIES and action == "run":
         from .runners import run_pipeline_command
 
-        return run_pipeline_command(group, action, legacy_args, runtime_paths)
-    if group == "status" and target in {"feature", "bugfix", "refactor"} and action == "status":
+        return run_pipeline_command(target, "run", legacy_args, runtime_paths)
+    if group == "status" and target in _FAMILIES and action == "status":
         from .runners import run_pipeline_command
 
-        return run_pipeline_command(target, action, legacy_args, runtime_paths)
-    if group == "recovery" and action in {"run", "detect"}:
-        from .runners import run_recovery_command
+        return run_pipeline_command(target, "status", legacy_args, runtime_paths)
+    if group == "status" and target == "all" and action == "status":
+        if legacy_args:
+            return CommandResult(
+                2,
+                "Python aggregate status",
+                "status all does not accept a plan path or family-specific arguments",
+            )
+        from .runners import run_pipeline_command
+        from .status import aggregate_family_status
 
-        return run_recovery_command(action, legacy_args, runtime_paths)
-    if group == "reset" and target in {"feature", "bugfix", "refactor"} and action == "reset":
+        aggregate = aggregate_family_status(
+            runtime_paths,
+            lambda family: run_pipeline_command(family, "status", (), runtime_paths),
+        )
+        return CommandResult(
+            aggregate.exit_code,
+            "Python aggregate status",
+            "Read-only status for all pipeline families.",
+            stdout=aggregate.output,
+        )
+    if group == "reset" and target in _FAMILIES and action == "reset":
         from .reset import run_reset_command
 
         return run_reset_command(target, legacy_args, runtime_paths)
-    if group == "daemon" and target in {"feature", "bugfix", "refactor"} and action in {"start", "stop", "status", "logs", "restart", "describe"}:
+    if group == "daemon" and target in _FAMILIES and action in {"start", "stop", "status", "logs", "restart"}:
         from .daemon import run_daemon_command
 
         try:
             return run_daemon_command(target, action, legacy_args, runtime_paths)
         except ValueError as exc:
             return CommandResult(1, f"Python {target} daemon", str(exc), stdout="", stderr=str(exc))
-    command = find_runtime_command(group, action, target)
-    return describe_command(command, runtime_paths)
+    if group == "helper" and action == "run" and target is None:
+        from .runtime_helper import render_result, run_helper_command
+
+        helper_result = run_helper_command(legacy_args)
+        return CommandResult(
+            helper_result.exit_code,
+            "Python runtime helper",
+            "Cross-platform prompt runtime helper result.",
+            stdout=render_result(helper_result, json_output="--json" in legacy_args),
+        )
+    raise RuntimeError(f"Registered command has no handler: {group} {target or ''} {action}".strip())
 
 
 def diagnostics_paths(paths: RuntimePaths | None = None) -> CommandResult:
@@ -275,20 +276,27 @@ def diagnostics_paths(paths: RuntimePaths | None = None) -> CommandResult:
 
 
 def diagnostics_entrypoints(paths: RuntimePaths | None = None) -> CommandResult:
-    """Return an inventory of canonical Python runtime and utility entrypoints."""
+    """Return canonical runtime, command, and utility entrypoints."""
     runtime_paths = paths or resolve_runtime_paths()
     details: list[str] = [
         f"runtime:cli: {runtime_paths.pipeline_root / 'cli.py'}",
         f"runtime:module: {runtime_paths.pipeline_root / 'prizmkit_runtime'}",
         f"runtime:helper-module: {runtime_paths.pipeline_root / 'prizmkit_runtime' / 'runtime_helper.py'}",
     ]
+    details.extend(
+        f"command:{command.group}:{command.target or command.action}: {command.current_entrypoint}"
+        for command in COMMAND_REGISTRY
+    )
     for name, relative_path in sorted(UTILITY_ENTRYPOINTS.items()):
         invocation = describe_existing_entrypoint("utility", name, paths=runtime_paths)
-        details.append(f"utility:{name}: {invocation.script_path if invocation else runtime_paths.pipeline_root / relative_path}")
+        details.append(
+            f"utility:{name}: "
+            f"{invocation.script_path if invocation else runtime_paths.pipeline_root / relative_path}"
+        )
     return CommandResult(
         exit_code=0,
         title="Python runtime entrypoint inventory",
-        message="Inventory for canonical Python runtime and utility scripts.",
+        message="Inventory for canonical Python runtime commands and utility scripts.",
         details=tuple(details),
     )
 
@@ -303,12 +311,39 @@ def diagnostics_version() -> CommandResult:
     )
 
 
+def diagnostics_ai_cli(paths: RuntimePaths | None = None) -> CommandResult:
+    """Report the family-neutral AI CLI resolution used by runtime commands."""
+    from .config import load_runtime_config
+
+    runtime_paths = paths or resolve_runtime_paths()
+    config = load_runtime_config(runtime_paths)
+    cli = config.ai_client.command or "(not found)"
+    details = [
+        f"detected_cli: {cli}",
+        f"platform: {config.ai_client.platform or 'unresolved'}",
+        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,
+        "Python runtime AI CLI diagnostics",
+        "AI CLI resolution for the canonical Python runtime.",
+        tuple(details),
+    )
+
+
 def handle_diagnostics(action: str, paths: RuntimePaths | None = None) -> CommandResult:
-    """Dispatch diagnostics actions."""
+    """Dispatch one registered diagnostics action."""
+    find_runtime_command("diagnostics", action)
     if action == "paths":
         return diagnostics_paths(paths)
     if action == "entrypoints":
         return diagnostics_entrypoints(paths)
     if action == "version":
         return diagnostics_version()
-    raise KeyError(f"Unknown diagnostics action: {action}")
+    if action == "ai-cli":
+        return diagnostics_ai_cli(paths)
+    raise RuntimeError(f"Registered diagnostics action has no handler: {action}")

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

@@ -70,7 +70,7 @@ ID_KEY_BY_KIND = {
 
 PROGRESS_COUNTS_BY_KIND = {
     "feature": ("completed", "in_progress", "failed", "pending", "skipped", "auto_skipped"),
-    "bugfix": ("completed", "in_progress", "failed", "pending", "needs_info", "skipped"),
+    "bugfix": ("completed", "in_progress", "failed", "pending", "needs_info", "skipped", "auto_skipped"),
     "refactor": ("completed", "in_progress", "failed", "pending", "skipped", "auto_skipped"),
 }
 
@@ -79,8 +79,6 @@ def run_daemon_command(kind: str, action: str, legacy_args: tuple[str, ...], pat
     """Run a daemon lifecycle command for feature, bugfix, or refactor."""
     family = family_for(kind, paths)
     daemon_paths = _daemon_paths(family)
-    if action == "describe":
-        return CommandResult(0, f"Python {kind} daemon", _help_text(family))
     if action == "start":
         return _start(family, daemon_paths, legacy_args, paths)
     if action == "status":
@@ -251,7 +249,7 @@ def _parse_start_args(family: RunnerFamily, legacy_args: tuple[str, ...]) -> Dae
     index = 0
     while index < len(legacy_args):
         arg = legacy_args[index]
-        if arg in {"--help", "-h", "help"}:
+        if arg in {"--help", "-h"}:
             help_requested = True
         elif arg == "--env" and index + 1 < len(legacy_args):
             index += 1
@@ -300,8 +298,8 @@ def _payload_command(family: RunnerFamily, paths, list_path: Path, options: Daem
         str(paths.project_root),
         "--pipeline-root",
         str(paths.pipeline_root),
-        family.kind,
         "run",
+        family.kind,
         str(list_path),
     ]
     if family.kind == "feature" and options.features_filter:

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

@@ -16,7 +16,6 @@ UTILITY_ENTRYPOINTS = {
     "detect-stuck": "scripts/detect-stuck.py",
     "generate-bootstrap-prompt": "scripts/generate-bootstrap-prompt.py",
     "generate-bugfix-prompt": "scripts/generate-bugfix-prompt.py",
-    "generate-recovery-prompt": "scripts/generate-recovery-prompt.py",
     "generate-refactor-prompt": "scripts/generate-refactor-prompt.py",
     "init-bugfix-pipeline": "scripts/init-bugfix-pipeline.py",
     "init-change-artifact": "scripts/init-change-artifact.py",

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

@@ -23,7 +23,6 @@ class RuntimePaths:
     feature_state_dir: Path
     bugfix_state_dir: Path
     refactor_state_dir: Path
-    recovery_state_dir: Path
     layout: str
 
     def path_values(self) -> tuple[Path, ...]:
@@ -42,7 +41,6 @@ class RuntimePaths:
             self.feature_state_dir,
             self.bugfix_state_dir,
             self.refactor_state_dir,
-            self.recovery_state_dir,
         )
 
 
@@ -105,6 +103,5 @@ def resolve_runtime_paths(
         feature_state_dir=state_dir / "features",
         bugfix_state_dir=state_dir / "bugfix",
         refactor_state_dir=state_dir / "refactor",
-        recovery_state_dir=state_dir / "recovery",
         layout=layout,
     )