prizmkit 1.1.105 → 1.1.107

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.105",
-  "bundledAt": "2026-07-06T18:17:35.126Z",
-  "bundledFrom": "e92eb9f"
+  "frameworkVersion": "1.1.107",
+  "bundledAt": "2026-07-07T11:02:06.367Z",
+  "bundledFrom": "93afdd5"
 }

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

@@ -565,7 +565,6 @@ def branch_ensure_return_plan(context: BranchContext) -> GitCommandPlan:
             ),
             _git("stash", "push", "-m", "pipeline-ensure-return-stash", allow_failure=True, description="stash checkout blockers"),
             _git("checkout", context.base_branch, allow_failure=True, description="return to original branch"),
-            _git("stash", "pop", allow_failure=True, description="restore stashed checkout blockers"),
         ),
         never_fails=True,
         notes=("Always returns success to support trap/finally cleanup paths.",),

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

@@ -7,10 +7,11 @@ legacy ordering around branch creation and final status updates.
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
-from .gitops import GitCommandResult, git_status_safe, run_git_command
+from .gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES, GitCommandResult, git_status_safe, run_git_command
 from .runner_models import RunnerFamily
 
 
@@ -27,25 +28,95 @@ class BookkeepingResult:
         return self.result is None or self.result.return_code == 0
 
 
-def has_workspace_changes(project_root: Path) -> bool:
-    """Return true when git status has non-hidden-tool worktree changes."""
-    return bool(git_status_safe(project_root).strip())
+def _bookkeeping_paths(project_root: Path, family: RunnerFamily, item_id: str) -> tuple[str, ...]:
+    return (
+        _repo_path(project_root, family.plan_path),
+        _repo_path(project_root, family.state_dir / item_id / "status.json"),
+    )
+
+
+def _repo_path(project_root: Path, path: Path) -> str:
+    try:
+        return path.resolve().relative_to(project_root.resolve()).as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
+def _changed_paths_in(project_root: Path, paths: Sequence[str]) -> tuple[str, ...]:
+    result = run_git_command(project_root, ("status", "--porcelain", "--", *paths))
+    if result.return_code != 0:
+        return ()
+    changed: list[str] = []
+    for line in result.stdout.splitlines():
+        path = line[3:].strip()
+        if " -> " in path:
+            path = path.split(" -> ", 1)[1].strip()
+        if path:
+            changed.append(path)
+    return tuple(changed)
+
+
+def commit_bookkeeping_changes(
+    project_root: Path,
+    family: RunnerFamily,
+    item_id: str,
+    message: str,
+) -> BookkeepingResult:
+    """Stage and commit only runner-owned bookkeeping paths when present."""
+    paths = _changed_paths_in(project_root, _bookkeeping_paths(project_root, family, item_id))
+    if not paths:
+        return BookkeepingResult(attempted=False, committed=False)
+    run_git_command(project_root, ("add", "-A", "--", *paths))
+    result = run_git_command(project_root, ("commit", "--no-verify", "-m", message))
+    return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
 
 
-def commit_all_changes(project_root: Path, message: str) -> BookkeepingResult:
-    """Stage and commit current workspace changes when present."""
-    if not has_workspace_changes(project_root):
+def commit_task_branch_changes(
+    project_root: Path,
+    family: RunnerFamily,
+    item_id: str,
+    status: str,
+) -> BookkeepingResult:
+    """Commit task branch code, artifacts, and status without switching branches."""
+    message = f"chore({item_id}): save {family.kind} {status} state"
+    if status == "completed":
+        message = f"chore({item_id}): complete {family.kind} task"
+    if not git_status_safe(project_root).strip():
         return BookkeepingResult(attempted=False, committed=False)
-    run_git_command(project_root, ("add", "-A", "--", "."))
+    run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
     result = run_git_command(project_root, ("commit", "--no-verify", "-m", message))
     return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
 
 
+def commit_wip_changes(
+    project_root: Path,
+    family: RunnerFamily,
+    item_id: str,
+    status: str,
+) -> BookkeepingResult:
+    """Commit all visible task-branch changes as preserved WIP."""
+    if not git_status_safe(project_root).strip():
+        return BookkeepingResult(attempted=False, committed=False)
+    run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
+    result = run_git_command(
+        project_root,
+        (
+            "commit",
+            "--no-verify",
+            "-m",
+            f"wip({item_id}): preserve {family.kind} {status} state",
+            "-m",
+            "Pipeline preserved task branch work without merging it to the base branch.",
+        ),
+    )
+    return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
+
+
 def commit_pre_branch_bookkeeping(project_root: Path, family: RunnerFamily, item_id: str) -> BookkeepingResult:
-    """Commit status/list changes before creating the item dev branch."""
-    return commit_all_changes(project_root, f"chore({item_id}): mark in_progress")
+    """Commit in-progress status on the current task branch."""
+    return commit_bookkeeping_changes(project_root, family, item_id, f"chore({item_id}): mark in_progress")
 
 
 def commit_final_bookkeeping(project_root: Path, family: RunnerFamily, item_id: str, status: str) -> BookkeepingResult:
-    """Commit final list/state changes after returning to the base branch."""
-    return commit_all_changes(project_root, f"chore({item_id}): update {family.kind} status {status}")
+    """Commit final runner-owned status changes on the current task branch."""
+    return commit_bookkeeping_changes(project_root, family, item_id, f"chore({item_id}): update {family.kind} status {status}")

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

@@ -29,6 +29,10 @@ INFRA_MARKERS = (
     "authentication",
     "unauthorized",
     "api error",
+    "quota",
+    "usage limit",
+    "credit balance",
+    "billing",
 )
 
 
@@ -43,10 +47,25 @@ def classify_session(
 ) -> SessionClassification:
     """Classify raw AI session signals with durable success precedence."""
     fingerprint = progress_fingerprint(project_root, prompt)
-    if _has_commit_since(project_root, base_head):
-        return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
+    has_commit_since_base = _has_commit_since(project_root, base_head)
+
+    if _is_terminal_success(result) and _has_completed_workflow_artifact(prompt):
+        return SessionClassification(
+            "success",
+            reason="terminal_success_with_completed_checkpoint",
+            progress_fingerprint=fingerprint,
+        )
+
+    if _has_late_runtime_error_after_completion(result, prompt, has_commit_since_base):
+        return SessionClassification(
+            "success",
+            reason="completed_checkpoint_with_late_runtime_error",
+            progress_fingerprint=fingerprint,
+        )
 
     if _is_context_overflow(result):
+        if has_commit_since_base:
+            return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
         no_progress_count = _next_no_progress_count(previous_fingerprint, fingerprint, previous_no_progress_count)
         if no_progress_count >= 2:
             return SessionClassification(
@@ -72,6 +91,8 @@ def classify_session(
         return SessionClassification("timed_out", reason="timeout", progress_fingerprint=fingerprint)
     if result.exit_code not in (0, None):
         return SessionClassification("crashed", reason=f"exit_code={result.exit_code}", progress_fingerprint=fingerprint)
+    if has_commit_since_base:
+        return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
     if _has_workspace_changes(project_root):
         _auto_commit_workspace(project_root)
         return SessionClassification("success", reason="auto_commit_uncommitted_changes", progress_fingerprint=fingerprint)
@@ -100,6 +121,63 @@ def progress_fingerprint(project_root: Path, prompt: PromptGenerationResult | No
     }
 
 
+def _is_terminal_success(result: AISessionResult) -> bool:
+    return (
+        result.exit_code in (0, None)
+        and not result.timed_out
+        and result.termination_reason not in {"timeout", "stale_session"}
+        and not result.fatal_error_code
+        and not result.progress_summary.fatal_error_code
+        and result.progress_summary.result_subtype == "success"
+    )
+
+
+def _has_late_runtime_error_after_completion(
+    result: AISessionResult,
+    prompt: PromptGenerationResult | None,
+    has_commit_since_base: bool,
+) -> bool:
+    if not has_commit_since_base or not _has_completed_workflow_artifact(prompt):
+        return False
+    return _is_context_overflow(result) or _is_infra_error(result)
+
+
+def _has_completed_workflow_artifact(prompt: PromptGenerationResult | None) -> bool:
+    if prompt is None:
+        return False
+    if prompt.checkpoint_path and prompt.checkpoint_path.is_file():
+        try:
+            data = json.loads(prompt.checkpoint_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            data = {}
+        if isinstance(data, dict) and _checkpoint_cursor(data) == "complete":
+            return True
+    if prompt.artifact_path and has_completed_artifact_path(prompt.artifact_path):
+        return True
+    return False
+
+
+def has_branch_completion_evidence(project_root: Path, base_branch: str, working_branch: str, artifact_path: Path | None) -> bool:
+    """Return true when a recorded task branch already has completed work to merge."""
+    if not base_branch or not working_branch or not has_completed_artifact_path(artifact_path):
+        return False
+    return _has_commit_range(project_root, base_branch, working_branch)
+
+
+def has_completed_artifact_path(artifact_path: Path | None) -> bool:
+    if artifact_path is None:
+        return False
+    checkpoint = artifact_path / "workflow-checkpoint.json"
+    if checkpoint.is_file():
+        try:
+            data = json.loads(checkpoint.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            data = {}
+        if isinstance(data, dict) and _checkpoint_cursor(data) == "complete":
+            return True
+    return (artifact_path / "completion-summary.json").is_file()
+
+
 def _next_no_progress_count(previous: object | None, current: object, count: int) -> int:
     if previous and previous == current:
         return max(0, count) + 1
@@ -125,11 +203,20 @@ def _is_infra_error(result: AISessionResult) -> bool:
     return bool(result.fatal_error_code and result.fatal_error_code != CONTEXT_OVERFLOW) or any(marker in text for marker in INFRA_MARKERS)
 
 
-def _has_commit_since(project_root: Path, base_head: str) -> bool:
-    if not base_head:
+def _has_commit_range(project_root: Path, start_ref: str, end_ref: str = "HEAD") -> bool:
+    if not start_ref or not end_ref:
         return False
-    current = run_git_command(project_root, ("rev-parse", "HEAD")).stdout.strip()
-    return bool(current and current != base_head)
+    result = run_git_command(project_root, ("rev-list", "--count", f"{start_ref}..{end_ref}"))
+    if result.return_code != 0:
+        return False
+    try:
+        return int(result.stdout.strip() or "0") > 0
+    except ValueError:
+        return False
+
+
+def _has_commit_since(project_root: Path, base_head: str) -> bool:
+    return _has_commit_range(project_root, base_head, "HEAD")
 
 
 def _has_workspace_changes(project_root: Path) -> bool:

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

@@ -45,7 +45,6 @@ class RunnerEnvironment:
     heartbeat_interval_seconds: int = 30
     heartbeat_stale_threshold_seconds: int = 600
     stale_kill_threshold_seconds: int = 600
-    max_log_size: int | None = None
     max_retries: int = 3
     strict_behavior_check: bool = True
 
@@ -67,7 +66,6 @@ class RunnerEnvironment:
                 _int_value(values, "HEARTBEAT_TIMEOUT_SECONDS", 600),
             ),
             stale_kill_threshold_seconds=_int_value(values, "STALE_KILL_THRESHOLD", 600),
-            max_log_size=_optional_int(values.get("MAX_LOG_SIZE")),
             max_retries=max(0, _int_value(values, "MAX_RETRIES", 3)),
             strict_behavior_check=not _falsey(values.get("STRICT_BEHAVIOR_CHECK")),
         )
@@ -349,9 +347,3 @@ def _safe_int(value: str | None, default: int) -> int:
 
 def _int_value(values: Mapping[str, str], name: str, default: int) -> int:
     return _safe_int(values.get(name), default)
-
-
-def _optional_int(value: str | None) -> int | None:
-    if value is None or str(value).strip() == "":
-        return None
-    return _safe_int(value, 0)

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

@@ -12,7 +12,7 @@ from pathlib import Path
 from .config import load_runtime_config
 from .paths import RuntimePaths
 from .runner_models import RunnerEnvironment, SessionPaths
-from .sessions import AISessionConfig, AISessionLauncher
+from .sessions import AISessionConfig, AISessionLauncher, detect_stream_json_support
 
 
 @dataclass(frozen=True)
@@ -122,6 +122,9 @@ def run_recovery(paths: RuntimePaths, legacy_args: tuple[str, ...] = ()) -> tupl
     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:
+        stream_json = detect_stream_json_support(config.ai_client.command, config.ai_client.platform).enabled
     launcher = AISessionLauncher(
         AISessionConfig(
             cli_command=config.ai_client.command,
@@ -134,7 +137,12 @@ def run_recovery(paths: RuntimePaths, legacy_args: tuple[str, ...] = ()) -> tupl
             heartbeat_path=session_paths.heartbeat_json,
             effort=config.effort,
             verbose=env.verbose,
+            live_output=env.live_output,
+            use_stream_json=stream_json,
             stale_kill_threshold_seconds=env.stale_kill_threshold_seconds,
+            live_progress_interval_seconds=env.heartbeat_interval_seconds,
+            live_banner=False,
+            suppress_stream_output=True,
         )
     )
     result = launcher.run()