amsd-pipeline-shared 0.5.4 → 0.5.6

package/orchestrations/prompts/doctor-repair.md

@@ -17,7 +17,7 @@ AGENTIC FIRST — decide this before anything else
 - The agentic layer of {{component}} is: {{agenticDescription}}. It lives in: {{agenticDirs}}.
 - If an agent caused it, repair the AGENTIC layer: sharpen the instruction, the answer schema and its field descriptions, the hand-off contract between the agents — so the agent is asked in a way that gets the right answer. Do NOT add deterministic code that tolerates, repairs or re-parses a wrong agent answer, and do not add a guard that hides an agent's behaviour.
 - Only a clear and outright coding bug gets a deterministic fix.
-- This abort was classified as: {{abortKind}} ({{layerHint}}). An agentic abort MUST be repaired agentically. For a crash, say which layer you found and why.
+- This abort was classified as: {{abortKind}} ({{layerHint}}). An agentic abort MUST be repaired agentically. For a crash or a fault (the leg failed without giving a verdict: a stage with no result, a session that answered an error), the layer is yours to find — look for the agentic cause first — and say which and why.
 - An agentic repair is proven by REPLAY: replay the real reply or hand-off that failed — copy it into a fixture — against the schema, the contract or the rendered instruction in the RED test (it fails on the base, passes after), and assert on the rendered instruction or schema text that now prevents the abort.
 
 HOW YOU WORK — in this order

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

@@ -23,7 +23,7 @@ function signaturesFor(runtime, injected) {
     internalFrame: rxOf(s.internalFrame), dependencyDir: s.dependencyDir };
 }
 
-function classify({ profile, portRoot, res, crash, aborted, since, signatures }) {
+function classify({ profile, portRoot, res, crash, aborted, since, signatures, evidence }) {
   const sig = signaturesFor(profile.classify.runtime, signatures);
   if (!res || typeof res !== 'object') return no('no-result', 'the leg gave no result');
   if (aborted) return no('aborted', 'the operator or a watcher ended the leg');
@@ -33,7 +33,17 @@ function classify({ profile, portRoot, res, crash, aborted, since, signatures })
   if (res.status === 'failed') {
     const reason = typeof res.reason === 'string' ? res.reason : '';
     const hit = reason && profile.agentic.abortSignatures.find((r) => r.test(reason));
-    if (!hit) return no('not-a-crash', 'the leg failed on a verdict that names no agent-caused message — reported, not repaired');
+    if (!hit) {
+      // A FAILED LEG THAT GAVE NO VERDICT (operator, 2026-10-20, after run 11 leg 3: "these are the types of bugs I need doctor to resolve during a run"): the machinery failed without throwing
+      // — a stage's result with no exit, a session that answered an error. Which lines of the leg's evidence say so is the pipeline's profile (classify.faultMarks); a lane's own verdict
+      // has a number and its reason and matches none. The marked line is still refused if it names the machine, the network, the model service or a kill.
+      const line = evidence && profile.classify.faultMarks.length ? String(evidence).split('\n').find((l) => profile.classify.faultMarks.some((r) => r.test(l))) : null;
+      if (line) {
+        if (sig.external.test(line)) return no('external', `the failing line also names the machine, the network, the model service or a kill — not the pipeline: ${line.slice(0, 160)}`);
+        return { call: true, kind: 'fault', layer: 'undecided', why: `the leg failed without a verdict: ${line.trim().slice(0, 200)}` };
+      }
+      return no('not-a-crash', 'the leg failed on a verdict that names no agent-caused message — reported, not repaired');
+    }
     if (sig.external.test(reason)) return no('external', 'the agent-caused message also names the machine, the network, the model service or a kill — not the pipeline');
     return { call: true, kind: 'agentic-abort', layer: 'agentic', why: `an agent caused the abort: ${reason.slice(0, 200)}` };
   }
@@ -49,6 +59,7 @@ function classify({ profile, portRoot, res, crash, aborted, since, signatures })
   const parts = rel.split(path.sep);
   const inPort = !!portRoot && !rel.startsWith('..') && !path.isAbsolute(rel) && profile.scope.repairDirs.includes(parts[0]) && !parts.includes(sig.dependencyDir);
   if (!inPort) return no('outside-port', `the throw site ${site.file}:${site.line} is not the component's own code`);
+  if (crash.fault === true) return { call: true, kind: 'fault', layer: 'undecided', why: `a fault the component raised: ${String(crash.message).slice(0, 160)} — at ${rel}:${site.line}${crash.step ? ` (step: ${crash.step})` : ''}` };
   if (!sig.runtimeNames.has(crash.name) && !sig.runtimeMessage.test(crash.message || '')) return no('ambiguous', `an Error in ${rel}:${site.line} with no sign of a code defect — reported`);
   return { call: true, kind: 'port-defect', layer: 'code', why: `${crash.name}: ${String(crash.message).slice(0, 160)} — thrown at ${rel}:${site.line}${crash.step ? ` (step: ${crash.step})` : ''}` };
 }

package/orchestrations/scripts/lib/doctor/crash-record.js

@@ -27,7 +27,7 @@ function frames(stack) {
 
 /** What was thrown, whatever it was: an Error, or anything a program may throw. */
 function describe(e) {
-  if (e instanceof Error) return { name: e.name || 'Error', message: String(e.message), stack: String(e.stack || '') };
+  if (e instanceof Error) return { name: e.name || 'Error', message: String(e.message), stack: String(e.stack || ''), ...(e.fault === true ? { fault: true, evidence: Array.isArray(e.evidence) ? e.evidence.map(String) : [] } : {}) };
   let text; try { text = typeof e === 'string' ? e : JSON.stringify(e); } catch { text = String(e); }
   return { name: 'NonError', message: String(text), stack: '' };
 }

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

@@ -29,7 +29,9 @@ async function handle(a) {
   const d = open(runDir, cfg, profile);
   const portRoot = path.join(install, profile.install.dest);
 
-  const c = classify({ profile, portRoot, res, crash, aborted, since });
+  // the leg's evidence tail (the files the profile names), read BEFORE the decision: a failure that threw nothing is judged on what the run itself wrote
+  const evidence = profile.logs.evidence.map((f) => tail(path.join(runDir, f), profile.logs.evidenceTailLines)).join('\n');
+  const c = classify({ profile, portRoot, res, crash, aborted, since, evidence });
   if (!c.call) { d.event('not-called', { kind: c.kind, why: c.why }); return { handled: false, kind: c.kind, why: c.why }; }
   d.event('trigger', { kind: c.kind, layer: c.layer, why: c.why, step: (crash && crash.step) || '' });
 

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

@@ -77,6 +77,8 @@ function validate(input) {
     out.classify = {};
     if (need('classify', cl, 'runtime')) out.classify.runtime = str('classify.runtime', cl.runtime);
     if (need('classify', cl, 'refusals')) out.classify.refusals = rxs('classify.refusals', cl.refusals);
+    // THE LINES THAT MEAN "THE MACHINERY GAVE NO VERDICT" (optional; none = a failed leg is never taken for a fault): a pipeline's own knowledge, matched against the leg's evidence tail
+    out.classify.faultMarks = cl.faultMarks === undefined ? [] : rxs('classify.faultMarks', cl.faultMarks);
   }
 
   const se = p.settings;

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

@@ -229,9 +229,14 @@ qa_record_phase_baseline() {
     # 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
+    # A RESUME ADOPTS A LEGACY BASELINE (a sha with no key file, recorded by the code before B77 — found replaying run 11's gotransit lane): on a resume it is the run's own, so a
+    # valid commit is kept and the key is written for every later call. Without a resume (a new run in the same folder) a keyless value is not trusted, as before.
+    local _legacy=0
+    [ -f "$_bf" ] && [ ! -f "$_kf" ] && [ -n "${EPAM_RESUME_RUN:-}" ] && _legacy=1
+    if [ -f "$_bf" ] && { [ "$_legacy" = 1 ] || { [ -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
+            [ "$_legacy" = 1 ] && printf '%s\n' "$_key" > "$_kf"
             printf '%s' "$_have"
             return 0
         fi

package/package.json

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