prizmkit 1.1.153 → 1.1.155

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

@@ -37,7 +37,6 @@ class DaemonStartOptions:
 
     list_path: Path
     env_overrides: str = ""
-    mode: str = ""
     features_filter: str = ""
     help_requested: bool = False
 
@@ -70,7 +69,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 +78,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":
@@ -244,23 +241,17 @@ def _logs(family: RunnerFamily, daemon_paths: DaemonPaths, legacy_args: tuple[st
 def _parse_start_args(family: RunnerFamily, legacy_args: tuple[str, ...]) -> DaemonStartOptions:
     list_path = family.plan_path
     env_overrides = ""
-    mode = ""
     features_filter = ""
     help_requested = False
     positional: list[str] = []
     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
             env_overrides = legacy_args[index]
-        elif arg == "--mode" and index + 1 < len(legacy_args):
-            index += 1
-            mode = legacy_args[index]
-            if mode not in {"lite", "standard", "full"}:
-                raise ValueError(f"Invalid mode: {mode} (must be lite, standard, or full)")
         elif arg == "--features" and index + 1 < len(legacy_args):
             index += 1
             features_filter = legacy_args[index]
@@ -271,7 +262,7 @@ def _parse_start_args(family: RunnerFamily, legacy_args: tuple[str, ...]) -> Dae
         index += 1
     if positional:
         list_path = Path(positional[0]).expanduser()
-    return DaemonStartOptions(list_path=list_path, env_overrides=env_overrides, mode=mode, features_filter=features_filter, help_requested=help_requested)
+    return DaemonStartOptions(list_path=list_path, env_overrides=env_overrides, features_filter=features_filter, help_requested=help_requested)
 
 
 def _parse_log_args(legacy_args: tuple[str, ...]) -> DaemonLogOptions:
@@ -300,14 +291,12 @@ 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:
         command.extend(["--features", options.features_filter])
-    if options.mode:
-        command.extend(["--mode", options.mode])
     return command
 
 
@@ -318,8 +307,6 @@ def _daemon_env(options: DaemonStartOptions) -> dict[str, str]:
             key, value = token.split("=", 1)
             if key:
                 env[key] = value
-    if options.mode:
-        env["PIPELINE_MODE"] = options.mode
     return env
 
 
@@ -350,7 +337,6 @@ def _write_meta(family: RunnerFamily, path: Path, pid: int, started_at: str, lis
         "started_at": started_at,
         LIST_META_KEY_BY_KIND[family.kind]: str(list_path),
         "env_overrides": options.env_overrides,
-        "mode": options.mode,
         "log_file": str(log_file),
     }
     tmp = path.with_suffix(path.suffix + ".tmp")
@@ -407,8 +393,6 @@ def _write_log_separator(family: RunnerFamily, log_file: Path, list_path: Path,
     ]
     if options.features_filter:
         lines.append(f"  Features filter: {options.features_filter}")
-    if options.mode:
-        lines.append(f"  Mode: {options.mode}")
     if options.env_overrides:
         lines.append(f"  Environment: {options.env_overrides}")
     lines.extend(["================================================================", ""])

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

@@ -442,7 +442,7 @@ def ensure_linked_worktree(runtime: WorktreeRuntimeContext) -> WorktreeOperation
 
 
 def merge_linked_worktree(runtime: WorktreeRuntimeContext, *, auto_push: bool = False) -> WorktreeOperationResult:
-    """Rebase a clean linked-worktree branch and fast-forward merge it into base."""
+    """Fast-forward a committed linked-worktree branch, rebasing only when needed."""
     results: list[GitCommandResult] = []
     clean = run_git_command(
         runtime.worktree_path,
@@ -459,11 +459,12 @@ def merge_linked_worktree(runtime: WorktreeRuntimeContext, *, auto_push: bool =
     if clean.return_code != 0:
         return WorktreeOperationResult(False, "dirty_task_checkout", runtime, tuple(results))
 
-    rebase = run_git_command(runtime.worktree_path, ("rebase", runtime.context.base_branch))
-    results.append(rebase)
-    if rebase.return_code != 0:
-        results.append(run_git_command(runtime.worktree_path, ("rebase", "--abort")))
-        return WorktreeOperationResult(False, "merge_conflict", runtime, tuple(results))
+    if not branch_fast_forward_possible(runtime.context.project_root, runtime.context):
+        rebase = run_git_command(runtime.worktree_path, ("rebase", runtime.context.base_branch))
+        results.append(rebase)
+        if rebase.return_code != 0:
+            results.append(run_git_command(runtime.worktree_path, ("rebase", "--abort")))
+            return WorktreeOperationResult(False, "merge_conflict", runtime, tuple(results))
 
     checkout = run_git_command(runtime.context.project_root, ("checkout", runtime.context.base_branch))
     results.append(checkout)
@@ -581,14 +582,47 @@ def branch_return_plan(context: BranchContext) -> GitCommandPlan:
     )
 
 
-def branch_merge_plan(context: BranchContext, *, auto_push: bool = False) -> GitCommandPlan:
-    """Plan a merge that consumes only a clean, committed task branch."""
+def branch_fast_forward_possible(project_root: Path, context: BranchContext) -> bool:
+    """Return whether the base branch is an ancestor of the committed task branch."""
+    return run_git_command(
+        project_root,
+        ("merge-base", "--is-ancestor", context.base_branch, context.working_branch),
+    ).return_code == 0
+
+
+def branch_merge_plan(
+    context: BranchContext,
+    *,
+    auto_push: bool = False,
+    rebase: bool = True,
+) -> GitCommandPlan:
+    """Plan a merge that consumes only task-visible committed branch state."""
     commands = [
-        _git("status", "--porcelain", "--untracked-files=normal", description="require a clean task checkout"),
-        _git("rebase", context.base_branch, context.working_branch, description="rebase dev onto original"),
-        _git("checkout", context.base_branch, description="checkout original for fast-forward"),
-        _git("merge", "--ff-only", context.working_branch, description="fast-forward original"),
+        _git(
+            "status",
+            "--porcelain",
+            "--untracked-files=normal",
+            "--",
+            ".",
+            *HIDDEN_TOOL_WORKTREE_EXCLUDES,
+            description="require a clean task checkout",
+        ),
     ]
+    if rebase:
+        commands.append(
+            _git(
+                "rebase",
+                context.base_branch,
+                context.working_branch,
+                description="rebase dev onto original",
+            )
+        )
+    commands.extend(
+        [
+            _git("checkout", context.base_branch, description="checkout original for fast-forward"),
+            _git("merge", "--ff-only", context.working_branch, description="fast-forward original"),
+        ]
+    )
     if auto_push:
         commands.append(_git("push", allow_failure=True, description="optional auto-push"))
     commands.append(_git("branch", "-d", context.working_branch, allow_failure=True, description="delete merged dev branch"))
@@ -596,8 +630,8 @@ def branch_merge_plan(context: BranchContext, *, auto_push: bool = False) -> Git
         name="branch_merge",
         commands=tuple(commands),
         notes=(
-            "The task checkout must be clean because committed branch state is the only merge input.",
-            "Rebase then fast-forward preserves merge history without pipeline-owned stashes.",
+            "Task-visible checkout state must be clean; recognized internal/support dirt remains outside merge input.",
+            "Rebase only when base ancestry requires it, then fast-forward without pipeline-owned stashes.",
         ),
     )
 

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,
     )