prizmkit 1.1.105 → 1.1.107

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

@@ -26,8 +26,13 @@ from .gitops import (
     worktree_runtime_context,
     worktree_save_wip,
 )
-from .runner_bookkeeping import commit_final_bookkeeping, commit_pre_branch_bookkeeping
-from .runner_classification import classify_session
+from .runner_bookkeeping import (
+    commit_final_bookkeeping,
+    commit_pre_branch_bookkeeping,
+    commit_task_branch_changes,
+    commit_wip_changes,
+)
+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
@@ -106,6 +111,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))
@@ -133,6 +146,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
 
 
@@ -180,7 +224,37 @@ def _is_recovery_side_effect_branch(branch: str, family: RunnerFamily, item_id:
 
 
 def _is_current_task_branch(branch: str, family: RunnerFamily, item_id: str) -> bool:
-    return bool(branch) and branch.startswith(f"{family.branch_prefix}/{item_id}-") and not _is_recovery_side_effect_branch(branch, family, item_id)
+    if not branch or _is_recovery_side_effect_branch(branch, family, item_id):
+        return False
+    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:
@@ -306,20 +380,15 @@ 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
 
-    _emit_item_header(family, invocation, item_id, initial_metadata)
     try:
-        start = start_item(family, invocation, item_id, paths.project_root)
-        if not start.ok:
-            raise RuntimeError(start.text)
-        commit_pre_branch_bookkeeping(paths.project_root, family, item_id)
-
         if use_worktree:
             worktree_runtime = worktree_runtime_context(
                 branch_context,
@@ -332,29 +401,74 @@ def _process_item(
             )
             setup = ensure_linked_worktree(worktree_runtime)
             if not setup.ok:
-                status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
-                return _status_from_update(status)
+                return "infra_error"
             worktree_runtime = setup.runtime or worktree_runtime
             _emit_info(f"Dev branch: {branch_name}")
             _emit_info(f"Worktree: {worktree_runtime.worktree_path}")
             support_assets = materialize_worktree_support_assets(worktree_runtime)
             if not support_assets.ok:
-                status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
-                return _status_from_update(status)
+                return _record_setup_failure(
+                    family,
+                    invocation,
+                    item_id,
+                    paths.project_root,
+                    worktree_runtime.worktree_path,
+                    base_branch,
+                    branch_name,
+                    worktree_runtime=worktree_runtime,
+                )
             execution_root = worktree_runtime.worktree_path
         else:
             branch_result = run_git_plan(paths.project_root, branch_create_plan(branch_context))
             _emit_branch_setup_result(branch_context, branch_result)
             if not branch_result.ok:
-                status = update_item(family, invocation, item_id, "infra_error", "", paths.project_root)
-                return _status_from_update(status)
+                return "infra_error"
+
+        _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)
@@ -368,7 +482,7 @@ def _process_item(
                     "task_type": family.task_type,
                     "active_dev_branch": branch_name,
                     "base_branch": base_branch,
-                    "continuation_summary_path": _continuation_summary_path(paths.project_root, family, item_id, None),
+                    "continuation_summary_path": _continuation_summary_path(execution_root, family, item_id, None),
                 }
             prompt = generate_prompt(
                 family,
@@ -417,14 +531,14 @@ def _process_item(
             )
             _emit_session_summary(session_result, session_paths, classification)
             if classification.session_status == "context_overflow":
-                summary_path = _continuation_summary_path(paths.project_root, family, item_id, prompt)
+                summary_path = _continuation_summary_path(execution_root, family, item_id, prompt)
                 update = update_item(
-                    family,
-                    invocation,
+                    status_family,
+                    status_invocation,
                     item_id,
                     "context_overflow",
                     session_id,
-                    paths.project_root,
+                    status_root,
                     active_dev_branch=branch_name,
                     base_branch=base_branch,
                     last_fatal_error_code=classification.fatal_error_code or "context_overflow",
@@ -444,32 +558,6 @@ def _process_item(
                 continue
 
             final_session_status = classification.session_status
-            if use_worktree and worktree_runtime is not None:
-                if final_session_status == "success":
-                    _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}")
-                    else:
-                        final_session_status = "merge_conflict"
-                        guarded_worktree_remove(worktree_runtime, delete_branch=False)
-                else:
-                    worktree_save_wip(worktree_runtime)
-                    guarded_worktree_remove(worktree_runtime, delete_branch=False)
-            else:
-                if final_session_status == "success":
-                    _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}")
-                    else:
-                        branch_ensure_return(paths.project_root, base_branch, branch_name)
-                        final_session_status = "merge_conflict"
-                else:
-                    branch_ensure_return(paths.project_root, base_branch, branch_name)
 
             _write_session_status(
                 session_paths,
@@ -485,12 +573,12 @@ def _process_item(
             )
 
             update = update_item(
-                family,
-                invocation,
+                status_family,
+                status_invocation,
                 item_id,
                 final_session_status,
                 session_id,
-                paths.project_root,
+                status_root,
                 active_dev_branch=branch_name,
                 base_branch=base_branch,
                 last_fatal_error_code=classification.fatal_error_code,
@@ -501,8 +589,32 @@ def _process_item(
                 raise RuntimeError(update.text)
             _emit_update_summary(family, item_id, update)
             new_status = _status_from_update(update)
-            commit_final_bookkeeping(paths.project_root, family, item_id, new_status)
-            return new_status
+            if final_session_status != "success":
+                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
+
+            return _complete_success_merge(
+                family,
+                item_id,
+                new_status,
+                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=classification.fatal_error_code,
+            )
     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:
@@ -513,6 +625,172 @@ 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)
+    else:
+        commit_wip_changes(execution_root, family, item_id, status)
+
+
+def _record_setup_failure(
+    family: RunnerFamily,
+    invocation: RunnerInvocation,
+    item_id: str,
+    project_root: Path,
+    status_root: Path,
+    base_branch: str,
+    branch_name: str,
+    *,
+    worktree_runtime=None,
+) -> str:
+    """Record setup-time infra failures on a task branch when one exists."""
+    if status_root.resolve() == project_root.resolve() and current_branch(project_root) != branch_name:
+        return "infra_error"
+    status_family = _family_for_execution_root(family, project_root, status_root)
+    status_invocation = _invocation_for_execution_family(invocation, status_family)
+    start = start_item(status_family, status_invocation, item_id, status_root)
+    if start.ok:
+        commit_pre_branch_bookkeeping(status_root, status_family, item_id)
+    update = update_item(
+        status_family,
+        status_invocation,
+        item_id,
+        "infra_error",
+        "",
+        status_root,
+        active_dev_branch=branch_name,
+        base_branch=base_branch,
+    )
+    new_status = _status_from_update(update) if update.ok else "infra_error"
+    if update.ok:
+        commit_final_bookkeeping(status_root, status_family, item_id, new_status)
+        _save_failure_wip(status_root, family, item_id, new_status, worktree_runtime)
+    if worktree_runtime is not None:
+        guarded_worktree_remove(worktree_runtime, delete_branch=False)
+    elif current_branch(project_root) == branch_name:
+        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)
@@ -539,6 +817,89 @@ def _use_worktree_for_family(env: RunnerEnvironment, family: RunnerFamily) -> bo
     return env.use_worktree and family.kind in {"feature", "bugfix"}
 
 
+def _family_for_execution_root(family: RunnerFamily, project_root: Path, execution_root: Path) -> RunnerFamily:
+    """Return family paths rooted in the task execution checkout."""
+    if execution_root.resolve() == project_root.resolve():
+        return family
+    return RunnerFamily(
+        kind=family.kind,
+        id_prefix=family.id_prefix,
+        list_key=family.list_key,
+        list_arg=family.list_arg,
+        item_id_arg=family.item_id_arg,
+        state_dir=_path_in_execution_root(family.state_dir, project_root, execution_root),
+        plan_path=_path_in_execution_root(family.plan_path, project_root, execution_root),
+        updater_script=family.updater_script,
+        prompt_script=family.prompt_script,
+        branch_prefix=family.branch_prefix,
+        artifact_root_name=family.artifact_root_name,
+    )
+
+
+def _invocation_for_execution_family(invocation: RunnerInvocation, family: RunnerFamily) -> RunnerInvocation:
+    return RunnerInvocation(
+        action=invocation.action,
+        list_path=family.plan_path,
+        item_id=invocation.item_id,
+        item_filter=invocation.item_filter,
+        max_retries=invocation.max_retries,
+        max_infra_retries=invocation.max_infra_retries,
+        mode=invocation.mode,
+        critic=invocation.critic,
+        dry_run=invocation.dry_run,
+        clean=invocation.clean,
+        no_reset=invocation.no_reset,
+        resume_phase=invocation.resume_phase,
+        help_requested=invocation.help_requested,
+        unknown_args=invocation.unknown_args,
+        raw_args=invocation.raw_args,
+    )
+
+
+def _path_in_execution_root(path: Path, project_root: Path, execution_root: Path) -> Path:
+    try:
+        return execution_root / path.resolve().relative_to(project_root.resolve())
+    except ValueError:
+        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,
     *,
@@ -579,8 +940,7 @@ def _status_from_update(update_result) -> str:
 
 
 def _default_branch_name(family: RunnerFamily, item_id: str) -> str:
-    stamp = time.strftime("%Y%m%d%H%M")
-    return f"{family.branch_prefix}/{item_id}-{stamp}"
+    return f"{family.branch_prefix}/{item_id}-{time.strftime('%Y%m%d%H%M%S')}"
 
 
 def _session_id(item_id: str) -> str: