amsd-pipeline-shared 0.5.1 → 0.5.3

package/docs/gateway-baseline-2.0.80.md5

@@ -86,3 +86,5 @@ ac166207d8a1d93a4c50a88568ef6e5c  scripts/lib/handlers/write-missing-plans.js
 8a1bb4df2d1b6e7fd135f757423fb2f2  config/repo-artifacts.json
 91cec3c50040ebc9050c3d95f037bce2  config/run-modes.json
 ee4366721c38cbc8cd72ee0f779d22a8  scripts/lib/plan-scope.js
+aab7063cf68a9ecd54f6ef735adf895e  scripts/lib/engine-paths.sh
+1d0346da09c13150e511809034396949  scripts/lib/pipeline-commit.sh

package/docs/gateway-files.txt

@@ -32,6 +32,7 @@ scripts/lib/doctor/repair.js
 scripts/lib/doctor/restarter.js
 scripts/lib/doctor/state.js
 scripts/lib/ecosystem-registry.js
+scripts/lib/engine-paths.sh
 scripts/lib/engine-prompt.js
 scripts/lib/env-file.sh
 scripts/lib/evidence-windows.js
@@ -73,6 +74,7 @@ scripts/lib/model-ladder.sh
 scripts/lib/model-ladders.sh
 scripts/lib/orchestration-resume.sh
 scripts/lib/phase-exit.sh
+scripts/lib/pipeline-commit.sh
 scripts/lib/pipeline-tools.js
 scripts/lib/plan-hash.js
 scripts/lib/plan-scope.js

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/engine-paths.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# What the ENGINE owns — the bash half of src/config/enginePaths.ts.
+#
+# These directories hold epam-cli's own state: knowledge base, agent profiles, run logs,
+# code indexes, telemetry, contracts. None of it is client content, none of it is writer
+# output, and none of it may be committed into a client codeline.
+#
+# ONE definition, because this rule has already drifted three ways. lib/git-ops.sh carried
+# the full list, worktree-health-check.sh excluded only orchestrations/logs/* (so
+# orchestrations/agents/KB.md passed straight through), Step 9's auto-commit excluded
+# nothing, and lib/story-outputs.sh had its own separate regex covering only two of the
+# five. Live metrolinx 20260804T225443Z: the engine's KB.md was written into the upexpress
+# client repo and recorded as writer output in that lane's manifest.
+#
+# The real perimeter is the WRITE seam (src/config/enginePaths.ts, enforced in
+# WriteFileTool). Everything here is defence in depth.
+
+_ENGINE_OWNED_DIRS=( 'orchestrations' '.epam' '.codegraph' '.deepeval' '.contracts' )
+
+# engine_paths_filter — stdin: repo-relative paths. stdout: those that are NOT engine-owned.
+#
+# Matches whole path SEGMENTS, never a substring: `src/orchestrations-ui/App.tsx` is client
+# code and must survive, while `orchestrations/agents/KB.md` and
+# `packages/web/.epam/settings.json` must both be dropped.
+engine_paths_filter() {
+    local _line
+    local _owned_list
+    _owned_list=$(printf '%s\n' "${_ENGINE_OWNED_DIRS[@]}")
+    while IFS= read -r _line; do
+        [ -n "$_line" ] || continue
+        # -x -F: exact, literal, whole-segment. No pattern matching.
+        if printf '%s\n' "$_line" | tr '/' '\n' | grep -qxF "$_owned_list" 2>/dev/null; then
+            continue
+        fi
+        printf '%s\n' "$_line"
+    done
+}
+
+# engine_paths_pathspec — the same owned set, as git pathspec exclusions.
+#
+# engine_paths_filter above filters a LIST of paths. Some callers need the exclusion applied by
+# git itself, because their output is a patch rather than a list and there are no paths to filter.
+# Both read _ENGINE_OWNED_DIRS, so the set is defined once: restating it in pathspec form at a
+# call site is how this rule has already drifted three ways.
+#
+# Usage:  mapfile -t _ex < <(engine_paths_pathspec); git diff <ref> -- . "${_ex[@]}"
+engine_paths_pathspec() {
+    local _d
+    for _d in "${_ENGINE_OWNED_DIRS[@]}"; do
+        printf ':!%s/*\n:!*/%s/*\n' "$_d" "$_d"
+    done
+}

package/orchestrations/scripts/lib/git-ops.sh

@@ -370,22 +370,66 @@ git_add_client_outputs() {
     return $_rc
 }
 
-# _story_branch_carries_own_work <root> <branch> <story_id> — true when <branch> exists and this run recorded a commit of
-# <story_id> (LOG_DIR/story-changes.jsonl) that is in the branch's history; never on a resume sent back to an earlier stage.
+# story_branch_name <story_id> [suffix] — THE ONE RULE for a story's branch name, for every pipeline that works a story branch (B75, RS-10): the project's
+# prefix (EPAM_BRANCH_PREFIX), "AI-<story_id>", and a release line's suffix (the argument, else EPAM_BRANCH_SUFFIX; an explicit empty suffix means none).
+story_branch_name() { printf '%s' "${EPAM_BRANCH_PREFIX:-}AI-${1}${2-${EPAM_BRANCH_SUFFIX:-}}"; }
+
+# _story_local_base_ref <root> <baseline> — the baseline as the checkout already has it, WITHOUT the network: the tag, then origin's branch, then the local
+# branch. Empty when none resolves.
+_story_local_base_ref() {
+    local _root="$1" _b="${2#refs/tags/}" _ref
+    _b="${_b#refs/heads/}"
+    [ -n "$_b" ] || return 0
+    for _ref in "refs/tags/${_b}" "refs/remotes/origin/${_b}" "refs/heads/${_b}"; do
+        git -C "$_root" rev-parse -q --verify "${_ref}^{commit}" >/dev/null 2>&1 && { printf '%s' "$_ref"; return 0; }
+    done
+    return 0
+}
+
+# _story_branch_carries_own_work <root> <branch> <story_id> [baseline] — true when <branch> exists and carries the story's own work. B75 (RS-1): the evidence
+# is GIT — a commit of the story ("<story_id>: …", the convention every commit of the story follows) between the baseline and the branch — so it holds for
+# any pipeline, wherever it keeps its records; a client's own history using the same ticket prefix does not count (only commits since the baseline). The bash
+# pipeline's own record (LOG_DIR/story-changes.jsonl) is evidence too, as before. Never on a resume sent back to an earlier stage.
 _story_branch_carries_own_work() {
-    local _root="$1" _br="$2" _id="$3" _f="${LOG_DIR:-}/story-changes.jsonl" _sha
-    [ -n "$_id" ] && [ -f "$_f" ] || return 1
+    local _root="$1" _br="$2" _id="$3" _base_name="${4:-}" _f="${LOG_DIR:-}/story-changes.jsonl" _sha _base _re
+    [ -n "$_id" ] || return 1
     git -C "$_root" rev-parse -q --verify "refs/heads/${_br}" >/dev/null 2>&1 || return 1
     if [ -n "${EPAM_RESUME_FROM_STAGE:-}" ] && declare -F _stage_rank >/dev/null 2>&1 \
         && [ "$(_stage_rank "$EPAM_RESUME_FROM_STAGE")" -lt "$(_stage_rank pre-writer)" ]; then
         return 1
     fi
+    _base=$(_story_local_base_ref "$_root" "$_base_name")
+    if [ -n "$_base" ]; then
+        _re=$(printf '%s' "$_id" | sed 's/[][\.*^$/]/\\&/g')
+        [ -n "$(git -C "$_root" log -1 --format=%h --grep="^${_re}:" "${_base}..refs/heads/${_br}" 2>/dev/null)" ] && return 0
+    fi
+    [ -f "$_f" ] || return 1
     while IFS= read -r _sha; do
         [ -n "$_sha" ] && git -C "$_root" merge-base --is-ancestor "$_sha" "refs/heads/${_br}" 2>/dev/null && return 0
     done < <(jq -r --arg id "$_id" 'select(.storyId == $id) | .sha // empty' "$_f" 2>/dev/null)
     return 1
 }
 
+# _preserve_uncommitted <root> <story_id> — B75 (RS-3): before ANY reset, whatever the working tree holds that no commit holds (tracked edits and untracked
+# files, the pipeline's own .epam/ aside) is committed to a rescue ref, epam-rescue/<story>-wip-<sha>, without touching the branch, the index or the tree.
+# Nothing to preserve: nothing is done. Fails (non-zero) when it cannot — the caller then refuses to reset, as it does when a commit cannot be pinned.
+_preserve_uncommitted() {
+    local _root="$1" _id="$2" _idx _tree _head _commit _ref
+    [ -n "$(git -C "$_root" status --porcelain --untracked-files=all -- . ':(exclude).epam' 2>/dev/null)" ] || return 0
+    _head=$(git -C "$_root" rev-parse -q --verify HEAD 2>/dev/null) || _head=""
+    _idx=$(mktemp -u "${TMPDIR:-/tmp}/epam-wip-index-XXXXXX") || return 1
+    GIT_INDEX_FILE="$_idx" git -C "$_root" add -A -- . ':(exclude).epam' >/dev/null 2>&1 || { rm -f "$_idx"; return 1; }
+    _tree=$(GIT_INDEX_FILE="$_idx" git -C "$_root" write-tree 2>/dev/null) || { rm -f "$_idx"; return 1; }
+    rm -f "$_idx"
+    _commit=$(git -C "$_root" -c user.name="${GIT_COMMITTER_NAME:-epam-rescue}" -c user.email="${GIT_COMMITTER_EMAIL:-epam-rescue@local}" \
+        commit-tree "$_tree" ${_head:+-p "$_head"} -m "epam-rescue: uncommitted work of ${_id}" 2>/dev/null) || return 1
+    _ref="epam-rescue/${_id}-wip-$(git -C "$_root" rev-parse --short "$_commit" 2>/dev/null || echo unknown)"
+    git -C "$_root" branch -f "$_ref" "$_commit" --quiet 2>/dev/null || return 1
+    warning "  [story-branch] ${_id}: uncommitted work preserved on branch '${_ref}'"
+    warning "  [story-branch]   recover with: git -C '${_root}' checkout ${_ref} -- <path>"
+    return 0   # the work IS preserved; a logger that cannot write (it returns its own status) must not turn that into a failure
+}
+
 ensure_story_branch() {
     local codeline_root="$1"
     local story_id="$2"
@@ -405,15 +449,16 @@ ensure_story_branch() {
     # constraint, so the default preserves today's plain "AI-<story_id>" shape.
     # ONE STORY BRANCH PER RELEASE LINE (lib/release-lines.sh): a line other than the codeline's own carries a
     # suffix, so the codeline's own story branch is never reset by another line's work.
-    local _branch="${EPAM_BRANCH_PREFIX:-}AI-${story_id}${EPAM_BRANCH_SUFFIX:-}"
+    local _branch; _branch=$(story_branch_name "$story_id")
 
     # A STORY THAT ALREADY HAS ITS OWN WORK ON ITS BRANCH CONTINUES FROM IT (AMSD-2974 run 9, 2026-10-14). A self-heal retry
     # sets the story pending again and comes back here; the hard reset below moved the 7.x line's branch to v7.11.0 twice
     # in one run, discarding the approved full port (c25e819), and the writer re-wrote it from nothing — paid twice, weaker.
     # This run's own record of the story's commits (story-changes.jsonl) is what says the work is its own: a fresh run has
     # none, and a resume sent back to an earlier stage (EPAM_RESUME_FROM_STAGE) starts over as asked.
-    if _story_branch_carries_own_work "$codeline_root" "$_branch" "$story_id"; then
+    if _story_branch_carries_own_work "$codeline_root" "$_branch" "$story_id" "$baseline_branch"; then
         if git -C "$codeline_root" checkout -q "$_branch" 2>/dev/null; then
+            _preserve_uncommitted "$codeline_root" "$story_id" || { error "  [story-branch] $story_id: uncommitted work could not be preserved — refusing to reset it away"; return 1; }
             git -C "$codeline_root" reset --hard -q "$_branch" 2>/dev/null || true
             git -C "$codeline_root" clean -fd -e .epam -q 2>/dev/null || true
             _provision_epam_plugin_config "$codeline_root"
@@ -509,6 +554,8 @@ ensure_story_branch() {
         fi
     done
 
+    _preserve_uncommitted "$codeline_root" "$story_id" || { error "  [story-branch] $story_id: uncommitted work could not be preserved — refusing to reset it away"; return 1; }
+
     if git -C "$codeline_root" checkout -B "$_branch" "$_base_ref" --quiet 2>/dev/null; then
         # checkout -B only forces tracked files that DIFFER between the old
         # branch tip and the new start-point — a tracked file whose content

package/orchestrations/scripts/lib/pipeline-commit.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# pipeline_commit_flags — the flags every commit the PIPELINE makes passes to `git commit`, one per line.
+#
+# A codeline's hooks are written for its team's own checkout and machine. Operator decisions,
+# 2026-10-05 (AMSD-2974): the pipeline's commits skip them — first inside worktrees, then in the
+# checkout too. Proven on a copy of next.gotransit.com: its pre-commit hook (husky + lint-staged)
+# type-checks the WHOLE project, which fails on the untouched checkout with 6 errors because the
+# team's node_modules is older than its own develop branch expects (it needs an `npm install`, which
+# the pipeline may not run) — so the hook refused every pipeline commit there, whatever it held, and
+# the reproducing test of a correct fix was never committed. In worktrees the same hook also refused
+# the branch name and sourced a helper git does not track.
+#
+# What the hook checks is still checked by the pipeline: the story's own verification, Step 19/20's
+# type check judged against the phase baseline, the lint gate, review and the QA gates. The Step 17
+# merge onto the story branch still runs the codeline's commit-msg hook (git merge has no --no-verify
+# here), and its message is written to pass it.
+pipeline_commit_flags() {
+    echo "--no-verify"
+}

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.1",
+  "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": {