prizmkit 1.1.106 → 1.1.108

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

@@ -29,10 +29,11 @@ from .gitops import (
 from .runner_bookkeeping import (
     commit_final_bookkeeping,
     commit_pre_branch_bookkeeping,
+    commit_preflight_ready_changes,
     commit_task_branch_changes,
     commit_wip_changes,
 )
-from .runner_classification import classify_session
+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
@@ -111,6 +112,14 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
             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):
+                return PipelineRunResult(
+                    False,
+                    processed,
+                    "pipeline_complete_with_non_terminal_history",
+                    _last_detail_status(details),
+                    tuple(details),
+                )
             return PipelineRunResult(True, processed, "pipeline_complete", details=tuple(details))
         if marker == "PIPELINE_BLOCKED":
             return PipelineRunResult(False, processed, "pipeline_blocked", details=tuple(details))
@@ -138,6 +147,37 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
             return PipelineRunResult(False, processed, "item_failed", final_status, tuple(details))
 
 
+_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 _detail_status(detail: str) -> str:
+    return detail.rsplit(":", 1)[-1] if ":" in detail else detail
+
+
+def _last_detail_status(details: list[str]) -> str:
+    if not details:
+        return ""
+    return _detail_status(details[-1])
+
+
+def _has_non_terminal_details(details: list[str]) -> bool:
+    return any(_detail_status(detail) in _NON_TERMINAL_DETAIL_STATUSES for detail in details)
+
+
 _SEPARATOR = "─" * 52
 
 
@@ -190,6 +230,34 @@ def _is_current_task_branch(branch: str, family: RunnerFamily, item_id: str) ->
     return branch == f"{family.branch_prefix}/{item_id}" or branch.startswith(f"{family.branch_prefix}/{item_id}-")
 
 
+def _with_recovery_metadata(family: RunnerFamily, item_id: str, metadata: dict[str, object]) -> dict[str, object]:
+    enriched = dict(metadata)
+    if enriched.get("active_dev_branch") and enriched.get("base_branch"):
+        return enriched
+    recovered = _latest_session_status(family.state_dir, item_id)
+    for key in ("active_dev_branch", "base_branch"):
+        if not enriched.get(key) and recovered.get(key):
+            enriched[key] = recovered[key]
+    return enriched
+
+
+def _latest_session_status(state_dir: Path, item_id: str) -> dict[str, object]:
+    sessions_dir = state_dir / item_id / "sessions"
+    try:
+        sessions = sorted(child for child in sessions_dir.iterdir() if child.is_dir())
+    except OSError:
+        return {}
+    for session in reversed(sessions):
+        status_path = session / "session-status.json"
+        try:
+            data = json.loads(status_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        if isinstance(data, dict):
+            return data
+    return {}
+
+
 def _resolve_base_branch(project_root: Path, metadata: dict[str, object], active_branch: str, family: RunnerFamily, item_id: str) -> str:
     recorded = str(metadata.get("base_branch") or "").strip()
     if recorded:
@@ -313,14 +381,29 @@ def _process_item(
         raise RuntimeError("No supported AI CLI command was found")
 
     active_branch = current_branch(paths.project_root)
-    base_branch = _resolve_base_branch(paths.project_root, initial_metadata, active_branch, family, item_id)
-    branch_name = _resolve_working_branch(family, item_id, initial_metadata, env, active_branch)
+    metadata = _with_recovery_metadata(family, item_id, initial_metadata)
+    base_branch = _resolve_base_branch(paths.project_root, metadata, active_branch, family, item_id)
+    branch_name = _resolve_working_branch(family, item_id, metadata, env, active_branch)
     branch_context = BranchContext(base_branch, branch_name, paths.project_root)
     worktree_runtime = None
     use_worktree = _use_worktree_for_family(env, family)
     execution_root = paths.project_root
 
     try:
+        preflight = commit_preflight_ready_changes(paths.project_root, item_id)
+        if preflight.committed:
+            _emit_info(f"Preflight: preserved existing user-visible changes before {family.kind} task {item_id}")
+        elif preflight.attempted:
+            detail = ""
+            if preflight.result is not None:
+                detail = (preflight.result.stderr or preflight.result.stdout).strip()
+            _emit_warning(f"Preflight: failed to preserve existing changes before {family.kind} task {item_id}")
+            if detail:
+                _emit_warning(detail.splitlines()[0][:500])
+            raise RuntimeError(f"Preflight dirty workspace preservation failed before {family.kind} task {item_id}")
+        else:
+            _emit_info(f"Preflight: no user-visible changes to preserve before {family.kind} task {item_id}")
+
         if use_worktree:
             worktree_runtime = worktree_runtime_context(
                 branch_context,
@@ -356,21 +439,51 @@ def _process_item(
             if not branch_result.ok:
                 return "infra_error"
 
-        _emit_item_header(family, invocation, item_id, initial_metadata)
+        _emit_item_header(family, invocation, item_id, metadata)
         status_root = execution_root if use_worktree else paths.project_root
         status_family = _family_for_execution_root(family, paths.project_root, status_root)
         status_invocation = _invocation_for_execution_family(invocation, status_family)
+        recovered_session_id = _latest_session_id(family.state_dir, item_id)
+        recovery_artifact = _artifact_path_for_item(execution_root, family, item_id, metadata)
+        if recovered_session_id and has_completed_artifact_path(recovery_artifact) and has_branch_completion_evidence(execution_root, base_branch, branch_name, recovery_artifact):
+            session_paths = SessionPaths.for_item(family.state_dir, item_id, recovered_session_id)
+            _write_session_status(
+                session_paths,
+                status="success",
+                session_id=recovered_session_id,
+                task_id=item_id,
+                task_type=family.task_type,
+                base_branch=base_branch,
+                active_dev_branch=branch_name,
+                worktree_path=worktree_runtime.worktree_path if worktree_runtime is not None else None,
+                reason="completed_branch_recovered_from_late_runtime_error",
+            )
+            return _finalize_recovered_success(
+                family,
+                item_id,
+                paths,
+                status_family,
+                status_invocation,
+                status_root,
+                execution_root,
+                branch_context,
+                branch_name,
+                base_branch,
+                recovered_session_id,
+                session_paths,
+                worktree_runtime,
+            )
         start = start_item(status_family, status_invocation, item_id, status_root)
         if not start.ok:
             raise RuntimeError(start.text)
         commit_pre_branch_bookkeeping(status_root, status_family, item_id)
 
-        previous_fingerprint = initial_metadata.get("last_progress_fingerprint")
-        previous_no_progress_count = int(initial_metadata.get("no_progress_count") or 0)
-        continuation_pending = bool(initial_metadata.get("continuation_pending"))
-        previous_session_id = str(initial_metadata.get("previous_session_id") or initial_metadata.get("last_context_overflow_session_id") or "")
-        continuation_count = int(initial_metadata.get("continuation_count") or 0)
-        context_overflow_count = int(initial_metadata.get("context_overflow_count") or 0)
+        previous_fingerprint = metadata.get("last_progress_fingerprint")
+        previous_no_progress_count = int(metadata.get("no_progress_count") or 0)
+        continuation_pending = bool(metadata.get("continuation_pending"))
+        previous_session_id = str(metadata.get("previous_session_id") or metadata.get("last_context_overflow_session_id") or "")
+        continuation_count = int(metadata.get("continuation_count") or 0)
+        context_overflow_count = int(metadata.get("context_overflow_count") or 0)
 
         while True:
             session_id = _session_id(item_id)
@@ -401,7 +514,9 @@ def _process_item(
             if invocation.dry_run:
                 return "dry_run"
             _emit_prompt_summary(prompt, session_id)
-            stream_json = detect_stream_json_support(config.ai_client.command, config.ai_client.platform).enabled
+            stream_json = False
+            if getattr(config.ai_client, "launch_profile", None) is None:
+                stream_json = detect_stream_json_support(config.ai_client.command, config.ai_client.platform).enabled
             base_head = run_git_command(execution_root, ("rev-parse", "HEAD")).stdout.strip()
             session_result = AISessionLauncher(
                 AISessionConfig(
@@ -417,7 +532,9 @@ def _process_item(
                     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,
@@ -500,62 +617,23 @@ def _process_item(
                     branch_ensure_return(paths.project_root, base_branch, branch_name)
                 return new_status
 
-            commit_final_bookkeeping(status_root, status_family, item_id, new_status)
-            commit_task_branch_changes(execution_root, family, item_id, new_status)
-            if use_worktree and worktree_runtime is not None:
-                _emit_info(f"Merging {branch_name} into {base_branch}...")
-                merge = merge_linked_worktree(worktree_runtime, auto_push=env.auto_push)
-                _emit_git_plan_output(merge)
-                if merge.ok:
-                    guarded_worktree_remove(worktree_runtime, delete_branch=True)
-                    _emit_success(f"Merged {branch_name} into {base_branch}")
-                    return new_status
-                final_session_status = "merge_conflict"
-            else:
-                _emit_info(f"Merging {branch_name} into {base_branch}...")
-                merge = run_git_plan(paths.project_root, branch_merge_plan(branch_context, auto_push=env.auto_push))
-                _emit_git_plan_output(merge)
-                if merge.ok:
-                    _emit_success(f"Merged {branch_name} into {base_branch}")
-                    return new_status
-                final_session_status = "merge_conflict"
-
-            _write_session_status(
-                session_paths,
-                status=final_session_status,
-                session_id=session_id,
-                task_id=item_id,
-                task_type=family.task_type,
-                base_branch=base_branch,
-                active_dev_branch=branch_name,
-                worktree_path=worktree_runtime.worktree_path if worktree_runtime is not None else None,
-                reason="merge_conflict",
-                fatal_error_code=classification.fatal_error_code,
-            )
-            update = update_item(
+            return _complete_success_merge(
+                family,
+                item_id,
+                new_status,
+                paths,
                 status_family,
                 status_invocation,
-                item_id,
-                final_session_status,
-                session_id,
                 status_root,
-                active_dev_branch=branch_name,
-                base_branch=base_branch,
-                last_fatal_error_code=classification.fatal_error_code,
-                no_progress_count=classification.no_progress_count,
-                progress_fingerprint=classification.progress_fingerprint,
+                execution_root,
+                branch_context,
+                branch_name,
+                base_branch,
+                session_id,
+                session_paths,
+                worktree_runtime,
+                classification_fatal_error_code=classification.fatal_error_code,
             )
-            if not update.ok:
-                raise RuntimeError(update.text)
-            _emit_update_summary(family, item_id, update)
-            new_status = _status_from_update(update)
-            commit_final_bookkeeping(status_root, status_family, item_id, new_status)
-            _save_failure_wip(execution_root, family, item_id, new_status, worktree_runtime)
-            if use_worktree and worktree_runtime is not None:
-                guarded_worktree_remove(worktree_runtime, delete_branch=False)
-            else:
-                branch_ensure_return(paths.project_root, base_branch, branch_name)
-            return new_status
     except KeyboardInterrupt:
         _emit_warning(f"Interrupted while processing {item_id}; preserving work and returning to {base_branch}")
         if use_worktree and worktree_runtime is not None:
@@ -566,6 +644,126 @@ def _process_item(
         raise
 
 
+def _finalize_recovered_success(
+    family: RunnerFamily,
+    item_id: str,
+    paths,
+    status_family: RunnerFamily,
+    status_invocation: RunnerInvocation,
+    status_root: Path,
+    execution_root: Path,
+    branch_context: BranchContext,
+    branch_name: str,
+    base_branch: str,
+    session_id: str,
+    session_paths: SessionPaths,
+    worktree_runtime,
+) -> str:
+    update = update_item(
+        status_family,
+        status_invocation,
+        item_id,
+        "success",
+        session_id,
+        status_root,
+        active_dev_branch=branch_name,
+        base_branch=base_branch,
+    )
+    if not update.ok:
+        raise RuntimeError(update.text)
+    _emit_update_summary(family, item_id, update)
+    return _complete_success_merge(
+        family,
+        item_id,
+        _status_from_update(update),
+        paths,
+        status_family,
+        status_invocation,
+        status_root,
+        execution_root,
+        branch_context,
+        branch_name,
+        base_branch,
+        session_id,
+        session_paths,
+        worktree_runtime,
+        classification_fatal_error_code="",
+    )
+
+
+def _complete_success_merge(
+    family: RunnerFamily,
+    item_id: str,
+    new_status: str,
+    paths,
+    status_family: RunnerFamily,
+    status_invocation: RunnerInvocation,
+    status_root: Path,
+    execution_root: Path,
+    branch_context: BranchContext,
+    branch_name: str,
+    base_branch: str,
+    session_id: str,
+    session_paths: SessionPaths,
+    worktree_runtime,
+    *,
+    classification_fatal_error_code: str = "",
+) -> str:
+    env = RunnerEnvironment.from_env()
+    commit_final_bookkeeping(status_root, status_family, item_id, new_status)
+    commit_task_branch_changes(execution_root, family, item_id, new_status)
+    if worktree_runtime is not None:
+        _emit_info(f"Merging {branch_name} into {base_branch}...")
+        merge = merge_linked_worktree(worktree_runtime, auto_push=env.auto_push)
+        _emit_git_plan_output(merge)
+        if merge.ok:
+            guarded_worktree_remove(worktree_runtime, delete_branch=True)
+            _emit_success(f"Merged {branch_name} into {base_branch}")
+            return new_status
+    else:
+        _emit_info(f"Merging {branch_name} into {base_branch}...")
+        merge = run_git_plan(paths.project_root, branch_merge_plan(branch_context, auto_push=env.auto_push))
+        _emit_git_plan_output(merge)
+        if merge.ok:
+            _emit_success(f"Merged {branch_name} into {base_branch}")
+            return new_status
+
+    _write_session_status(
+        session_paths,
+        status="merge_conflict",
+        session_id=session_id,
+        task_id=item_id,
+        task_type=family.task_type,
+        base_branch=base_branch,
+        active_dev_branch=branch_name,
+        worktree_path=worktree_runtime.worktree_path if worktree_runtime is not None else None,
+        reason="merge_conflict",
+        fatal_error_code=classification_fatal_error_code,
+    )
+    update = update_item(
+        status_family,
+        status_invocation,
+        item_id,
+        "merge_conflict",
+        session_id,
+        status_root,
+        active_dev_branch=branch_name,
+        base_branch=base_branch,
+        last_fatal_error_code=classification_fatal_error_code,
+    )
+    if not update.ok:
+        raise RuntimeError(update.text)
+    _emit_update_summary(family, item_id, update)
+    merged_status = _status_from_update(update)
+    commit_final_bookkeeping(status_root, status_family, item_id, merged_status)
+    _save_failure_wip(execution_root, family, item_id, merged_status, worktree_runtime)
+    if worktree_runtime is not None:
+        guarded_worktree_remove(worktree_runtime, delete_branch=False)
+    else:
+        branch_ensure_return(paths.project_root, base_branch, branch_name)
+    return merged_status
+
+
 def _save_failure_wip(execution_root: Path, family: RunnerFamily, item_id: str, status: str, worktree_runtime) -> None:
     if worktree_runtime is not None:
         worktree_save_wip(worktree_runtime)
@@ -684,6 +882,43 @@ def _path_in_execution_root(path: Path, project_root: Path, execution_root: Path
         return path
 
 
+def _latest_session_id(state_dir: Path, item_id: str) -> str:
+    sessions_dir = state_dir / item_id / "sessions"
+    try:
+        sessions = [child.name for child in sessions_dir.iterdir() if child.is_dir()]
+    except OSError:
+        return ""
+    return sorted(sessions)[-1] if sessions else ""
+
+
+def _artifact_path_for_item(project_root: Path, family: RunnerFamily, item_id: str, metadata: dict[str, object]) -> Path:
+    if family.kind == "feature":
+        title = str(metadata.get("title") or "")
+        if title:
+            return project_root / ".prizmkit" / "specs" / _feature_slug(item_id, title)
+        specs = project_root / ".prizmkit" / "specs"
+        numeric = item_id.replace("F-", "").replace("f-", "").zfill(3)
+        try:
+            matches = sorted(path for path in specs.iterdir() if path.is_dir() and path.name.startswith(f"{numeric}-"))
+        except OSError:
+            matches = []
+        if matches:
+            return matches[0]
+    return project_root / ".prizmkit" / family.artifact_root_name / item_id
+
+
+def _feature_slug(feature_id: str, title: str) -> str:
+    import re
+
+    numeric = feature_id.replace("F-", "").replace("f-", "").zfill(3)
+    cleaned = re.sub(r"[^a-z0-9\s-]", "", title.lower())
+    cleaned = re.sub(r"[\s]+", "-", cleaned.strip())
+    cleaned = re.sub(r"-+", "-", cleaned).strip("-")
+    if not cleaned:
+        cleaned = "feature"
+    return f"{numeric}-{cleaned}"
+
+
 def _write_session_status(
     session_paths: SessionPaths,
     *,