amsd-pipeline-shared 0.5.17 → 0.5.20

package/orchestrations/prompts/templates/detective-overall-plan.json

@@ -12,7 +12,8 @@
     "",
     "2026-10-06, real-model round: a consumer's change read \"none (dependency bump only; review own toast messages)\", and that lane then changed its locale file.",
     "2026-10-06: a shared codeline is worked once per release line the plan names (lib/release-lines.sh); the plan says which line the codeline's own base is on, so no version arithmetic is written into the engine.",
-    "v5 (operator, 2026-10-22: \"If the plan agent is not given proper instructions to provide package updates then there is your rc\"): a consumer's plan names the update that brings in the provider's release, and any change of its own its criteria need — run 11's plan gave gotransit 'no change', it never received cx-shared 8.12.0, and its Writer looped."
+    "v5 (operator, 2026-10-22: \"If the plan agent is not given proper instructions to provide package updates then there is your rc\"): a consumer's plan names the update that brings in the provider's release, and any change of its own its criteria need — run 11's plan gave gotransit 'no change', it never received cx-shared 8.12.0, and its Writer looped.",
+    "v6 (operator, 2026-10-22): the plan agent is told the story's existing release lines — run 11's re-plan named the approved '7.x' line '7.x backport', and a second port on a new branch would have been written."
   ],
   "description": "Composed into every code-graph detective's prescription: before naming fix sites, write the one plan the whole story is worked from — every codeline's part, every consumer's blast radius, every release line.",
   "id": "detective-overall-plan",
@@ -20,8 +21,12 @@
     "code-graph-detective"
   ],
   "placeholders": [
+    "__EXISTING_RELEASE_LINES__",
     "__PLAN_CODELINES__"
   ],
-  "version": 5,
-  "body": "\nTHE OVERALL PLAN. This story is worked in the codelines below, and every one of them is worked from the plan you write here — it is the one plan for the whole story, not this codeline's notes. You can read each codeline at the location given.\n__PLAN_CODELINES__\nEstablish, by reading the code, not by assuming:\n1. EACH CODELINE'S PART: what it must change in its own code, or that it changes nothing — and the order the codelines must be worked in, when one needs another's change first.\n2. FOR EVERY PACKAGE ONE OF THESE CODELINES PROVIDES AND ANOTHER CONSUMES: the BLAST RADIUS — in each consumer, the files and calls that reach the code being changed, read in that consumer; and whether the change alters anything those calls depend on.\n3. THE RELEASE LINES the change must ship on, so that every consumer receives it through the range it ALREADY declares. A consumer's declared range is never changed by this story. Say how each consumer receives its release: within its declared range (an update the range already allows) — never by installing the latest release, which can move the range; read what a consumer's own scripts do before naming one. Each line is worked on its own branch from its base; say for each whether the provider codeline's own base is already on it (onCodelineBase). One line per distinct line the consumers' ranges require; for each, the base it is cut from (the newest existing release on that line, from the release facts above) and the version it ships as.\n\nWrite the plan as ONE JSON object between these tags, before your fix-site answer:\n<OVERALL_PLAN>\n{\"codelines\":[{\"codeline\":\"<name>\",\"part\":\"<what it changes in its own code, or that it changes nothing and how it receives the change>\",\"order\":1}],\"packages\":[{\"package\":\"<name, as its manifest declares it>\",\"providedBy\":\"<codeline>\",\"releaseLines\":[{\"line\":\"<the release line>\",\"base\":\"<the existing release it is cut from>\",\"version\":\"<the version it ships as>\",\"onCodelineBase\":<true if the provider codeline's own base is on this line — even when newer releases were cut on it since; the change merges forward onto it. false only for a different, older line>,\"carries\":\"<what this line carries: for a line off the codeline's own base, the change made on the codeline's own line, ported in full: the story's whole change on the codeline's own line — what is already there and what this plan adds — every part of it, adapted where this line's code differs>\"}],\"consumers\":[{\"codeline\":\"<codeline>\",\"declaredRange\":\"<as its manifest declares it>\",\"receivesVia\":\"<the version, from the release lines above>\",\"usage\":[\"<file>: <how it reaches the code being changed>\"],\"update\":\"<the update that brings receivesVia into this consumer within its declared range — the lock file, or what its own update script does (read its scripts)>\",\"change\":\"<exactly none, or the change this consumer makes in its OWN code for this story — for example passing an option the provider adds — never none plus something to do or review>\"}]}]}\n</OVERALL_PLAN>\nRECEIVING THE PROVIDER'S RELEASE IS PART OF EVERY CONSUMER'S WORK in this story: a consumer that does not take the new version never gets the change. Name, for each consumer, the update that brings it in within the range it already declares (`update`) — its declared range itself is not changed. Where the consumer's own criteria need more than the new version — an option the provider adds, its own wording, its own call sites — that is its `change`. A consumer's `change` is code; a note that a file needs no edit is never written into that file.\nYour fix sites, after the plan, are files of THIS codeline only. Another codeline's files belong in the plan — its part and its usage — never among your fix sites.\nA story worked in ONE codeline writes the same plan: one entry under codelines, and packages empty unless that codeline provides one another codeline consumes.\n"
+  "version": 6,
+  "body": "\nTHE OVERALL PLAN. This story is worked in the codelines below, and every one of them is worked from the plan you write here — it is the one plan for the whole story, not this codeline's notes. You can read each codeline at the location given.\n__PLAN_CODELINES__\nEstablish, by reading the code, not by assuming:\n1. EACH CODELINE'S PART: what it must change in its own code, or that it changes nothing — and the order the codelines must be worked in, when one needs another's change first.\n2. FOR EVERY PACKAGE ONE OF THESE CODELINES PROVIDES AND ANOTHER CONSUMES: the BLAST RADIUS — in each consumer, the files and calls that reach the code being changed, read in that consumer; and whether the change alters anything those calls depend on.\n3. THE RELEASE LINES the change must ship on, so that every consumer receives it through the range it ALREADY declares. THE LINES THIS STORY ALREADY HAS, with the work on them — reviewed, perhaps approved: __EXISTING_RELEASE_LINES__ A line you need on the same base as one of these IS that line: give it exactly that name, never a second line for the same base. A consumer's declared range is never changed by this story. Say how each consumer receives its release: within its declared range (an update the range already allows) — never by installing the latest release, which can move the range; read what a consumer's own scripts do before naming one. Each line is worked on its own branch from its base; say for each whether the provider codeline's own base is already on it (onCodelineBase). One line per distinct line the consumers' ranges require; for each, the base it is cut from (the newest existing release on that line, from the release facts above) and the version it ships as.\n\nWrite the plan as ONE JSON object between these tags, before your fix-site answer:\n<OVERALL_PLAN>\n{\"codelines\":[{\"codeline\":\"<name>\",\"part\":\"<what it changes in its own code, or that it changes nothing and how it receives the change>\",\"order\":1}],\"packages\":[{\"package\":\"<name, as its manifest declares it>\",\"providedBy\":\"<codeline>\",\"releaseLines\":[{\"line\":\"<the release line>\",\"base\":\"<the existing release it is cut from>\",\"version\":\"<the version it ships as>\",\"onCodelineBase\":<true if the provider codeline's own base is on this line — even when newer releases were cut on it since; the change merges forward onto it. false only for a different, older line>,\"carries\":\"<what this line carries: for a line off the codeline's own base, the change made on the codeline's own line, ported in full: the story's whole change on the codeline's own line — what is already there and what this plan adds — every part of it, adapted where this line's code differs>\"}],\"consumers\":[{\"codeline\":\"<codeline>\",\"declaredRange\":\"<as its manifest declares it>\",\"receivesVia\":\"<the version, from the release lines above>\",\"usage\":[\"<file>: <how it reaches the code being changed>\"],\"update\":\"<the update that brings receivesVia into this consumer within its declared range — the lock file, or what its own update script does (read its scripts)>\",\"change\":\"<exactly none, or the change this consumer makes in its OWN code for this story — for example passing an option the provider adds — never none plus something to do or review>\"}]}]}\n</OVERALL_PLAN>\nRECEIVING THE PROVIDER'S RELEASE IS PART OF EVERY CONSUMER'S WORK in this story: a consumer that does not take the new version never gets the change. Name, for each consumer, the update that brings it in within the range it already declares (`update`) — its declared range itself is not changed. Where the consumer's own criteria need more than the new version — an option the provider adds, its own wording, its own call sites — that is its `change`. A consumer's `change` is code; a note that a file needs no edit is never written into that file.\nYour fix sites, after the plan, are files of THIS codeline only. Another codeline's files belong in the plan — its part and its usage — never among your fix sites.\nA story worked in ONE codeline writes the same plan: one entry under codelines, and packages empty unless that codeline provides one another codeline consumes.\n",
+  "mayBeEmpty": [
+    "__EXISTING_RELEASE_LINES__"
+  ]
 }

package/orchestrations/prompts/templates/spec-review-criteria.json

@@ -7,7 +7,8 @@
     "split check are both moot on a brownfield ticket, whose AC array is empty by policy -- the",
     "observable checks live in verificationCriteria. Asked anyway, the reviewer reported the",
     "empty array as a hallucination or a persistence failure and lowered qualityScore for it,",
-    "which is a gate blocking on a policy it was not told about."
+    "which is a gate blocking on a policy it was not told about.",
+    "v2 (operator, 2026-10-22): plan and criteria are reconciled before pause 2 — run 11's gotransit plan said 'no change' while its own criterion asked for a toast longer than 5 s; nothing checked one against the other."
   ],
   "description": "The criteria a spec-review coordinator judges a story's collaborative spec work against.",
   "id": "spec-review-criteria",
@@ -15,9 +16,9 @@
     "spec-coordinator"
   ],
   "placeholders": [],
-  "version": 1,
+  "version": 2,
   "bodies": {
-    "brownfield": "For each story, evaluate the quality of the collaborative spec work:\n1. Did both agents add meaningful, non-overlapping value?\n2. Flag any story needing human review.\n3. PLAN ALIGNMENT — where planAlignmentEvidence is present, it tells you what the\n   code-graph-detective SAID it would investigate (detectivePlan) and a deterministic,\n   cheap signal (aligned: true/false) for whether the final fixSiteAnalysis shares any\n   named symbol/file with that plan. This signal is NOT your verdict — it is evidence, the\n   same as MANIFEST EVIDENCE below. A plan can legitimately turn out wrong once real\n   exploration starts. Read detectivePlan and fixSiteAnalysis yourself and judge: did the\n   detective explain WHY it moved from its plan to its final answer (a stated pivot,\n   reasoning that connects the two), or did the answer just change with no explanation?\n   The latter is a real defect (a fix has shipped that shared no term with the detective's\n   own stated plan, with no explanation, more than once on the same ticket) — set\n   planAlignment to justified_deviation when the detective justifies its pivot, or\n   unexplained_mismatch when it does not, and say why in reviewNotes. aligned:true needs\n   no action.\n\n(Brownfield tickets never split and their acceptance criteria are immutable —\ndo not evaluate split quality or AC completeness; there is nothing there for\neither agent to have changed.\n\nEXPECTED, NOT A DEFECT: an agent's notes may describe acceptance criteria it\nauthored while the story's acceptanceCriteria array is empty, and report\nacceptanceChanged=false. That is this pipeline REDACTING them on purpose: on a\nbrownfield ticket the ACs are the ticket's own, and a thin ticket legitimately\nhas none. The observable checks live in verificationCriteria — judge THOSE.\nDo not report the mismatch as a hallucination, a persistence failure or a\nmetadata inconsistency, and do not lower qualityScore for it. An empty\nacceptanceCriteria array on a brownfield story is correct by policy.)",
-    "greenfield": "For each story, evaluate the quality of the collaborative spec work:\n1. Did both agents add meaningful, non-overlapping value?\n2. Are the acceptance criteria complete, testable, and non-overlapping?\n3. Are story splits logical and properly scoped?\n4. Flag any story needing human review."
+    "brownfield": "For each story, evaluate the quality of the collaborative spec work:\n1. Did both agents add meaningful, non-overlapping value?\n2. Flag any story needing human review.\n3. PLAN ALIGNMENT — where planAlignmentEvidence is present, it tells you what the\n   code-graph-detective SAID it would investigate (detectivePlan) and a deterministic,\n   cheap signal (aligned: true/false) for whether the final fixSiteAnalysis shares any\n   named symbol/file with that plan. This signal is NOT your verdict — it is evidence, the\n   same as MANIFEST EVIDENCE below. A plan can legitimately turn out wrong once real\n   exploration starts. Read detectivePlan and fixSiteAnalysis yourself and judge: did the\n   detective explain WHY it moved from its plan to its final answer (a stated pivot,\n   reasoning that connects the two), or did the answer just change with no explanation?\n   The latter is a real defect (a fix has shipped that shared no term with the detective's\n   own stated plan, with no explanation, more than once on the same ticket) — set\n   planAlignment to justified_deviation when the detective justifies its pivot, or\n   unexplained_mismatch when it does not, and say why in reviewNotes. aligned:true needs\n   no action.\n\n(Brownfield tickets never split and their acceptance criteria are immutable —\ndo not evaluate split quality or AC completeness; there is nothing there for\neither agent to have changed.\n\nEXPECTED, NOT A DEFECT: an agent's notes may describe acceptance criteria it\nauthored while the story's acceptanceCriteria array is empty, and report\nacceptanceChanged=false. That is this pipeline REDACTING them on purpose: on a\nbrownfield ticket the ACs are the ticket's own, and a thin ticket legitimately\nhas none. The observable checks live in verificationCriteria — judge THOSE.\nDo not report the mismatch as a hallucination, a persistence failure or a\nmetadata inconsistency, and do not lower qualityScore for it. An empty\nacceptanceCriteria array on a brownfield story is correct by policy.)\n\nEVERY VERIFICATION CRITERION HAS A PLANNED CHANGE THAT MAKES IT TRUE. For each verification criterion, name what in the plan makes it observable in this codeline: a fix site whose changeRequired is true, this codeline's own change or update in overallPlanForThisCodeline, or — where this codeline consumes another's package — the provider's change it receives, which its Writer is tested against through the provider's build the pipeline places in this codeline. A criterion nothing planned makes true cannot be met by the writer: flag it as criterion-without-planned-change, severity blocking, with a why that quotes the criterion and names the change that would meet it, or says that the criterion asks for something this story does not change and should be dropped. Do not approve a spec with such a criterion.\n",
+    "greenfield": "For each story, evaluate the quality of the collaborative spec work:\n1. Did both agents add meaningful, non-overlapping value?\n2. Are the acceptance criteria complete, testable, and non-overlapping?\n3. Are story splits logical and properly scoped?\n4. Flag any story needing human review.\n\nEVERY VERIFICATION CRITERION HAS A PLANNED CHANGE THAT MAKES IT TRUE. For each verification criterion, name what in the plan makes it observable in this codeline: a fix site whose changeRequired is true, this codeline's own change or update in overallPlanForThisCodeline, or — where this codeline consumes another's package — the provider's change it receives, which its Writer is tested against through the provider's build the pipeline places in this codeline. A criterion nothing planned makes true cannot be met by the writer: flag it as criterion-without-planned-change, severity blocking, with a why that quotes the criterion and names the change that would meet it, or says that the criterion asks for something this story does not change and should be dropped. Do not approve a spec with such a criterion.\n"
   }
 }

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

@@ -340,6 +340,40 @@ link_sibling_builds() {
     return 0
 }
 
+# sibling_link_in_place <root> <vendor-dir> / sibling_unlink_in_place <root> <vendor-dir> — A CONSUMER'S WRITER RUNS AGAINST ITS
+# PROVIDER'S CHANGE (operator, 2026-10-22; backlog B92). The bash pipeline runs a story in a lane worktree whose vendor directory holds
+# the provider's fresh build (link_sibling_builds) while the codeline keeps its installed release for the baseline. A pipeline that
+# works the story in the codeline itself (the Claude workflows) gets the same: the installed release is set aside as
+# <vendor>/<scope>/.<name>.epam-installed and the package link_sibling_builds placed takes its place — for the Writer, after the
+# baseline was taken; unlink puts the installed release back (and is safe to call when nothing is linked).
+sibling_link_in_place() {
+    local _root="$1" _vd="$2" _tmp _p _rel _at _aside
+    [ -n "$_root" ] && [ -n "$_vd" ] && [ -d "$_root/$_vd" ] || return 0
+    sibling_unlink_in_place "$_root" "$_vd"
+    _tmp=$(mktemp -d) || return 1
+    link_sibling_builds "$_root" "$_tmp" "$_vd"
+    while IFS= read -r _p; do
+        _rel="${_p#"$_tmp/$_vd/"}"; _rel="${_rel%/.epam-sibling-copy}"
+        _at="$_root/$_vd/$_rel"; _aside="$(dirname "$_at")/.$(basename "$_at").epam-installed"
+        if [ -e "$_at" ] && [ ! -f "$_at/.epam-sibling-copy" ]; then mv -- "$_at" "$_aside" || continue; fi
+        [ -e "$_at" ] && rm -rf -- "${_at:?}"
+        mv -- "$(dirname "$_p")" "$_at" && log "  [sibling] ${_rel} → the provider's build, in place for the Writer (the installed release is set aside)"
+    done < <(find "$_tmp/$_vd" -mindepth 2 -maxdepth 3 -name .epam-sibling-copy -type f 2>/dev/null)
+    rm -rf -- "${_tmp:?}"
+    return 0
+}
+
+sibling_unlink_in_place() {
+    local _root="$1" _vd="$2" _aside _at
+    [ -n "$_root" ] && [ -n "$_vd" ] && [ -d "$_root/$_vd" ] || return 0
+    while IFS= read -r _aside; do
+        _at="$(dirname "$_aside")/$(basename "$_aside" .epam-installed)"; _at="$(dirname "$_at")/${_at##*/.}"
+        if [ -e "$_at" ] && [ -f "$_at/.epam-sibling-copy" ]; then rm -rf -- "${_at:?}"; fi
+        [ -e "$_at" ] || { mv -- "$_aside" "$_at" && log "  [sibling] ${_at#"$_root/$_vd/"}: its installed release is back"; }
+    done < <(find "$_root/$_vd" -mindepth 1 -maxdepth 2 -name '.*.epam-installed' -type d 2>/dev/null)
+    return 0
+}
+
 resolve_codeline_node() {
     local codeline_root="$1"
     local pkg="$codeline_root/package.json"
@@ -707,9 +741,27 @@ record_lanes_pause() {
 # marked completed was un-marked 33 s later and a paid writer re-wrote approved work on every resume
 # (AMSD-2974 run 9, resumes 9-12). A lane resumed from its checkpoint (_lane_spec_mode=0 under EPAM_RESUME_RUN)
 # passes nothing; every other lane, and every retry after gate remediation, still resets.
+# APPROVED WORK IS NEVER RESET (operator, 2026-10-22: "we should never throw away approved work"). A lane specified again on a
+# resume (its plan changed) passed --reset, which set its completed stories back to pending, and the Writer cut the branch fresh
+# from its base: LIVE-AMSD-2974-11's rehearsal dropped cx-shared's change approved at 9/10. A lane whose every story has an approval
+# record (review-verdict-<story>.json in the lane's log, written by the reviewer on approval) keeps it — a resume judges it again
+# where the operator asks (EPAM_REREVIEW_APPROVED), never from scratch. The caller's _cl_prd and _lane_log_dir are in scope.
+_lane_stories_approved() {
+  local _prd="${1:-}" _log="${2:-}" _id _n=0
+  [ -f "$_prd" ] && [ -d "$_log" ] || return 1
+  while IFS= read -r _id; do
+    [ -n "$_id" ] || continue
+    _n=$((_n + 1))
+    [ "$(jq -r '.verdict // empty' "$_log/review-verdict-${_id}.json" 2>/dev/null)" = "approved" ] || return 1
+  done < <(jq -r '(.stories // [])[] | select(.status != "deprecated") | .id // empty' "$_prd" 2>/dev/null)
+  [ "$_n" -gt 0 ]
+}
+
 _lane_phase_args() {
   if [ -n "${EPAM_RESUME_RUN:-}" ] && [ "${_lane_spec_mode:-}" = "0" ]; then
     printf ''
+  elif [ -n "${EPAM_RESUME_RUN:-}" ] && _lane_stories_approved "${_cl_prd:-}" "${_lane_log_dir:-}"; then
+    printf ''
   else
     printf '%s' '--reset'
   fi
@@ -1049,6 +1101,7 @@ _run_codeline_loop() {
   _lane_resume_prd() {
     local _rcl="$1" _rout="$2"
     _lane_spec_mode=""
+    _lane_respecified=""
     [ -n "${EPAM_RESUME_RUN:-}" ] || return 1
     local _rck="${EPAM_PROJECT_CONFIG_DIR:-${PROJECT_CONFIG_DIR:-}}/runs/${EPAM_RESUME_RUN}/lanes/${_rcl}/checkpoint"
     [ -f "$_rck/prd.json" ] && [ -f "$_rck/checkpoint.json" ] || return 1
@@ -1065,6 +1118,7 @@ _run_codeline_loop() {
     # A SPEC BUILT FROM INPUTS THAT NO LONGER HOLD IS SPECIFIED AGAIN (lib/run-checkpoint.sh).
     if ! lane_spec_is_current "$_rck" "$_rout"; then
       log "[orch] Codeline '${_rcl}': not resuming its pre-writer checkpoint — the lane is specified again"
+      _lane_respecified=1
       return 1
     fi
     if _operator_edited "$_rout" "$_rck/reviewed/$(basename "$_rout")"; then
@@ -1212,6 +1266,7 @@ _run_codeline_loop() {
       AGENT_IO_DIR="$_lane_log_dir/agent-io" \
       PRD_FILE="$_cl_prd" \
       EPAM_SPEC_MODE="${_lane_spec_mode:-${EPAM_SPEC_MODE:-}}" \
+      EPAM_LANE_RESPECIFIED="${_lane_respecified:-}" \
       PROJECT_ROOT="$_wt" \
       OUTPUT_DIR="$_wt" \
       PHASE="$_phase" \
@@ -1459,6 +1514,7 @@ _run_codeline_loop() {
       AGENT_IO_DIR="$_lane_log_dir/agent-io" \
       PRD_FILE="$_cl_prd" \
       EPAM_SPEC_MODE="${_lane_spec_mode:-${EPAM_SPEC_MODE:-}}" \
+      EPAM_LANE_RESPECIFIED="${_lane_respecified:-}" \
       PROJECT_ROOT="$_wt" \
       OUTPUT_DIR="$_wt" \
       PHASE="$_phase" \

package/orchestrations/scripts/lib/doctor/profile.js

@@ -9,7 +9,10 @@ const fs = require('fs');
 
 const SECTIONS = ['component', 'scope', 'test', 'install', 'crash', 'classify', 'settings', 'restart', 'model', 'logs', 'branch', 'boundaries', 'agentic'];
 const ENV_NAME = /^[A-Z][A-Z0-9_]*$/;
-const MANIFESTS = ['package.json#files'];       // how the files a component ships are listed (the only manifest the doctor can read)
+const MANIFESTS = ['package.json#files'];       // how the files a component ships are listed
+// OR a list file the component's installer copies from (operator, 2026-10-22: the doctor repairs any pipeline code — the shared component installs
+// the files docs/gateway-files.txt lists, from its orchestrations/ folder into <install>/orchestrations): "lines:<list file>:<folder the lines are under>"
+const LINES_MANIFEST = /^lines:[^:\s]+:[^:\s]+$/;
 
 function validate(input) {
   const problems = [];
@@ -72,7 +75,7 @@ function validate(input) {
     if (need('install', i, 'dest')) out.install.dest = rel('install.dest', i.dest);
     if (need('install', i, 'requires')) { const v = strs('install.requires', i.requires, { nonEmpty: false }); if (v) { v.forEach((d, n) => rel(`install.requires[${n}]`, d)); out.install.requires = v; } }
     if (need('install', i, 'command')) { const v = strs('install.command', i.command, { nonEmpty: true }); if (v) { for (const ph of ['{worktree}', '{install}']) if (!v.some((x) => x.includes(ph))) bad('install.command', `must contain ${ph}`); out.install.command = v; } }
-    if (need('install', i, 'manifest')) { if (!MANIFESTS.includes(i.manifest)) bad('install.manifest', `must be one of: ${MANIFESTS.join(', ')}`); else out.install.manifest = i.manifest; }
+    if (need('install', i, 'manifest')) { if (!MANIFESTS.includes(i.manifest) && !LINES_MANIFEST.test(String(i.manifest))) bad('install.manifest', `must be one of: ${MANIFESTS.join(', ')}, or lines:<list file>:<folder>`); else out.install.manifest = i.manifest; }
     if (need('install', i, 'patchRecord')) out.install.patchRecord = file('install.patchRecord', i.patchRecord);
   }
 

package/orchestrations/scripts/lib/doctor/repair.js

@@ -104,21 +104,28 @@ function verifyRepair({ repo, base, branch, profile, layer, abortKind, install }
 // ── the reinstall: the component's own installer, then every packaged file compared byte for byte ─────────────────────
 const show = (repo, rev, rel) => spawnSync('git', ['-C', repo, 'show', `${rev}:${rel}`], { encoding: 'buffer', maxBuffer: 64 * 1024 * 1024 });
 
-/** The files the component ships at <branch>: the manifest's entries expanded from the branch's tree, plus the manifest file itself. */
-function packaged(repo, branch) {
+/** The files the component ships at <branch>, each as { repo: its path in the repository, inst: its path under <install>/<dest> }:
+ *  package.json#files — the manifest's entries expanded from the branch's tree, plus package.json, at the same path; or
+ *  lines:<list>:<folder> — every line of the list file, found under <folder> in the repository and at the line's own path in the install. */
+function packaged(repo, branch, manifest = 'package.json#files') {
+  const m = /^lines:([^:]+):([^:]+)$/.exec(String(manifest));
+  if (m) {
+    const list = show(repo, branch, m[1]); if (list.status !== 0) return [];
+    return list.stdout.toString().split('\n').map((l) => l.trim()).filter(Boolean).sort().map((l) => ({ repo: `${m[2]}/${l}`, inst: l }));
+  }
   const pj = show(repo, branch, 'package.json'); if (pj.status !== 0) return [];
   const prefixes = (JSON.parse(pj.stdout.toString()).files || []).map((f) => f.replace(/\/$/, ''));
   const all = git(repo, 'ls-tree', '-r', '--name-only', branch).stdout.split('\n').filter(Boolean);
-  return [...new Set([...all.filter((f) => prefixes.some((p) => f === p || f.startsWith(`${p}/`))), 'package.json'])].sort();
+  return [...new Set([...all.filter((f) => prefixes.some((p) => f === p || f.startsWith(`${p}/`))), 'package.json'])].sort().map((f) => ({ repo: f, inst: f }));
 }
 
-/** The packaged files that are not byte-identical under <install>/<dest> (missing counts). */
+/** The packaged files that are not byte-identical under <install>/<dest> (missing counts) — by their path in the repository. */
 function installedMismatches({ repo, branch, install, profile }) {
   const dest = path.join(install, profile.install.dest);
-  return packaged(repo, branch).filter((rel) => {
-    const want = show(repo, branch, rel); const f = path.join(dest, rel);
+  return packaged(repo, branch, profile.install.manifest).filter(({ repo: rel, inst }) => {
+    const want = show(repo, branch, rel); const f = path.join(dest, inst);
     return want.status !== 0 || !fs.existsSync(f) || !want.stdout.equals(fs.readFileSync(f));
-  });
+  }).map((x) => x.repo);
 }
 
 function reinstall({ repo, branch, install, run, attempt, files, profile }) {

package/orchestrations/scripts/lib/run-checkpoint.sh

@@ -168,6 +168,9 @@ _is_known_stage() {
 # _pause_already_passed <stage-this-pause-guards>
 _pause_already_passed() {
     local _guards="${1:-}"
+    # A LANE SPECIFIED AGAIN IN THIS RUN HAS NOT PASSED THE PAUSE FOR ITS NEW SPEC (operator, 2026-10-22): the pause it passed was
+    # for the spec it no longer has — skipping it sent a new plan straight into the Writer with nobody seeing it.
+    [ "${EPAM_LANE_RESPECIFIED:-}" = "1" ] && return 1
     # The SNAPSHOT, not a fresh reading. EPAM_RESUMED_FROM_STAGE is published by resume_skip_env at
     # startup and inherited by every lane; a fresh run never sets it, so nothing is ever skipped.
     # Re-deriving here is the trap described above: the run would test state it had just written.

package/orchestrations/scripts/spec-mode-runner.js

@@ -1199,6 +1199,9 @@ function buildReviewPayload(stories, isBrownfieldReview, allStories = [], logDir
       technicalNotes: s.technicalNotes,
       specification: s.specification,
       fixSiteAnalysis: _fixSiteAnalysis,
+      // THE STORY'S PLAN FOR THIS CODELINE (operator, 2026-10-22): what it changes, receives and updates, as its Writer reads it
+      // (lib/producers/fix-plan.js) — the coordinator judges whether each verification criterion has a planned change behind it
+      ...(s.overallPlan ? { overallPlanForThisCodeline: require('./lib/producers/fix-plan.js').overallPlanText(s.overallPlan, s.codeline) } : {}),
       planAlignmentEvidence,
       ...(isBrownfieldReview ? {} : {
         splitChildren: (allStories || [])
@@ -6368,9 +6371,32 @@ function overallPlanBlock(story, prd) {
   }
   return renderEngineTemplate('detective-overall-plan', {
     __PLAN_CODELINES__: roots.map((r) => `- ${r.codeline}${r.path ? ` — ${r.path}` : ''}${r.codeline === (story && story.codeline) ? ' (the codeline you are in)' : ''}`).join('\n'),
+    __EXISTING_RELEASE_LINES__: existingReleaseLines(story, roots),
   });
 }
 
+/**
+ * THE RELEASE LINES THE STORY ALREADY HAS (operator, 2026-10-22): its line branches in each codeline, named by the pipeline's one
+ * branch rule (lib/git-ops.sh story_branch_name — "<prefix>AI-<story>" and the line's "-<name>"), each with the release it was cut
+ * from (the newest tag in its history). A re-plan that renamed a line made a second port of approved work. 'none' when there are none.
+ */
+function existingReleaseLines(story, roots) {
+  const { spawnSync } = require('child_process');
+  const id = story && story.id; if (!id) return 'none';
+  const stem = spawnSync('bash', ['-c', '. "$1/lib/git-ops.sh" >/dev/null 2>&1; story_branch_name "$2" ""', '_', __dirname, String(id)], { encoding: 'utf8' }).stdout.trim();
+  if (!stem) return 'none';
+  const lines = [];
+  for (const r of roots) {
+    if (!r.path) continue;
+    const refs = spawnSync('git', ['-C', r.path, 'for-each-ref', '--format=%(refname:short)', 'refs/heads/'], { encoding: 'utf8' });
+    for (const b of (refs.status === 0 ? refs.stdout.split('\n') : []).filter((x) => x.startsWith(`${stem}-`))) {
+      const base = spawnSync('git', ['-C', r.path, 'describe', '--tags', '--abbrev=0', b], { encoding: 'utf8' }).stdout.trim();
+      lines.push(`line "${b.slice(stem.length + 1)}" in ${r.codeline} (branch ${b}${base ? `, cut from ${base}` : ''})`);
+    }
+  }
+  return lines.length ? lines.join('; ') + '.' : 'none.';
+}
+
 function detectiveSharedBlock(story, prd) {
   const lanes = (story && Array.isArray(story.codelines)) ? story.codelines.filter(Boolean) : [];
   const here = story && story.codeline;
@@ -11021,6 +11047,7 @@ function costLabelFor(tag, env) {
 }
 
 module.exports = {
+  overallPlanBlock, existingReleaseLines,
   stampSpecification,
   rewireDependenciesOnSplit,
   storyAcsBlock,

package/orchestrations/scripts/team-lead-review.sh

@@ -233,6 +233,15 @@ reviewer_model_for() {
 #
 # Absent means the writer named no model, and the seam's own declared rung stands. Nothing here
 # invents one.
+# record_review_approval <story_id> — the approval, recorded where a resume reads it (operator, 2026-10-22: approved work is
+# never reset — lib/codeline-lanes.sh _lane_stories_approved): <LOG_DIR>/review-verdict-<story>.json, the same record the Claude
+# workflows' driver writes. HEAD is the commit the approval judged.
+record_review_approval() {
+    jq -cn --arg h "$(git -C "${PROJECT_ROOT:-.}" rev-parse HEAD 2>/dev/null)" --arg at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+        '{verdict: "approved", head: (if $h == "" then null else $h end), at: $at}' \
+        > "${LOG_DIR:-$AUTOMATION_DIR/logs}/review-verdict-${1}.json" 2>/dev/null || true
+}
+
 run_review_prompt() {
     local prompt_text="$1"
     local writer_model="$2"
@@ -978,6 +987,9 @@ $(render_engine_prompt story-diff-not-inlined "$_sdni_vals" excluded)"
         success "  Review: approved — ${STORY_SUMMARY:-no issues found}"
         # Clear any stale feedback from a prior cycle now that this story passed.
         rm -f "${LOG_DIR:-$AUTOMATION_DIR/logs}/review-feedback-${story_id}.json" 2>/dev/null || true
+        # THE APPROVAL IS RECORDED (operator, 2026-10-22): a resume must know this story's work was approved so it is never reset
+        # (lib/codeline-lanes.sh _lane_stories_approved) — the same record the Claude workflows' driver writes.
+        record_review_approval "$story_id"
     fi
 
     # THE REVIEWER'S MEMORY OF THIS STORY. Written HERE, inside the loop, because this is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amsd-pipeline-shared",
-  "version": "0.5.17",
+  "version": "0.5.20",
   "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": {