amsd-pipeline-shared 0.5.7 → 0.5.9

package/orchestrations/config/doctor-signatures.json

@@ -3,7 +3,8 @@
   "node": {
     "runtimeNames": ["TypeError", "ReferenceError", "SyntaxError", "RangeError"],
     "runtimeMessage": "Unexpected token|is not valid JSON|Unexpected end of JSON|Cannot read propert|Cannot set propert|is not a function|is not defined|is not iterable|Cannot destructure|is not a constructor|Invalid array length|Maximum call stack",
-    "external": "\\bE(NOSPC|ACCES|PERM|MFILE|NOMEM|CONNRESET|CONNREFUSED|TIMEDOUT|NOTFOUND|AI_AGAIN|PIPE)\\b|bounded: cap|exited (137|143)\\b|\\b(401|403|429|500|502|503|529)\\b|overloaded|rate.?limit|credit|quota|<!DOCTYPE|<html|out of memory|killed",
+    "external": "\\bE(NOSPC|ACCES|PERM|MFILE|NOMEM|CONNRESET|CONNREFUSED|TIMEDOUT|NOTFOUND|AI_AGAIN|PIPE)\\b|bounded: REFUSED|exited (137|143)\\b|\\b(401|403|429|500|502|503|529)\\b|overloaded|rate.?limit|credit|quota|<!DOCTYPE|<html|out of memory|killed",
+    "ownBudget": "bounded: cap=\\d+MB",
     "generalRefusal": "refused|usage:",
     "internalFrame": "^node:",
     "dependencyDir": "node_modules"

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

@@ -19,12 +19,16 @@ function signaturesFor(runtime, injected) {
   const all = injected || JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', '..', 'config', 'doctor-signatures.json'), 'utf8'));
   const s = all[runtime];
   if (!s) throw new Error(`no signatures for runtime "${runtime}" (config/doctor-signatures.json knows: ${Object.keys(all).filter((k) => !k.startsWith('$')).join(', ')})`);
-  return { runtimeNames: new Set(s.runtimeNames), runtimeMessage: rxOf(s.runtimeMessage), external: rxOf(s.external), generalRefusal: rxOf(s.generalRefusal),
+  return { runtimeNames: new Set(s.runtimeNames), runtimeMessage: rxOf(s.runtimeMessage), external: rxOf(s.external), ownBudget: s.ownBudget ? rxOf(s.ownBudget) : /$^/, generalRefusal: rxOf(s.generalRefusal),
     internalFrame: rxOf(s.internalFrame), dependencyDir: s.dependencyDir };
 }
 
 function classify({ profile, portRoot, res, crash, aborted, since, signatures, evidence }) {
   const sig = signaturesFor(profile.classify.runtime, signatures);
+  const takesMost = profile.classify.policy === 'all-but-refusals';
+  // WHAT IS EXTERNAL: the machine, the network, the model service, a kill. Under "all-but-refusals" a kill that happened inside the pipeline's OWN memory budget (the bounded wrapper's start banner is in the text:
+  // the cap the pipeline chose, so what ran inside it is the pipeline's to bound — run 11, jest workers inside a Writer session's cap) is not external
+  const isExternal = (text) => sig.external.test(text) && !(takesMost && sig.ownBudget.test(text));
   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');
   // AN AGENT-CAUSED ABORT (operator, 2026-10-20: look for the agentic solution first): a failed leg whose reason is one of the pipeline's own agent-caused
@@ -39,7 +43,7 @@ function classify({ profile, portRoot, res, crash, aborted, since, signatures, e
       // 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)}`);
+        if (isExternal(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)}` };
       }
       // MOST FAILURES (profile classify.policy "all-but-refusals"): the pipeline's own refusals are its decision and what names the machine, the network, the model service or a kill is not the code —
@@ -48,21 +52,21 @@ function classify({ profile, portRoot, res, crash, aborted, since, signatures, e
         const lines = String(evidence || '').split('\n').filter((l) => l.trim());
         const window = [reason, ...lines.slice(-25)].filter(Boolean).join('\n');
         if (!window.trim()) return no('not-a-crash', 'the leg failed with no reason and no evidence — nothing to investigate');
-        if (sig.external.test(window)) return no('external', 'the end of the failure also names the machine, the network, the model service or a kill — not the pipeline');
+        if (isExternal(window)) return no('external', 'the end of the failure also names the machine, the network, the model service or a kill — not the pipeline');
         if (profile.classify.refusals.some((r) => r.test(window))) return no('refusal', 'the pipeline stopped on purpose (its own refusal or pre-condition)');
         const last = [...lines].reverse().find((l) => /fail|HALT|block|error/i.test(l)) || reason;
         return { call: true, kind: 'failure', layer: 'undecided', why: `the leg failed (${reason || 'no reason'}): ${String(last).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');
+    if (isExternal(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)}` };
   }
   if (res.status !== 'crashed') return no(res.status === 'no-answer' ? 'no-record' : 'not-a-crash', `the leg ended ${res.status}, not crashed — a kill, a verdict or a pause is reported, not repaired`);
   if (!crash || typeof crash !== 'object') return no('no-record', 'no crash record: nothing proves a defect in the code');
   if (!crash.at || !since || Date.parse(crash.at) < Date.parse(since)) return no('stale-record', 'the crash record is older than this leg');
   const text = `${crash.name || ''}: ${crash.message || ''}`;
-  if (sig.external.test(text)) return no('external', 'the failure names the machine, the network, the model service or a kill — not the code');
+  if (isExternal(text)) return no('external', 'the failure names the machine, the network, the model service or a kill — not the code');
   if (sig.generalRefusal.test(text) || profile.classify.refusals.some((r) => r.test(text))) return no('refusal', 'the pipeline stopped on purpose');
   const site = (crash.frames || []).find((f) => f && typeof f.file === 'string' && !sig.internalFrame.test(f.file)) || null;
   if (!site) return no('outside-port', 'no frame of the stack is in any file');
@@ -71,6 +75,8 @@ function classify({ profile, portRoot, res, crash, aborted, since, signatures, e
   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})` : ''}` };
+  // under "all-but-refusals" an Error thrown by the component's own code is the doctor's even without a runtime-exception mark (run 11: `the live session for writer exited null`)
+  if (takesMost && !sig.runtimeNames.has(crash.name) && !sig.runtimeMessage.test(crash.message || '')) return { call: true, kind: 'crash', layer: 'undecided', why: `${crash.name}: ${String(crash.message).slice(0, 160)} — thrown 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/profile.js

@@ -58,6 +58,9 @@ function validate(input) {
     if (need('test', t, 'envUnset')) out.test.envUnset = strs('test.envUnset', t.envUnset, { nonEmpty: false });
     if (need('test', t, 'greenPatterns')) { if (Array.isArray(t.greenPatterns) && !t.greenPatterns.length) bad('test.greenPatterns', 'at least one pattern is required'); out.test.greenPatterns = rxs('test.greenPatterns', t.greenPatterns); }
     if (need('test', t, 'failedPattern')) out.test.failedPattern = rx('test.failedPattern', t.failedPattern);
+    // OPTIONAL: repository paths that git ignores and the tests read (a codeline copy, generated data) — linked into every throwaway worktree the verification runs its tests in
+    out.test.fixtures = has(t, 'fixtures') ? (strs('test.fixtures', t.fixtures, { nonEmpty: false }) || []) : [];
+    out.test.fixtures.forEach((d, i) => rel(`test.fixtures[${i}]`, d));
   }
 
   const i = p.install;

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

@@ -34,12 +34,23 @@ function runTests(wt, files, profile) {
   return { status: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
 }
 
-/** A throwaway work tree of <rev>; removed by the caller's finally. */
-function worktree(repo, rev) {
+/**
+ * A throwaway work tree of <rev>; removed by the caller's finally. `fixtures` (the profile's test.fixtures): repository paths git ignores and the tests read — each is linked in from the repository, so a
+ * correct repair is judged on the data its tests need (run 11: the doctor's own GREEN check failed on a missing git-ignored codeline copy). A fixture the repository does not have is a stated error.
+ */
+function worktree(repo, rev, fixtures = []) {
   const wt = fs.mkdtempSync(path.join(os.tmpdir(), 'doctor-wt-'));
   fs.rmSync(wt, { recursive: true, force: true });
   const r = git(repo, 'worktree', 'add', '--detach', '-q', wt, rev);
   if (r.status !== 0) throw new Error(`worktree of ${rev}: ${r.stderr}`);
+  try {
+    for (const f of fixtures) {
+      const from = path.join(repo, f); const to = path.join(wt, f);
+      if (!fs.existsSync(from)) throw new Error(`test.fixtures names ${f}, which is not in ${repo} — nothing to link into the worktree`);
+      if (fs.existsSync(to)) continue;
+      fs.mkdirSync(path.dirname(to), { recursive: true }); fs.symlinkSync(from, to);
+    }
+  } catch (e) { drop(repo, wt); throw e; }
   return wt;
 }
 const drop = (repo, wt) => { git(repo, 'worktree', 'remove', '--force', wt); git(repo, 'worktree', 'prune'); fs.rmSync(wt, { recursive: true, force: true }); };
@@ -72,13 +83,13 @@ function verifyRepair({ repo, base, branch, profile, layer, abortKind }) {
   let wtBase = null; let wtTip = null;
   try {
     // RED: the base, with ONLY the repair's tests added — they must fail there (a test that cannot even load is caught by the GREEN run)
-    wtBase = worktree(repo, base);
+    wtBase = worktree(repo, base, profile.test.fixtures);
     const co = git(wtBase, 'checkout', branch, '--', ...tests);
     if (co.status !== 0) return bad(`cannot place the tests on the base: ${co.stderr.trim()}`, { files });
     const red = runTests(wtBase, tests, profile);
     if (red.status === 0) return bad('the test passes without the fix: it is not RED, so it proves nothing', { files, red: red.out });
     // GREEN: the branch's tip
-    wtTip = worktree(repo, branch);
+    wtTip = worktree(repo, branch, profile.test.fixtures);
     const green = runTests(wtTip, tests, profile);
     if (green.status !== 0 || !profile.test.greenPatterns.every((r) => r.test(green.out))) return bad('the test fails with the fix: not GREEN', { files, red: red.out, green: green.out });
     return { ok: true, why: 'RED on the base, GREEN with the fix', files, tests, red: red.out, green: green.out };

package/package.json

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