amsd-pipeline-shared 0.5.44 → 0.5.46

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

@@ -44,13 +44,32 @@ function renderPrompt(vars, profile) {
 }
 
 /** The command, prepared and not started: the CLI in print mode on the profile's family, in the work tree, memory-bounded when the host has the wrapper. */
+/** THE RUNNER'S OWN ISOLATION FOR THE DOCTOR'S CALL (2026-10-25: the doctor's session loaded the host's MCP servers and skills — it is an
+ *  agent like every other and gets the same declaration). The claude runner's alwaysFlags and env from the stack's declaration the
+ *  profile names (config/llm-defaults.<set>.json runners.claude), read as the hub's resolver reads them; none when the file has none. */
+function runnerIsolation(install, profile) {
+  try {
+    const file = String(profile.model.config || '').replace('{install}', install);
+    const settings = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const r = settings.runners || {};
+    const d = r.claude || Object.values(r)[0] || {};
+    const flags = Array.isArray(d.alwaysFlags) ? d.alwaysFlags.filter((f) => f !== '--safe-mode') : [];
+    const env = {};
+    for (const [k, name] of Object.entries(d.env || {})) { const v = settings[name]; if (v !== undefined && v !== null && String(v) !== '') env[k] = String(v); }
+    return { flags, env };
+  } catch { return { flags: [], env: {} }; }
+}
+
 function buildCommand({ install, profile, prompt, cwd, claudeBin, budgetUsd, model: rung }) {
   // a rung the failed-call step moved to is taken only within the profile's family; otherwise the family's own model
   const model = rung && rung.toLowerCase().includes(profile.model.family.toLowerCase()) ? rung : modelFor(install, profile);
+  const iso = runnerIsolation(install, profile);
+  // the declaration's switches (--setting-sources "", --strict-mcp-config, …) replace the former `--setting-sources project`; the
+  // doctor edits files, so its permission mode stays bypass
   const argv = [...hostWrap(), claudeBin || process.env.CLAUDE_BIN || 'claude', '-p', prompt, '--model', model, '--output-format', 'json',
-    '--setting-sources', 'project', '--permission-mode', 'bypassPermissions',
+    ...(iso.flags.length ? iso.flags : ['--setting-sources', 'project']), '--permission-mode', 'bypassPermissions',
     ...(budgetUsd ? ['--max-budget-usd', String(budgetUsd)] : [])];
-  return { cwd, argv, model };
+  return { cwd, argv, model, env: iso.env };
 }
 
 /** The answer's shape: repaired / cannot with the fields — anything else is no answer. */
@@ -80,7 +99,7 @@ function readAnswer(text) {
 /** Runs the session (the only model call the doctor makes). Returns the answer, the session's cost record and any model of another family it used. */
 function runAgent({ install, profile, prompt, cwd, sessionDir, env, claudeBin, budgetUsd, model }) {
   const cmd = buildCommand({ install, profile, prompt, cwd, claudeBin, budgetUsd, model });
-  const r = spawnSync(cmd.argv[0], cmd.argv.slice(1), { cwd: cmd.cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: '0', ...process.env, ...(env || {}) }, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+  const r = spawnSync(cmd.argv[0], cmd.argv.slice(1), { cwd: cmd.cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: '0', ...process.env, ...cmd.env, ...(env || {}) }, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
   try { fs.mkdirSync(sessionDir, { recursive: true }); fs.writeFileSync(path.join(sessionDir, 'agent.stderr'), String(r.stderr || '')); fs.writeFileSync(path.join(sessionDir, 'agent.stdout'), String(r.stdout || '')); } catch { /* evidence only */ }
   let out = null; try { out = JSON.parse(r.stdout); } catch { out = null; }
   const session = out && out.session_id ? { sessionId: out.session_id, modelUsage: out.modelUsage || {}, totalCostUsd: out.total_cost_usd || 0 } : null;

package/orchestrations/scripts/lib/pipeline-tools-mcp.js

@@ -9,8 +9,12 @@
 // agent is granted them by name (--tools mcp__<server>__<tool>), and a tool whose permission is 'safe' is annotated read-only,
 // which is what lets it run in plan mode (proven 2026-10-24 on Claude Code 2.1.310: without the annotation plan mode refuses it).
 //
+//   node pipeline-tools-mcp.js --codeline <dir>     serve the plugins THAT CODELINE provisions (.epam/settings.json tools — the
+//                                                   pipeline's own grant rule, lib/agent-tools.js pluginToolsFor), run inside it
 //   node pipeline-tools-mcp.js <runner-name>        serve the runner's hostedToolPlugins (declaration read from the active set)
 //   node pipeline-tools-mcp.js --modules a.js,b.js  serve these plugin modules (tests)
+// ONE SERVER FOR BOTH RUNTIMES (2026-10-25): the Claude workflows had their own (claude-workflows/mcp/pipeline-tools.js, per
+// codeline) and the hub got this one (per runner) — duplicated code; the workflows now start this file in --codeline mode.
 //
 // Protocol: JSON-RPC 2.0, one message per line, MCP 2024-11-05 — initialize, tools/list, tools/call; nothing else.
 const fs = require('fs');
@@ -27,6 +31,13 @@ function hostedModulesFor(runnerName) {
   return ((runner && runner.hostedToolPlugins) || []).map((m) => path.resolve(ORCH, m));
 }
 
+/** The plugin modules a codeline provisions (.epam/settings.json tools), as the pipeline's grant rule reads them. */
+function codelineModulesOf(codeline) {
+  let settings;
+  try { settings = JSON.parse(fs.readFileSync(path.join(codeline, '.epam', 'settings.json'), 'utf8')); } catch { return []; }
+  return (Array.isArray(settings.tools) ? settings.tools : []).filter((e) => typeof e === 'string' && e);
+}
+
 /** Every tool the modules export, as MCP lists them: safe → read-only; the plugin's own input schema and description. */
 function toolsOf(modules) {
   const out = [];
@@ -35,7 +46,7 @@ function toolsOf(modules) {
     const mod = require(m);
     for (const t of ((mod && mod.tools) || [])) {
       const name = t.name || (t.definition && t.definition.name);
-      if (!name) continue;
+      if (!name || typeof t.execute !== 'function') continue;
       const def = t.definition || {};
       out.push({
         name,
@@ -94,9 +105,12 @@ function mcpConfig(runnerName, nodeBin = process.execPath) {
 
 if (require.main === module) {
   const a = process.argv.slice(2);
-  const modules = a[0] === '--modules' ? String(a[1] || '').split(',').filter(Boolean).map((m) => path.resolve(m)) : hostedModulesFor(a[0]);
-  if (!modules.length) { process.stderr.write(`[pipeline-tools-mcp] no hosted tool plugins for runner '${a[0] || ''}'\n`); process.exit(2); }
+  let modules;
+  if (a[0] === '--modules') modules = String(a[1] || '').split(',').filter(Boolean).map((m) => path.resolve(m));
+  else if (a[0] === '--codeline') { const cl = path.resolve(a[1] || process.cwd()); process.chdir(cl); modules = codelineModulesOf(cl); }   // plugins work on the folder they run in
+  else modules = hostedModulesFor(a[0]);
+  if (!modules.length) { process.stderr.write(`[pipeline-tools-mcp] no tool plugins for ${a[0] === '--codeline' ? `codeline ${a[1]}` : `runner '${a[0] || ''}'`}\n`); process.exit(2); }
   serve(modules);
 }
 
-module.exports = { hostedModulesFor, toolsOf, serve, mcpConfig, asMcpResult };
+module.exports = { hostedModulesFor, codelineModulesOf, toolsOf, serve, mcpConfig, asMcpResult };

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

@@ -4175,6 +4175,16 @@ PROPOSE TWO CLASSES OF AGENT.
 IMPLEMENTERS (kind: "implementer") author code, as described above. One roster of them spans
 every codeline.
 
+THE CODELINE'S STANDING ENGINEER, NOT A SPECIALITY. Propose ONE implementer per codeline that
+needs work written, named for that codeline (its engineer) and briefed on its WHOLE stack: its
+layout, build, conventions, tests and how to verify there. Any story on that codeline — a
+component change, a page, an integration, a localisation fix — must find this role fit to
+assign. Where codelines share one stack and structure, one engineer may cover them all, named
+for what they share. Propose a speciality (a narrower role) only where a codeline's structure
+genuinely splits it — a separate build, a separate deployable, a separately-owned subtree — and
+never for the kind of work one ticket happens to need: this roster outlives every ticket, and a
+roster of specialities leaves the next story with no one to assign.
+
 Every proposal states a "codeline". An implementer spans the project and uses "*". An
 investigator names the ONE codeline it reads, exactly as spelled in scope above. There is no
 third option and no omitting it.

package/package.json

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