prizmkit 1.1.69 → 1.1.72

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.69",
-  "bundledAt": "2026-06-09T23:54:02.566Z",
-  "bundledFrom": "7453dba"
+  "frameworkVersion": "1.1.72",
+  "bundledAt": "2026-06-11T12:58:26.870Z",
+  "bundledFrom": "099177b"
 }

package/bundled/dev-pipeline/lib/common.sh

@@ -444,6 +444,433 @@ prizm_detect_infra_error() {
     return 1
 }
 
+# Detect AI runtime/provider request failures that are not caused by generated
+# project code. Unlike generic infra errors, these can be deterministic for the
+# current transcript (for example context_too_large), so the runner must first
+# check semantic completion before deciding whether to retry.
+prizm_detect_ai_runtime_error() {
+    local session_log="${1:-}"
+    local progress_json="${2:-}"
+
+    if [[ -n "$progress_json" && -f "$progress_json" ]]; then
+        local fatal_error_code
+        fatal_error_code=$(python3 - "$progress_json" <<'PY' 2>/dev/null || true
+import json
+import sys
+
+try:
+    with open(sys.argv[1], encoding="utf-8") as fh:
+        progress = json.load(fh)
+except Exception:
+    raise SystemExit(0)
+
+code = progress.get("fatal_error_code")
+if code:
+    print(str(code))
+PY
+)
+        if [[ -n "$fatal_error_code" ]]; then
+            return 0
+        fi
+    fi
+
+    local haystack=""
+    if [[ -n "$session_log" && -f "$session_log" ]]; then
+        haystack="$(tail -c 65536 "$session_log" 2>/dev/null || true)"
+    fi
+    if [[ -n "$progress_json" && -f "$progress_json" ]]; then
+        haystack+=$'\n'
+        haystack+="$(cat "$progress_json" 2>/dev/null || true)"
+    fi
+
+    [[ -n "$haystack" ]] || return 1
+
+    if printf '%s' "$haystack" | grep -Eiq \
+        'context_too_large|model_context_window_exceeded|input exceeds the context window|context window of this model|context window (was )?exceeded|exceeded (the )?context window|invalid_request_error.*context window|context window.*invalid_request_error'; then
+        if printf '%s' "$haystack" | grep -Eiq \
+            'api error|invalid_request_error|api_error_status|api_error_code|status[[:space:]]*[:=]?[[:space:]]*(400|413)|last_result_is_error[[:space:]"'\'':=]+true|is_error[[:space:]"'\'':=]+true'; then
+            return 0
+        fi
+    fi
+
+    return 1
+}
+
+prizm_feature_slug_from_list() {
+    local feature_list="$1"
+    local feature_id="$2"
+    python3 - "$feature_list" "$feature_id" <<'PY'
+import json
+import re
+import sys
+
+feature_list, feature_id = sys.argv[1], sys.argv[2]
+with open(feature_list, encoding="utf-8") as fh:
+    data = json.load(fh)
+for feature in data.get("features", []):
+    if feature.get("id") == feature_id:
+        number = feature.get("id", "").replace("F-", "").replace("f-", "").zfill(3)
+        title = str(feature.get("title", "")).lower()
+        title = re.sub(r"[^a-z0-9\s-]", "", title)
+        title = re.sub(r"[\s]+", "-", title.strip())
+        title = re.sub(r"-+", "-", title).strip("-")
+        print(f"{number}-{title}" if title else number)
+        raise SystemExit(0)
+raise SystemExit(1)
+PY
+}
+
+prizm_checkpoint_all_complete() {
+    local checkpoint_file="$1"
+    [[ -f "$checkpoint_file" ]] || return 1
+    python3 - "$checkpoint_file" <<'PY'
+import json
+import sys
+
+try:
+    with open(sys.argv[1], encoding="utf-8") as fh:
+        data = json.load(fh)
+except Exception:
+    raise SystemExit(2)
+steps = data.get("steps")
+if not isinstance(steps, list) or not steps:
+    raise SystemExit(1)
+for step in steps:
+    if not isinstance(step, dict) or step.get("status") not in ("completed", "skipped"):
+        raise SystemExit(1)
+raise SystemExit(0)
+PY
+}
+
+# Return the successful feature commit SHA if one exists in base_ref..HEAD.
+# Prefer messages containing the feature ID. If checkpoint is complete, allow an
+# older prompt variant only when the non-WIP commit identifies the feature title.
+prizm_find_feature_commit() {
+    local project_root="$1"
+    local base_ref="$2"
+    local feature_id="$3"
+    local allow_title_fallback="${4:-false}"
+    local feature_title="${5:-}"
+
+    git -C "$project_root" rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 1
+
+    local range="${base_ref}..HEAD"
+    if [[ -z "$base_ref" ]] || ! git -C "$project_root" rev-parse --verify "$base_ref" >/dev/null 2>&1; then
+        range="HEAD"
+    fi
+
+    local feature_commit
+    feature_commit=$(git -C "$project_root" log "$range" --format='%H%x09%s' 2>/dev/null \
+        | awk -F '\t' -v fid="$feature_id" 'index($2, fid) > 0 && $2 !~ /^wip(\(|:)/ { print $1; exit }')
+    if [[ -n "$feature_commit" ]]; then
+        printf '%s\n' "$feature_commit"
+        return 0
+    fi
+
+    if [[ "$allow_title_fallback" == "true" && -n "$feature_title" ]]; then
+        feature_commit=$(git -C "$project_root" log "$range" --format='%H%x09%s' 2>/dev/null \
+            | python3 -c '
+import re
+import sys
+
+title = sys.argv[1]
+
+def words(text):
+    return [w for w in re.split(r"[^a-z0-9]+", text.lower()) if len(w) >= 3]
+
+title_words = words(title)
+if not title_words:
+    raise SystemExit(1)
+# Require all title words for short titles, or a strong majority for longer
+# titles so punctuation/articles do not make older commits unmatchable.
+required = len(title_words) if len(title_words) <= 3 else max(3, int(len(title_words) * 0.75 + 0.999))
+for line in sys.stdin:
+    commit, sep, subject = line.rstrip("\n").partition("\t")
+    if not sep or re.match(r"^wip(\(|:)", subject):
+        continue
+    subject_words = set(words(subject))
+    if sum(1 for word in title_words if word in subject_words) >= required:
+        print(commit)
+        raise SystemExit(0)
+raise SystemExit(1)
+' "$feature_title")
+        if [[ -n "$feature_commit" ]]; then
+            printf '%s\n' "$feature_commit"
+            return 0
+        fi
+    fi
+
+    return 1
+}
+
+# Semantic completion means the durable workflow checkpoint is complete and a
+# non-WIP feature commit exists. This intentionally runs before exit-code based
+# failure classification so delayed post-commit model errors cannot strand a
+# completed feature on its dev branch.
+PRIZM_SEMANTIC_FEATURE_SLUG=""
+PRIZM_SEMANTIC_COMMIT_SHA=""
+prizm_feature_semantically_complete() {
+    local feature_list="$1"
+    local feature_id="$2"
+    local project_root="$3"
+    local base_ref="$4"
+    local prizmkit_dir="$5"
+
+    PRIZM_SEMANTIC_FEATURE_SLUG=""
+    PRIZM_SEMANTIC_COMMIT_SHA=""
+
+    local feature_slug
+    feature_slug=$(prizm_feature_slug_from_list "$feature_list" "$feature_id" 2>/dev/null) || return 1
+    local checkpoint_file="$prizmkit_dir/specs/${feature_slug}/workflow-checkpoint.json"
+    prizm_checkpoint_all_complete "$checkpoint_file" || return 1
+
+    local feature_title
+    feature_title=$(python3 - "$feature_list" "$feature_id" <<'PY' 2>/dev/null || true
+import json
+import sys
+with open(sys.argv[1], encoding="utf-8") as fh:
+    data = json.load(fh)
+for feature in data.get("features", []):
+    if feature.get("id") == sys.argv[2]:
+        print(feature.get("title", ""))
+        break
+PY
+)
+
+    local commit_sha
+    commit_sha=$(prizm_find_feature_commit "$project_root" "$base_ref" "$feature_id" true "$feature_title" 2>/dev/null) || return 1
+
+    PRIZM_SEMANTIC_FEATURE_SLUG="$feature_slug"
+    PRIZM_SEMANTIC_COMMIT_SHA="$commit_sha"
+    return 0
+}
+
+prizm_preserve_post_completion_dirty() {
+    local project_root="$1"
+    local artifact_dir="$2"
+    local feature_id="$3"
+    local session_id="${4:-}"
+
+    git -C "$project_root" rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 1
+
+    local dirty_status
+    dirty_status=$(git -C "$project_root" status --porcelain --untracked-files=all 2>/dev/null || true)
+    [[ -n "$dirty_status" ]] || return 0
+
+    mkdir -p "$artifact_dir" || return 1
+
+    local status_file="$artifact_dir/post-completion-status.txt"
+    local patch_file="$artifact_dir/post-completion-dirty.patch"
+    local staged_patch_file="$artifact_dir/post-completion-staged.patch"
+    local untracked_manifest="$artifact_dir/post-completion-untracked.txt"
+    local findings_file="$artifact_dir/post-completion-findings.md"
+    local untracked_dir="$artifact_dir/untracked"
+
+    printf '%s\n' "$dirty_status" > "$status_file" || return 1
+    git -C "$project_root" diff --binary > "$patch_file" 2>/dev/null || return 1
+    git -C "$project_root" diff --cached --binary > "$staged_patch_file" 2>/dev/null || return 1
+
+    : > "$untracked_manifest" || return 1
+    local untracked_tmp
+    untracked_tmp=$(mktemp 2>/dev/null || mktemp -t prizm-untracked) || return 1
+    git -C "$project_root" ls-files --others --exclude-standard -z > "$untracked_tmp" 2>/dev/null || {
+        rm -f "$untracked_tmp"
+        return 1
+    }
+
+    if [[ -s "$untracked_tmp" ]]; then
+        mkdir -p "$untracked_dir" || {
+            rm -f "$untracked_tmp"
+            return 1
+        }
+        while IFS= read -r -d '' rel_path; do
+            [[ -n "$rel_path" ]] || continue
+            printf '%s\n' "$rel_path" >> "$untracked_manifest" || {
+                rm -f "$untracked_tmp"
+                return 1
+            }
+            local source_path="$project_root/$rel_path"
+            local dest_path="$untracked_dir/$rel_path"
+            mkdir -p "$(dirname "$dest_path")" || {
+                rm -f "$untracked_tmp"
+                return 1
+            }
+            if [[ -f "$source_path" ]]; then
+                cp -p "$source_path" "$dest_path" || {
+                    rm -f "$untracked_tmp"
+                    return 1
+                }
+            elif [[ -d "$source_path" ]]; then
+                mkdir -p "$dest_path" || {
+                    rm -f "$untracked_tmp"
+                    return 1
+                }
+            fi
+        done < "$untracked_tmp"
+    fi
+
+    cat > "$findings_file" <<EOF
+# Post-completion dirty changes preserved
+
+- Feature: $feature_id
+- Session: ${session_id:-unknown}
+- Reason: workflow checkpoint and feature commit were already complete, but delayed post-commit activity left the working tree dirty.
+
+## Recovery guidance
+
+The finalized feature commit was kept unchanged for merge. Review these follow-up artifacts separately; do not assume they were merged:
+
+- \`post-completion-status.txt\` — original dirty working tree status
+- \`post-completion-dirty.patch\` — unstaged tracked changes
+- \`post-completion-staged.patch\` — staged changes
+- \`post-completion-untracked.txt\` and \`untracked/\` — untracked files copied before cleanup
+EOF
+
+    git -C "$project_root" reset --hard >/dev/null 2>&1 || {
+        rm -f "$untracked_tmp"
+        return 1
+    }
+
+    while IFS= read -r -d '' rel_path; do
+        [[ -n "$rel_path" ]] || continue
+        case "$rel_path" in
+            .prizmkit/*) continue ;;
+        esac
+        rm -f "$project_root/$rel_path" 2>/dev/null || true
+    done < "$untracked_tmp"
+    rm -f "$untracked_tmp"
+
+    dirty_status=$(git -C "$project_root" status --porcelain --untracked-files=all 2>/dev/null | grep -v '^?? .prizmkit/' || true)
+    [[ -z "$dirty_status" ]] || return 1
+
+    return 0
+}
+
+prizm_synthesize_failure_log() {
+    local failure_log="$1"
+    local feature_id="$2"
+    local session_id="$3"
+    local session_status="$4"
+    local exit_code="$5"
+    local stale_kill_marker="$6"
+    local progress_json="$7"
+    local checkpoint_file="$8"
+    local project_root="$9"
+    local base_ref="${10:-}"
+
+    [[ -n "$failure_log" ]] || return 0
+    [[ -f "$failure_log" ]] && return 0
+    mkdir -p "$(dirname "$failure_log")" || return 0
+
+    local progress_summary="Progress data unavailable."
+    if [[ -f "$progress_json" ]]; then
+        progress_summary=$(python3 - "$progress_json" <<'PY' 2>/dev/null || true
+import json
+import sys
+try:
+    with open(sys.argv[1], encoding="utf-8") as fh:
+        data = json.load(fh)
+except Exception as exc:
+    print(f"Progress parse error: {exc}")
+    raise SystemExit(0)
+fields = [
+    ("fatal_error_code", data.get("fatal_error_code")),
+    ("api_error_status", data.get("api_error_status")),
+    ("api_error_code", data.get("api_error_code")),
+    ("current_phase", data.get("current_phase")),
+    ("current_tool", data.get("current_tool")),
+    ("last_text_snippet", data.get("last_text_snippet")),
+    ("terminal_result_text", data.get("terminal_result_text")),
+]
+for key, value in fields:
+    if value not in (None, "", []):
+        text = str(value).replace("\n", " ")
+        print(f"- {key}: {text[:500]}")
+PY
+)
+        [[ -n "$progress_summary" ]] || progress_summary="Progress data contained no terminal fields."
+    fi
+
+    local stale_summary="No stale-kill marker."
+    if [[ -f "$stale_kill_marker" ]]; then
+        stale_summary="$(cat "$stale_kill_marker" 2>/dev/null || true)"
+    fi
+
+    local checkpoint_summary="No checkpoint file found."
+    if [[ -f "$checkpoint_file" ]]; then
+        checkpoint_summary=$(python3 - "$checkpoint_file" <<'PY' 2>/dev/null || true
+import json
+import sys
+try:
+    with open(sys.argv[1], encoding="utf-8") as fh:
+        data = json.load(fh)
+except Exception as exc:
+    print(f"Checkpoint parse error: {exc}")
+    raise SystemExit(0)
+steps = data.get("steps") or []
+complete = sum(1 for step in steps if isinstance(step, dict) and step.get("status") in ("completed", "skipped"))
+print(f"{complete}/{len(steps)} steps completed_or_skipped")
+for step in steps:
+    if isinstance(step, dict) and step.get("status") not in ("completed", "skipped"):
+        print(f"- incomplete: {step.get('id')} {step.get('skill')} = {step.get('status')}")
+PY
+)
+    fi
+
+    local latest_commit="unavailable"
+    local feature_commit="no"
+    if git -C "$project_root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+        latest_commit=$(git -C "$project_root" rev-parse --short HEAD 2>/dev/null || echo unavailable)
+        if prizm_find_feature_commit "$project_root" "$base_ref" "$feature_id" false >/dev/null 2>&1; then
+            feature_commit="yes"
+        fi
+    fi
+
+    local dirty_summary="unavailable"
+    dirty_summary=$(git -C "$project_root" status --short 2>/dev/null || true)
+    [[ -n "$dirty_summary" ]] || dirty_summary="clean"
+
+    cat > "$failure_log" <<EOF
+# Runtime-synthesized failure log
+
+## Session
+
+- feature_id: $feature_id
+- session_id: ${session_id:-unknown}
+- session_status: $session_status
+- exit_code: $exit_code
+
+## Stale kill marker
+
+\`\`\`json
+$stale_summary
+\`\`\`
+
+## Progress
+
+$progress_summary
+
+## Checkpoint
+
+$checkpoint_summary
+
+## Git state
+
+- feature_commit_exists: $feature_commit
+- latest_commit: $latest_commit
+
+\`\`\`text
+$dirty_summary
+\`\`\`
+
+## Recommended recovery action
+
+- If this is an AI runtime/provider error before checkpoint completion, retry the session with a fresh context.
+- If checkpoint completion and a feature commit both exist, inspect post-completion artifacts and finalize manually rather than rebuilding from scratch.
+- If the working tree is dirty, preserve or review those changes before any reset or merge.
+EOF
+}
+
 prizm_extract_update_new_status() {
     python3 -c "
 import json, sys

package/bundled/dev-pipeline/lib/heartbeat.sh

@@ -173,6 +173,42 @@ PY
                 fi
             fi
 
+            # Fatal provider/runtime errors are terminal; do not wait for the
+            # stale window when progress.json already proves the model cannot
+            # continue (for example context_too_large).
+            if [[ -f "$progress_json" ]]; then
+                local fatal_error_code=""
+                fatal_error_code=$(python3 - "$progress_json" <<'PY' 2>/dev/null || true
+import json
+import sys
+try:
+    with open(sys.argv[1], encoding="utf-8") as fh:
+        progress = json.load(fh)
+except Exception:
+    raise SystemExit(0)
+code = progress.get("fatal_error_code") or ""
+if code:
+    print(code)
+PY
+)
+                if [[ -n "$fatal_error_code" ]]; then
+                    echo -e "  ${RED}[HEARTBEAT]${NC} ${mins}m${secs}s | log: ${size_display} | ${RED}FATAL: ${fatal_error_code}${NC}"
+                    local _marker_dir
+                    _marker_dir="$(dirname "$session_log")"
+                    echo "{\"killed_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"reason\": \"${fatal_error_code}\", \"fatal_error_code\": \"${fatal_error_code}\", \"stale_seconds\": $stale_seconds, \"threshold\": $effective_stale_kill_threshold}" > "$_marker_dir/fatal-error.json" 2>/dev/null || true
+                    echo "{\"killed_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"reason\": \"${fatal_error_code}\", \"fatal_error_code\": \"${fatal_error_code}\", \"stale_seconds\": $stale_seconds, \"threshold\": $effective_stale_kill_threshold}" > "$_marker_dir/stale-kill.json" 2>/dev/null || true
+                    kill -TERM "$cli_pid" 2>/dev/null || true
+                    local fatal_kill_grace_seconds="${STALE_KILL_GRACE_SECONDS:-10}"
+                    if [[ $fatal_kill_grace_seconds -gt 0 ]]; then
+                        sleep "$fatal_kill_grace_seconds"
+                    fi
+                    if kill -0 "$cli_pid" 2>/dev/null; then
+                        kill -9 "$cli_pid" 2>/dev/null || true
+                    fi
+                    break
+                fi
+            fi
+
             # Stale-kill: auto-terminate process if no progress for too long.
             # Parent sessions can wait on spawned work; child transcript growth
             # counts as progress above, while silent waits still use the active