prizmkit 1.1.153 → 1.1.155

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

@@ -1,4 +1,4 @@
-"""Python foreground runner dispatch for feature, bugfix, refactor, and recovery."""
+"""Python foreground runner dispatch for feature, bugfix, and refactor pipelines."""
 
 from __future__ import annotations
 
@@ -6,6 +6,7 @@ import json
 import os
 import signal
 import sys
+import tempfile
 import threading
 import time
 from collections.abc import Iterator, Mapping
@@ -19,6 +20,7 @@ from .gitops import (
     WorktreePolicy,
     branch_create_plan,
     branch_ensure_return,
+    branch_fast_forward_possible,
     branch_merge_plan,
     branch_save_wip,
     current_branch,
@@ -41,10 +43,18 @@ from .runner_bookkeeping import (
     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_models import (
+    RunnerEnvironment,
+    RunnerFamily,
+    RunnerInvocation,
+    SessionClassification,
+    SessionPaths,
+    family_for,
+    parse_invocation,
+)
 from .runner_prompts import PromptGenerationResult, generate_prompt
-from .runner_recovery import run_recovery, run_recovery_detect
-from .runner_status import get_next, run_status_action, start_item, status_text, update_item
+from .runtime_commit import REQUEST_FILENAME, RuntimeCommitResult, finalize_runtime_commit
+from .runner_status import get_next, start_item, status_text, update_item
 from .sessions import AISessionConfig, AISessionLauncher, detect_stream_json_support
 from .task_checkout import (
     CHECKOUT_MODE_BRANCH,
@@ -95,21 +105,6 @@ def run_pipeline_command(kind: str, action: str, legacy_args: tuple[str, ...], p
     if action == "status":
         status = status_text(family, invocation, paths.project_root)
         return CommandResult(status.return_code, f"Python {kind} status", status.stdout.strip() or status.stderr.strip())
-    if action == "unskip":
-        status = run_status_action(
-            family,
-            "unskip",
-            invocation,
-            item_id=invocation.item_id,
-            project_root=paths.project_root,
-        )
-        return CommandResult(
-            status.return_code,
-            f"Python {kind} unskip",
-            status.stdout.strip() or status.stderr.strip(),
-        )
-    if action == "test-cli":
-        return _test_cli(kind, paths)
     if action != "run":
         return CommandResult(1, "Unsupported Python runner action", f"Unsupported action: {kind} {action}")
     if not invocation.list_path.is_file():
@@ -121,24 +116,13 @@ def run_pipeline_command(kind: str, action: str, legacy_args: tuple[str, ...], p
         return CommandResult(1, f"Python {kind} runner failed", str(exc))
     details = result.details + ((f"last_status: {result.last_status}",) if result.last_status else ())
     return CommandResult(
-        0 if result.completed else 1,
+        0 if result.completed or result.last_status == "dry_run" else 1,
         f"Python {kind} runner",
         f"processed={result.processed} completed={result.completed} stopped_reason={result.stopped_reason or 'none'}",
         details=details,
     )
 
 
-def run_recovery_command(action: str, legacy_args: tuple[str, ...], paths) -> CommandResult:
-    """Dispatch a Python recovery command."""
-    if action == "detect":
-        code, stdout, stderr, _data = run_recovery_detect(paths)
-        return CommandResult(code, "Python recovery detect", stdout.strip() or stderr.strip())
-    if action == "run":
-        code, stdout, stderr = run_recovery(paths, legacy_args)
-        return CommandResult(code, "Python recovery run", stdout.strip() or stderr.strip())
-    return CommandResult(1, "Unsupported Python recovery action", f"Unsupported action: {action}")
-
-
 def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) -> "PipelineRunResult":
     from .runner_models import PipelineRunResult
 
@@ -150,7 +134,12 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
         except KeyboardInterrupt:
             with shield_interruption_signals():
                 return PipelineRunResult(False, 1, "interrupted", "interrupted")
-        return PipelineRunResult(status == "completed", 1, "single_item_done", status)
+        return PipelineRunResult(
+            status == "completed",
+            1,
+            "dry_run" if status == "dry_run" else "single_item_done",
+            status,
+        )
 
     while True:
         next_result = get_next(family, invocation, paths.project_root)
@@ -182,6 +171,14 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
         item_id = str(next_result.data.get(f"{family.kind}_id") or next_result.data.get("feature_id") or next_result.data.get("bug_id") or next_result.data.get("refactor_id") or "")
         if not item_id:
             return PipelineRunResult(False, processed, "missing_item_id", details=(marker[:500],))
+        if item_id in item_statuses:
+            return PipelineRunResult(
+                False,
+                processed,
+                "reselected_item",
+                item_statuses[item_id],
+                _render_item_statuses(item_statuses),
+            )
         try:
             final_status = _process_item(family, invocation, item_id, paths, initial_metadata=next_result.data)
         except KeyboardInterrupt:
@@ -197,6 +194,22 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
                 )
         processed += 1
         item_statuses[item_id] = final_status
+        if final_status == "dry_run":
+            return PipelineRunResult(
+                False,
+                processed,
+                "dry_run",
+                final_status,
+                _render_item_statuses(item_statuses),
+            )
+        if final_status == "skipped":
+            return PipelineRunResult(
+                False,
+                processed,
+                "item_skipped",
+                final_status,
+                _render_item_statuses(item_statuses),
+            )
         if final_status in _completion_compatible_statuses(family):
             if final_status == "completed":
                 _emit_info(f"Pausing 5s before next {family.kind}...")
@@ -210,7 +223,7 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
             return PipelineRunResult(False, processed, "item_failed", final_status, details)
 
 
-_COMPLETION_COMPATIBLE_STATUSES = {"completed", "skipped", "auto_skipped"}
+_COMPLETION_COMPATIBLE_STATUSES = {"completed", "auto_skipped"}
 
 
 def _completion_compatible_statuses(family: RunnerFamily) -> set[str]:
@@ -423,21 +436,10 @@ def _child_log_activity_summary(progress: Mapping[str, object]) -> str:
     return _bytes_text(child_bytes)
 
 
-def _emit_prompt_summary(prompt: PromptGenerationResult, session_id: str) -> None:
-    if prompt.pipeline_mode:
-        _emit_info(f"Pipeline mode: {_pipeline_mode_label(prompt.pipeline_mode)}")
+def _emit_prompt_summary(_prompt: PromptGenerationResult, session_id: str) -> None:
     _emit_info(f"Spawning AI CLI session: {session_id}")
 
 
-def _pipeline_mode_label(mode: str) -> str:
-    labels = {
-        "lite": "lite (Tier 1 — Scoped Guidance)",
-        "standard": "standard (Tier 2 — Review Gates)",
-        "full": "full (Full Guidance)",
-    }
-    return labels.get(mode, mode)
-
-
 def _emit_session_summary(session_result, session_paths: SessionPaths, classification) -> None:
     lines, size = _session_log_summary(session_paths.session_log)
     _emit_info(f"Session log: {lines} lines, {size}")
@@ -482,6 +484,8 @@ def _process_item(
     *,
     initial_metadata: dict[str, object],
 ) -> str:
+    if invocation.dry_run:
+        return _preview_item(family, invocation, item_id, paths, initial_metadata)
     try:
         with task_checkout_guard(family.state_dir, item_id):
             return _process_item_locked(family, invocation, item_id, paths, initial_metadata=initial_metadata)
@@ -489,6 +493,44 @@ def _process_item(
         raise
 
 
+def _preview_item(
+    family: RunnerFamily,
+    invocation: RunnerInvocation,
+    item_id: str,
+    paths,
+    initial_metadata: dict[str, object],
+) -> str:
+    """Render one disposable Prompt preview without mutating task or Git state."""
+    config = load_runtime_config(paths)
+    if not config.ai_client.command:
+        raise RuntimeError("No supported AI CLI command was found")
+    metadata = _with_recovery_metadata(family, item_id, initial_metadata)
+    retry_count = int(metadata.get("retry_count") or 0)
+    session_id = f"{item_id}-dry-run"
+    _emit_item_header(family, invocation, item_id, metadata)
+    with tempfile.TemporaryDirectory(prefix="prizmkit-dry-run-") as temporary:
+        session_paths = SessionPaths.for_item(Path(temporary), item_id, session_id)
+        prompt = generate_prompt(
+            family,
+            invocation,
+            item_id=item_id,
+            session_id=session_id,
+            run_id="dry-run",
+            retry_count=retry_count,
+            session_paths=session_paths,
+            project_root=paths.project_root,
+            execution_root=paths.project_root,
+            preview=True,
+        )
+        prompt_size = prompt.output_path.stat().st_size
+        model = prompt.model or config.model or "default"
+        _emit_info(
+            f"Dry-run Prompt validated for {item_id}: model={model}, bytes={prompt_size}; "
+            "no checkout, checkpoint, task status, or AI session was created"
+        )
+    return "dry_run"
+
+
 def _process_item_locked(
     family: RunnerFamily,
     invocation: RunnerInvocation,
@@ -677,8 +719,6 @@ def _process_item_locked(
                 execution_root=execution_root,
                 continuation=continuation,
             )
-            if invocation.dry_run:
-                return "dry_run"
             _emit_prompt_summary(prompt, session_id)
             stream_json = False
             if getattr(config.ai_client, "launch_profile", None) is None:
@@ -707,6 +747,10 @@ def _process_item_locked(
                     suppress_stream_output=True,
                 )
             ).run()
+            runtime_commit = _finalize_prepared_runtime_commit(
+                execution_root,
+                prompt,
+            )
             classification = classify_session(
                 session_result,
                 project_root=execution_root,
@@ -715,6 +759,13 @@ def _process_item_locked(
                 previous_fingerprint=previous_fingerprint,
                 previous_no_progress_count=previous_no_progress_count,
             )
+            if runtime_commit.status == "failed":
+                classification = SessionClassification(
+                    "commit_missing",
+                    reason=runtime_commit.reason,
+                    progress_fingerprint=classification.progress_fingerprint,
+                    checkpoint_state=classification.checkpoint_state,
+                )
             _emit_session_summary(session_result, session_paths, classification)
             final_session_status = classification.session_status
             summary_path = _continuation_summary_path(execution_root, family, item_id, prompt)
@@ -938,6 +989,34 @@ def _emit_interruption_cleanup_failure(result, message: str, recovery: str) -> N
     _emit_warning(recovery)
 
 
+def _finalize_prepared_runtime_commit(
+    execution_root: Path,
+    prompt: PromptGenerationResult,
+) -> RuntimeCommitResult:
+    """Execute a prepared commit only when the checkpoint proves readiness."""
+    checkpoint = prompt.checkpoint_path
+    artifact = prompt.artifact_path
+    if checkpoint is None or artifact is None or not checkpoint.is_file():
+        return RuntimeCommitResult("not_ready", "commit_handoff_unavailable")
+    from .checkpoint_state import load_checkpoint_state
+
+    state = load_checkpoint_state(checkpoint, project_root=execution_root)
+    request_path = artifact / REQUEST_FILENAME
+    cleanup_recovery = state.semantic_complete and request_path.is_file()
+    if not state.semantic_commit_ready and not cleanup_recovery:
+        return RuntimeCommitResult("not_ready", "checkpoint_not_commit_ready")
+    result = finalize_runtime_commit(
+        execution_root,
+        artifact_dir=artifact,
+        checkpoint_path=checkpoint,
+    )
+    if result.committed:
+        _emit_success(f"Runtime committed prepared task change: {result.commit_hash}")
+    else:
+        _emit_warning(f"Runtime commit preparation failed: {result.reason}")
+    return result
+
+
 def _is_retryable_ai_outcome(session_status: str, new_status: str) -> bool:
     """Return whether a persisted post-launch outcome should continue in-process."""
     if session_status in {
@@ -1069,7 +1148,17 @@ def _complete_success_merge(
             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))
+        merge = run_git_plan(
+            paths.project_root,
+            branch_merge_plan(
+                branch_context,
+                auto_push=env.auto_push,
+                rebase=not branch_fast_forward_possible(
+                    paths.project_root,
+                    branch_context,
+                ),
+            ),
+        )
         _emit_git_plan_output(merge)
         if merge.ok:
             checkout = load_task_checkout(family.state_dir, family.task_type, item_id)
@@ -1165,28 +1254,6 @@ def _record_setup_failure(
         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)
-    cli = config.ai_client.command or "(not found)"
-    platform = config.ai_client.platform or "unresolved"
-    details = [
-        f"detected_cli: {cli}",
-        f"platform: {platform}",
-        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,
-        f"Python {kind} AI CLI test",
-        "AI CLI resolution for the canonical Python runtime.",
-        tuple(details),
-    )
-
-
 def _use_worktree_for_family(env: RunnerEnvironment, family: RunnerFamily) -> bool:
     return env.use_worktree and family.kind in {"feature", "bugfix"}
 
@@ -1218,7 +1285,6 @@ def _invocation_for_execution_family(invocation: RunnerInvocation, family: Runne
         item_filter=invocation.item_filter,
         max_retries=invocation.max_retries,
         max_infra_retries=invocation.max_infra_retries,
-        mode=invocation.mode,
         dry_run=invocation.dry_run,
         clean=invocation.clean,
         no_reset=invocation.no_reset,
@@ -1341,7 +1407,6 @@ def _resolve_invocation_paths(invocation: RunnerInvocation, project_root: Path)
         item_filter=invocation.item_filter,
         max_retries=invocation.max_retries,
         max_infra_retries=invocation.max_infra_retries,
-        mode=invocation.mode,
         dry_run=invocation.dry_run,
         clean=invocation.clean,
         no_reset=invocation.no_reset,
@@ -1355,6 +1420,6 @@ def _resolve_invocation_paths(invocation: RunnerInvocation, project_root: Path)
 def _help_text(family: RunnerFamily) -> str:
     return (
         f"Python foreground runner for {family.kind}.\n"
-        "Supported legacy options include plan list path, item id, --features for feature, "
-        "--max-retries, --max-infra-retries, --mode, --resume-phase, and --dry-run."
+        "Supported options include plan list path, item id, --features for feature, "
+        "--max-retries, --max-infra-retries, --resume-phase, and --dry-run."
     )