prizmkit 1.1.152 → 1.1.154

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

@@ -1,228 +0,0 @@
-"""Recovery detection and execution for Python foreground runner commands."""
-
-from __future__ import annotations
-
-import json
-import subprocess
-import sys
-import time
-from dataclasses import dataclass
-from pathlib import Path
-
-from .checkpoint_state import load_checkpoint_state
-from .config import load_runtime_config
-from .paths import RuntimePaths
-from .runner_models import RunnerEnvironment, SessionPaths
-from .sessions import AISessionConfig, AISessionLauncher, detect_stream_json_support
-
-
-@dataclass(frozen=True)
-class RecoveryDetectorResolver:
-    """Resolve recovery detector sources without coupling to one platform copy."""
-
-    paths: RuntimePaths
-
-    def candidates(self) -> tuple[Path, ...]:
-        project = self.paths.project_root
-        return (
-            project / ".agents" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
-            project / ".claude" / "command-assets" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
-            project / ".codebuddy" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
-            project / ".pi" / "skills" / "recovery-workflow" / "scripts" / "detect-recovery-state.py",
-            project
-            / "core"
-            / "skills"
-            / "orchestration-skill"
-            / "workflows"
-            / "recovery-workflow"
-            / "scripts"
-            / "detect-recovery-state.py",
-        )
-
-    def resolve(self) -> Path:
-        for candidate in self.candidates():
-            if candidate.is_file():
-                return candidate
-        raise FileNotFoundError("recovery detector script not found")
-
-
-def run_recovery_detect(paths: RuntimePaths) -> tuple[int, str, str, dict[str, object] | None]:
-    """Run recovery state detection and parse the JSON report."""
-    detector = RecoveryDetectorResolver(paths).resolve()
-    completed = subprocess.run(
-        [sys.executable, str(detector), "--project-root", str(paths.project_root)],
-        cwd=str(paths.project_root),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        check=False,
-    )
-    data = None
-    if completed.stdout.strip():
-        try:
-            data = json.loads(completed.stdout)
-        except json.JSONDecodeError:
-            data = None
-    return completed.returncode, completed.stdout, completed.stderr, data
-
-
-def run_recovery(paths: RuntimePaths, legacy_args: tuple[str, ...] = ()) -> tuple[int, str, str]:
-    """Detect recovery state, render a prompt, launch an AI session, and classify."""
-    dry_run = "--dry-run" in legacy_args
-    model_override = _option_value(legacy_args, "--model")
-    code, stdout, stderr, detection = run_recovery_detect(paths)
-    if code != 0 or not detection:
-        return code or 1, stdout, stderr
-    if not detection.get("detected"):
-        return 0, stdout, stderr
-
-    session_id = "recovery-{}-{}".format(
-        str(detection.get("workflow_type") or "workflow"),
-        time.strftime("%Y%m%d-%H%M%S"),
-    )
-    session_dir = paths.recovery_state_dir / session_id
-    session_paths = SessionPaths(
-        session_dir=session_dir,
-        prompt_path=session_dir / "bootstrap-prompt.md",
-        logs_dir=session_dir / "logs",
-        session_log=session_dir / "logs" / "session.log",
-        progress_json=session_dir / "logs" / "progress.json",
-        heartbeat_json=session_dir / "logs" / "heartbeat.json",
-        session_status_json=session_dir / "session-status.json",
-    )
-    detection_json = session_paths.session_dir / "detection.json"
-    session_paths.session_dir.mkdir(parents=True, exist_ok=True)
-    detection_json.write_text(json.dumps(detection, indent=2, ensure_ascii=False), encoding="utf-8")
-    prompt_output = session_paths.prompt_path
-    generator = paths.pipeline_root / "scripts" / "generate-recovery-prompt.py"
-    prompt_cmd = [
-        sys.executable,
-        str(generator),
-        "--detection-json",
-        str(detection_json),
-        "--output",
-        str(prompt_output),
-        "--project-root",
-        str(paths.project_root),
-        "--session-id",
-        session_id,
-    ]
-    prompt_result = subprocess.run(
-        prompt_cmd,
-        cwd=str(paths.project_root),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        check=False,
-    )
-    if prompt_result.returncode != 0:
-        return prompt_result.returncode, prompt_result.stdout, prompt_result.stderr
-    if dry_run:
-        return 0, prompt_result.stdout, prompt_result.stderr
-
-    config = load_runtime_config(paths)
-    if not config.ai_client.command:
-        return 1, "", "No supported AI CLI command was found for recovery\n"
-    env = RunnerEnvironment.from_env()
-    stream_json = False
-    if env.live_output and getattr(config.ai_client, "launch_profile", None) is None:
-        stream_json = detect_stream_json_support(config.ai_client.command, config.ai_client.platform).enabled
-    launcher = AISessionLauncher(
-        AISessionConfig(
-            cli_command=config.ai_client.command,
-            platform=config.ai_client.platform or "codebuddy",
-            model=model_override or config.model,
-            prompt_path=prompt_output,
-            cwd=paths.project_root,
-            log_path=session_paths.session_log,
-            progress_path=session_paths.progress_json,
-            heartbeat_path=session_paths.heartbeat_json,
-            effort=config.effort,
-            verbose=env.verbose,
-            live_output=env.live_output,
-            use_stream_json=stream_json,
-            launch_profile=getattr(config.ai_client, "launch_profile", None),
-            stale_kill_threshold_seconds=env.stale_kill_threshold_seconds,
-            heartbeat_stale_threshold_seconds=env.heartbeat_stale_threshold_seconds,
-            live_progress_interval_seconds=env.heartbeat_interval_seconds,
-            live_banner=False,
-            suppress_stream_output=True,
-        )
-    )
-    result = launcher.run()
-    checkpoint_path = _recovery_checkpoint_path(paths.project_root, detection)
-    outcome, semantic = _recovery_outcome(
-        paths.project_root,
-        result.exit_code,
-        checkpoint_path=checkpoint_path,
-    )
-    session_paths.session_status_json.write_text(
-        json.dumps(
-            {
-                "session_id": session_id,
-                "outcome": outcome,
-                "checkpoint_path": str(checkpoint_path) if checkpoint_path else None,
-                "checkpoint_state": semantic,
-            },
-            indent=2,
-        )
-        + "\n",
-        encoding="utf-8",
-    )
-    return 0 if outcome in {"success", "no_changes"} else 1, outcome + "\n", ""
-
-
-def _option_value(args: tuple[str, ...], flag: str) -> str | None:
-    for index, arg in enumerate(args):
-        if arg == flag and index + 1 < len(args):
-            return args[index + 1]
-        if arg.startswith(flag + "="):
-            return arg.split("=", 1)[1]
-    return None
-
-
-def _recovery_checkpoint_path(project_root: Path, detection: dict[str, object]) -> Path | None:
-    """Select the L4 checkpoint identified by recovery inspection."""
-    semantic = detection.get("semantic_checkpoint")
-    if isinstance(semantic, dict) and semantic.get("path"):
-        candidate = project_root / str(semantic["path"])
-        if candidate.is_file():
-            return candidate
-    execution_owner = detection.get("execution_owner")
-    checkpoints = execution_owner.get("l4_checkpoints") if isinstance(execution_owner, dict) else []
-    if isinstance(checkpoints, list) and len(checkpoints) == 1:
-        candidate = project_root / str(checkpoints[0])
-        if candidate.is_file():
-            return candidate
-    return None
-
-
-def _recovery_outcome(
-    project_root: Path,
-    exit_code: int | None,
-    *,
-    checkpoint_path: Path | None = None,
-) -> tuple[str, dict[str, object]]:
-    """Classify recovery from semantic L4 state without mutating partial work."""
-    if checkpoint_path is not None:
-        state = load_checkpoint_state(checkpoint_path, project_root=project_root)
-        semantic = state.semantic_snapshot
-        if state.valid and state.semantic_complete:
-            return "success", semantic
-        if state.valid and state.semantic_blocked:
-            return "workflow_blocked", semantic
-        if state.exists and not state.valid:
-            return "blocked_invalid_checkpoint", semantic
-        return "partial" if exit_code == 0 else "failed", semantic
-
-    status = subprocess.run(
-        ["git", "-C", str(project_root), "status", "--porcelain"],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.DEVNULL,
-        text=True,
-        check=False,
-    )
-    has_changes = bool(status.stdout.strip())
-    if exit_code == 0 and not has_changes:
-        return "no_changes", {}
-    return ("partial" if has_changes else "failed"), {}