prizmkit 1.1.106 → 1.1.107

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.106",
-  "bundledAt": "2026-07-07T02:54:30.507Z",
-  "bundledFrom": "8e4fe49"
+  "frameworkVersion": "1.1.107",
+  "bundledAt": "2026-07-07T11:02:06.367Z",
+  "bundledFrom": "93afdd5"
 }

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",
 )
 
 
@@ -52,6 +56,13 @@ def classify_session(
             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)
@@ -121,6 +132,16 @@ def _is_terminal_success(result: AISessionResult) -> bool:
     )
 
 
+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
@@ -131,11 +152,32 @@ def _has_completed_workflow_artifact(prompt: PromptGenerationResult | None) -> b
             data = {}
         if isinstance(data, dict) and _checkpoint_cursor(data) == "complete":
             return True
-    if prompt.artifact_path and (prompt.artifact_path / "completion-summary.json").is_file():
+    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
@@ -161,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()

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

@@ -32,7 +32,7 @@ from .runner_bookkeeping import (
     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 +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))
@@ -138,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
 
 
@@ -190,6 +229,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,8 +380,9 @@ 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)
@@ -356,21 +424,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)
@@ -500,62 +598,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 +625,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 +863,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,
     *,