amsd-pipeline-shared 0.5.2 → 0.5.3

package/orchestrations/scripts/lib/codeline-lanes.sh

@@ -603,25 +603,36 @@ archive_prior_lane_state() {
     local _lanes="${LOG_DIR:-}/lanes"
     [ -d "$_lanes" ] || return 0
     local _run="${EPAM_RESUME_RUN:-${ORCH_RUN_ID:-}}"
-    [ -n "$_run" ] || return 0
+    if [ -z "$_run" ]; then
+        warning "[orch] the earlier lane state is not archived: there is no run id (EPAM_RESUME_RUN / ORCH_RUN_ID) — it stays where it is" || true
+        return 0
+    fi
     local _marker=""
     if [ -n "${EPAM_PROJECT_CONFIG_DIR:-}" ]; then
         _marker="${EPAM_PROJECT_CONFIG_DIR}/runs/${_run}/lane-state-archived"
         [ -f "$_marker" ] && return 0
     fi
-    # The run's start is in its id (YYYYMMDDTHHMMSSZ, UTC).
-    local _start
+    # B80 (RS-7): the run's start is its id when the id is a timestamp (as before); for ANY other id (every Claude workflows id is LIVE-…) it is NOW — the
+    # first time this function runs for the run — which is only safe with the marker that stops a resume from archiving the run's own state
+    local _start _how=""
     _start=$(printf '%s' "$_run" | sed -nE 's/^([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2})([0-9]{2})([0-9]{2})Z?$/\1-\2-\3 \4:\5:\6 UTC/p')
-    [ -n "$_start" ] || return 0
+    if [ -z "$_start" ]; then
+        if [ -z "$_marker" ]; then
+            warning "[orch] the earlier lane state is not archived: run id '${_run}' carries no start time and there is no EPAM_PROJECT_CONFIG_DIR to record that it was archived (a resume would archive the run's own state)" || true
+            return 0
+        fi
+        _start=$(date -u '+%Y-%m-%d %H:%M:%S.%N UTC'); _how=" (run '${_run}' carries no start time: it starts now)"
+    fi
     local _ref; _ref=$(mktemp "${TMPDIR:-/tmp}/run-start-XXXXXX") || return 0
     touch -d "$_start" "$_ref" 2>/dev/null || { rm -f "$_ref"; return 0; }
-    local _dest="${LOG_DIR}/archive/lanes-before-${_run}" _n=0 _f _rel
+    local _dest="${LOG_DIR}/archive/lanes-before-${_run}" _n=0 _failed=0 _f _rel
     while IFS= read -r -d '' _f; do
         _rel="${_f#"$_lanes"/}"
-        mkdir -p "$_dest/$(dirname "$_rel")" 2>/dev/null && mv "$_f" "$_dest/$_rel" 2>/dev/null && _n=$((_n + 1))
+        if mkdir -p "$_dest/$(dirname "$_rel")" 2>/dev/null && mv "$_f" "$_dest/$_rel" 2>/dev/null; then _n=$((_n + 1)); else _failed=$((_failed + 1)); fi
     done < <(find "$_lanes" -type f ! -newer "$_ref" -print0 2>/dev/null)
     rm -f "$_ref"
-    [ "$_n" -gt 0 ] && log "[orch] archived ${_n} file(s) of earlier runs' lane state → ${_dest} (this run starts with none of it)"
+    [ "$_n" -gt 0 ] && { log "[orch] archived ${_n} file(s) of earlier runs' lane state → ${_dest} (this run starts with none of it)${_how}" || true; }
+    [ "$_failed" -gt 0 ] && { warning "[orch] ${_failed} file(s) of earlier runs' lane state could not be archived — they stay in ${_lanes}" || true; }
     [ -n "$_marker" ] && { mkdir -p "${_marker%/*}" 2>/dev/null; date -u +%Y-%m-%dT%H:%M:%SZ > "$_marker"; }
     return 0
 }

package/orchestrations/scripts/lib/qa-gate-evidence.sh

@@ -223,13 +223,32 @@ qa_phase_baseline_sha() {
 # phase-baseline-sha.txt: every pre-existing failure was charged to its writer, eight attempts in a
 # row (£0 multi-lane run, 2026-10-04). Nothing resolvable is said out loud, never written as a guess.
 qa_record_phase_baseline() {
-    local _root="${1:-}" _branch="${2:-}" _log_dir="${3:-${LOG_DIR:-}}" _sha
+    local _root="${1:-}" _branch="${2:-}" _log_dir="${3:-${LOG_DIR:-}}" _sha _have _key
     [ -n "$_root" ] && [ -n "$_log_dir" ] || return 1
+    local _bf="$_log_dir/phase-baseline-sha.txt" _kf="$_log_dir/phase-baseline-key.txt"
+    # B77 (RS-4, = B73): THE BASELINE IS RECORDED ONCE for a run and phase. A resume starts the phase again; the baseline it had must not move to wherever HEAD
+    # is by then (that made "committed since the baseline" empty). A new phase, or a new run in the same log folder, has a different key and records its own.
+    _key="${PHASE:-main}|${ORCH_RUN_ID:-}"
+    if [ -f "$_bf" ] && [ -f "$_kf" ] && [ "$(cat "$_kf" 2>/dev/null)" = "$_key" ]; then
+        _have=$(tr -d '[:space:]' < "$_bf" 2>/dev/null)
+        if [ -n "$_have" ] && git -C "$_root" cat-file -e "${_have}^{commit}" 2>/dev/null; then
+            printf '%s' "$_have"
+            return 0
+        fi
+        warning "[orch] the recorded phase baseline (${_have:-empty}) is not a commit of $_root — recording it again" || true
+    fi
     _sha="$(qa_phase_baseline_sha "$_root" "$_branch" 2>/dev/null || echo "")"
     if [ -z "$_sha" ]; then
-        warning "[orch] could not resolve a baseline commit in $_root — every diff-based gate will compare against nothing"
+        warning "[orch] could not resolve a baseline commit in $_root — every diff-based gate will compare against nothing" || true
         return 1
     fi
-    printf '%s\n' "$_sha" > "$_log_dir/phase-baseline-sha.txt"
+    # the fallback is HEAD (the codeline has no such baseline branch — cx-shared has no develop): fine at the FIRST call, and said, because it is not a fork point
+    if [ -n "$_branch" ] && ! git -C "$_root" rev-parse --verify --quiet "origin/${_branch}^{commit}" >/dev/null 2>&1 \
+        && ! git -C "$_root" rev-parse --verify --quiet "${_branch}^{commit}" >/dev/null 2>&1; then
+        warning "[orch] baseline '${_branch}' did not resolve in $_root — the phase baseline is HEAD (${_sha:0:9}) as of now; it is recorded once and not moved" || true
+    fi
+    printf '%s\n' "$_sha" > "$_bf"
+    printf '%s\n' "$_key" > "$_kf"
     printf '%s' "$_sha"
+    return 0
 }

package/orchestrations/scripts/lib/release-lines.sh

@@ -32,19 +32,35 @@ _run_release_lines() {
 
 # _return_from_release_lines <codeline-root> [name] — back on the branch the record names; the record is removed.
 _return_from_release_lines() {
-    local _gd _home
+    local _gd _home _cur
     _gd=$(git -C "$1" rev-parse --absolute-git-dir 2>/dev/null) || return 0
     [ -f "$_gd/epam-release-home" ] || return 0
     _home=$(cat "$_gd/epam-release-home")
-    if [ -n "$_home" ] && [ "$(git -C "$1" symbolic-ref -q --short HEAD 2>/dev/null)" != "$_home" ]; then
+    _cur=$(git -C "$1" symbolic-ref -q --short HEAD 2>/dev/null)
+    if [ -n "$_home" ] && [ "$_cur" != "$_home" ]; then
         if git -C "$1" checkout -q "$_home" 2>/dev/null; then
-            log "[orch] Codeline '${2:-$1}': release lines done — back on ${_home}"
+            log "[orch] Codeline '${2:-$1}': release lines done — back on ${_home}" || true
         else
-            warning "[orch] Codeline '${2:-$1}': could not return to ${_home} after its release lines"
-            return 0
+            # B81 (RS-8): the usual reason is a dirty tree (a killed session). Whatever it holds is PRESERVED first (a rescue ref, git-ops.sh), then the copy is
+            # forced home; if it still cannot go home, that is an error (rc 1, the marker kept) — never a warning that leaves the copy on the line branch.
+            if [ -n "$(git -C "$1" status --porcelain --untracked-files=all 2>/dev/null)" ]; then
+                if declare -F _preserve_uncommitted >/dev/null 2>&1; then
+                    _preserve_uncommitted "$1" "${_cur//\//-}" || { error "[orch] Codeline '${2:-$1}': could not return to ${_home} after its release lines — its uncommitted work could not be preserved, so nothing was forced"; return 1; }
+                else
+                    error "[orch] Codeline '${2:-$1}': could not return to ${_home} after its release lines — the tree is dirty and this install cannot preserve it (needs amsd-pipeline-shared >= 0.5.2)"
+                    return 1
+                fi
+            fi
+            if git -C "$1" checkout -q -f "$_home" 2>/dev/null; then
+                warning "[orch] Codeline '${2:-$1}': release lines done — back on ${_home} (its tree was not clean; the work it held is preserved)" || true
+            else
+                error "[orch] Codeline '${2:-$1}': could not return to ${_home} after its release lines (it is still on ${_cur:-a detached HEAD}; any uncommitted work is preserved on a rescue ref)"
+                return 1
+            fi
         fi
     fi
     rm -f "$_gd/epam-release-home"
+    return 0
 }
 
 # _return_codelines_from_release_lines <prd> — every codeline of the PRD a line pass left is put back before the

package/orchestrations/scripts/lib/story-outputs.sh

@@ -220,12 +220,16 @@ story_outputs_tests_for() {
 # the writer skips it and the review judges the committed change. A newer rejection leaves it for the writer.
 story_resume_completed_by_commit() {
     local project_root="$1" log_dir="$2" prd="$3"
-    [ -n "$project_root" ] && [ -e "$project_root/.git" ] && [ -f "$prd" ] || return 0
-    [ -f "$log_dir/phase-baseline-sha.txt" ] || return 0
+    [ -n "$project_root" ] && [ -e "$project_root/.git" ] && [ -f "$prd" ] || { echo "[resume] no story is completed by its commit: ${project_root:-no project root} is not a repository, or there is no PRD at ${prd:-none}" >&2; return 0; }
+    # B78 (RS-5): a precondition it cannot meet is SAID — the story is then left exactly as it was (the writer is invoked), and the operator can see why
+    [ -f "$log_dir/phase-baseline-sha.txt" ] || { echo "[resume] no phase baseline is recorded in ${log_dir} — cannot tell which commits are this run's; no story is completed by its commit" >&2; return 0; }
     local _base; _base=$(tr -d '[:space:]' < "$log_dir/phase-baseline-sha.txt" 2>/dev/null)
-    [ -n "$_base" ] && git -C "$project_root" rev-parse --verify --quiet "$_base" >/dev/null 2>&1 || return 0
+    if [ -z "$_base" ] || ! git -C "$project_root" rev-parse --verify --quiet "${_base}^{commit}" >/dev/null 2>&1; then
+        echo "[resume] the recorded phase baseline (${_base:-empty}) is not a commit of ${project_root} — no story is completed by its commit" >&2
+        return 0
+    fi
     local _id _ct _fb _fbt
-    for _id in $(jq -r '.stories[]? | select(.completed != true) | .id' "$prd" 2>/dev/null); do
+    for _id in $(jq -r '.stories[]? | select(.completed != true and .status != "deprecated") | .id' "$prd" 2>/dev/null); do
         _ct=$(git -C "$project_root" log "${_base}..HEAD" --grep="^${_id}:" -1 --format=%ct 2>/dev/null)
         [ -n "$_ct" ] || continue
         _fb="$log_dir/review-feedback-${_id}.json"
@@ -234,9 +238,9 @@ story_resume_completed_by_commit() {
             [ "${_fbt:-0}" -gt "$_ct" ] && continue
         fi
         local _tmp; _tmp=$(mktemp)
-        jq --arg id "$_id" '(.stories[] | select(.id == $id)) |= (. + {completed: true})' "$prd" > "$_tmp" \
+        jq --arg id "$_id" '(.stories[] | select(.id == $id)) |= (. + {completed: true, status: "completed"})' "$prd" > "$_tmp" \
             && mv "$_tmp" "$prd" || rm -f "$_tmp"
-        echo "[resume] ${_id}: its work is committed in this run ($(git -C "$project_root" log "${_base}..HEAD" --grep="^${_id}:" -1 --format=%h 2>/dev/null)) and no review rejection is newer — the writer is not invoked again; the review judges the committed change"
+        echo "[resume] ${_id}: its work is committed in this run ($(git -C "$project_root" log "${_base}..HEAD" --grep="^${_id}:" -1 --format=%h 2>/dev/null)) and no review rejection is newer — the writer is not invoked again; the review judges the committed change" >&2
     done
     return 0
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amsd-pipeline-shared",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "The AMSD pipeline's shared components, one source for the bash pipeline and its Claude workflows: the model-call gateway (llm-handler.sh — retry, ladder, self-heal, cost) and the libraries it runs.",
   "license": "UNLICENSED",
   "bin": {