prizmkit 1.1.154 → 1.1.155

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/runner_classification.py

@@ -65,6 +65,17 @@ def classify_session(
             progress_fingerprint=fingerprint,
             checkpoint_state=checkpoint.semantic_snapshot,
         )
+    if (
+        checkpoint is not None
+        and checkpoint.semantic_complete
+        and not _runtime_commit_receipt_matches(project_root, checkpoint)
+    ):
+        return SessionClassification(
+            "commit_missing",
+            reason="runtime_commit_receipt_mismatch",
+            progress_fingerprint=fingerprint,
+            checkpoint_state=checkpoint.semantic_snapshot,
+        )
     if _is_terminal_success(result) and checkpoint is not None and checkpoint.semantic_complete:
         return SessionClassification(
             "success",
@@ -172,6 +183,25 @@ def _is_terminal_success(result: AISessionResult) -> bool:
     )
 
 
+def _runtime_commit_receipt_matches(
+    project_root: Path,
+    checkpoint: CheckpointState,
+) -> bool:
+    """Verify canonical Runtime receipt identity against the current Git HEAD."""
+    commit_hash = checkpoint.semantic.runtime_commit_hash
+    base_head = checkpoint.semantic.runtime_base_head
+    if not commit_hash and not base_head:
+        return True
+    head = run_git_command(project_root, ("rev-parse", "HEAD"))
+    parent = run_git_command(project_root, ("rev-parse", f"{commit_hash}^"))
+    return bool(
+        head.return_code == 0
+        and parent.return_code == 0
+        and head.stdout.strip().lower() == commit_hash.lower()
+        and parent.stdout.strip().lower() == base_head.lower()
+    )
+
+
 def _has_late_runtime_error_after_completion(
     result: AISessionResult,
     checkpoint: CheckpointState | None,
@@ -201,9 +231,27 @@ def has_branch_completion_evidence(
     working_branch: str,
     artifact_path: Path | None,
 ) -> bool:
-    """Return true only when a task branch is ahead and semantically complete."""
-    if not base_branch or not working_branch or not has_completed_artifact_path(artifact_path, project_root):
+    """Require semantic completion and matching Runtime receipt on the task branch."""
+    if not base_branch or not working_branch or artifact_path is None:
+        return False
+    checkpoint_path = artifact_path / "workflow-checkpoint.json"
+    if not checkpoint_path.is_file():
+        return False
+    checkpoint = load_checkpoint_state(checkpoint_path, project_root=project_root)
+    if not checkpoint.semantic_complete:
         return False
+    commit_hash = checkpoint.semantic.runtime_commit_hash
+    base_head = checkpoint.semantic.runtime_base_head
+    if commit_hash or base_head:
+        branch_head = run_git_command(project_root, ("rev-parse", working_branch))
+        parent = run_git_command(project_root, ("rev-parse", f"{commit_hash}^"))
+        if not (
+            branch_head.return_code == 0
+            and parent.return_code == 0
+            and branch_head.stdout.strip().lower() == commit_hash.lower()
+            and parent.stdout.strip().lower() == base_head.lower()
+        ):
+            return False
     return _has_commit_range(project_root, base_branch, working_branch)
 
 

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

@@ -79,7 +79,6 @@ class RunnerInvocation:
     item_filter: str = ""
     max_retries: int | None = None
     max_infra_retries: int = 3
-    mode: str | None = None
     dry_run: bool = False
     clean: bool = False
     no_reset: bool = False
@@ -95,7 +94,6 @@ class PromptGenerationResult:
 
     output_path: Path
     model: str = ""
-    pipeline_mode: str = ""
     checkpoint_path: Path | None = None
     artifact_path: Path | None = None
     raw: Mapping[str, object] = field(default_factory=dict)
@@ -273,7 +271,6 @@ def parse_invocation(
     item_filter = ""
     max_retries: int | None = None
     max_infra_retries = 3
-    mode: str | None = None
     dry_run = False
     clean = False
     no_reset = False
@@ -308,11 +305,6 @@ def parse_invocation(
             max_infra_retries = _safe_int(args[index], 3)
         elif arg.startswith("--max-infra-retries="):
             max_infra_retries = _safe_int(arg.split("=", 1)[1], 3)
-        elif arg == "--mode" and index + 1 < len(args):
-            index += 1
-            mode = args[index]
-        elif arg.startswith("--mode="):
-            mode = arg.split("=", 1)[1]
         elif arg == "--resume-phase" and index + 1 < len(args):
             index += 1
             resume_phase = args[index]
@@ -339,7 +331,6 @@ def parse_invocation(
         item_filter=item_filter,
         max_retries=max_retries,
         max_infra_retries=max_infra_retries,
-        mode=mode,
         dry_run=dry_run,
         clean=clean,
         no_reset=no_reset,

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

@@ -22,6 +22,7 @@ def generate_prompt(
     project_root: Path,
     execution_root: Path | None = None,
     continuation: dict[str, object] | None = None,
+    preview: bool = False,
 ) -> PromptGenerationResult:
     """Run the existing prompt generator and return its structured JSON result."""
     visible_root = execution_root or project_root
@@ -47,8 +48,8 @@ def generate_prompt(
         "--output",
         str(session_paths.prompt_path),
     ]
-    if invocation.mode:
-        command.extend(["--mode", invocation.mode])
+    if preview:
+        command.append("--no-checkpoint-write")
     if continuation:
         command.extend(["--continuation-mode", "ai_error"])
         for flag, key in (
@@ -95,7 +96,6 @@ def generate_prompt(
     return PromptGenerationResult(
         output_path=output_path,
         model=str(data.get("model") or ""),
-        pipeline_mode=str(data.get("pipeline_mode") or ""),
         checkpoint_path=Path(str(checkpoint)) if checkpoint else None,
         artifact_path=_artifact_path(family, visible_root, item_id, data),
         raw=data,

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

@@ -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,8 +43,17 @@ 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 .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 (
@@ -105,7 +116,7 @@ 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,
@@ -123,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)
@@ -178,6 +194,14 @@ 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,
@@ -412,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}")
@@ -471,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)
@@ -478,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,
@@ -666,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:
@@ -696,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,
@@ -704,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)
@@ -927,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 {
@@ -1058,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)
@@ -1185,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,
@@ -1308,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,
@@ -1322,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."
     )