amsd-pipeline-workflow 0.1.0 → 0.1.5

package/README.md

@@ -1,20 +1,37 @@
 # amsd-pipeline-workflow
 
 The AMSD pipeline driven as Claude workflows. It runs **against an installed AMSD pipeline** (it calls the pipeline's
-own scripts) and is installed by the pipeline's installer.
+own scripts) with the shared components (`amsd-pipeline-shared`) installed into it. Neither the pipeline nor its
+installer is changed.
 
 ## Install
 
+Three steps, in this order, into one install:
+
 ```bash
-npx amsd-pipeline@<version> --dest <dir> --ref v<version> --no-docker --workflows
+npx amsd-pipeline@2.0.80 --dest <dir> --ref v2.0.80 --no-docker        # 1. the pipeline, as always
+npx amsd-pipeline-shared@<version> install --into <dir>                # 2. the shared gateway, reviewer, messages
+npx amsd-pipeline-workflow@<version> install --into <dir> [--codeline-cache <cache>]   # 3. the workflows
 ```
 
-`--workflows` installs the `amsd-pipeline-workflow` version the pipeline release pins
-(`orchestrations/config/claude-workflows.json`) into `<dir>/claude-workflows/`. `--workflows <file.tgz>` installs a
-local package instead (for testing a build before it is published). `--check` verifies it; `--uninstall` removes it.
+Step 3 writes only `<dir>/claude-workflows/` and, with `--codeline-cache`, each codeline's cached roster and prompts
+(`<cache>/orchestrations/projects/<project>/.prompt-cache/<codeline>/` and its `.complete-<codeline>[.brownfield]` marker)
+into the same project, so the pipeline reuses them instead of minting and generating again. The pipeline still decides at
+launch whether each is current. Reinstalling replaces `claude-workflows/`. Without step 2 the workflows still run, but
+messaging is off (said at generation) and the gateway's hub keeps 2.0.80's defect B56 (a failed call reads as success).
 
 Needs: Node 20+, the `claude` CLI, `unshare` (util-linux) and `systemd-run --user` (the memory bound, `bin/bounded`).
 
+## What every agent call gets
+
+- **Retries, the ladder and self-heal, for every agent** (`generator/gateway.js`, `hooks/step-call-failed.sh`): a call with
+  no usable answer goes to the pipeline's own decisions — the failure on the agent's ladder, its next rung, the
+  previous-refusal block, the KB episode — and is asked again, up to `EPAM_CALL_MAX_ATTEMPTS`; only then is it no answer.
+  The Codeline, Agents stage runs the pipeline's own hub, which does the same.
+- **Agent-to-agent messages**: any agent may answer with `messages` ([{to, type, subject, text}]); "router" (or no one) goes
+  to the stage's router — the reviewer in the Writer, the coordinator in Spec. Delivered in the recipient's next prompt,
+  on the pipeline's bus (`hooks/messages-out.js`), no extra model call.
+
 ## Run
 
 ```bash
@@ -25,6 +42,15 @@ Needs: Node 20+, the `claude` CLI, `unshare` (util-linux) and `systemd-run --use
 Langfuse tracing follows the install's own settings (`LANGFUSE_PUBLIC_KEY`, `LANGFUSE_SECRET_KEY`): each agent call is
 sent as one generation through the pipeline's own emitter.
 
+## Live runs: the run note and the abort
+
+`tools/rehearse.js --live yes` (and `--start live`, `--leg 2|3`, `--tag`) keeps one note per run in the operator's vault
+(`pipeline/live/<run>.md`, `tools/live-tracker.js`), refreshed every 2 minutes while a leg runs: legs, cost by stage,
+the Langfuse session id (proven by a launch trace read back before each leg), the lanes, the messages, and the six
+**abort-class checks** — retries, ladder, self-heal, costing, LLM settings, reviewer verdicts. A red one aborts the leg at
+once (`tools/abort-watch.sh` kills the leg's process group) and the leg is recorded ABORTED with the reason.
+At £0, `--plant writer,reviewer` makes those agents give no answer once per lane, to watch the gateway climb.
+
 ## Version
 
 `amsd-pipeline-workflow version`. `package.json` `amsdPipeline.tested` names the pipeline release it was tested against.

package/bin/amsd-pipeline-workflow.js

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
 'use strict';
-// amsd-pipeline-workflow — the AMSD pipeline as Claude workflows. Installed by the pipeline's own installer
-// (install.sh --workflows) into <install>/claude-workflows/, which writes install.json there naming the install.
+// amsd-pipeline-workflow — the AMSD pipeline as Claude workflows, installed INTO an existing pipeline install with no
+// change to the pipeline (operator, 2026-10-18).
+//   amsd-pipeline-workflow install --into <pipeline install> [--codeline-cache <dir>]
+//        writes <install>/claude-workflows/ (this package's published files, and install.json naming the install) and,
+//        with --codeline-cache, each codeline's cache entry from <dir>/orchestrations/projects/<p>/.prompt-cache/ — its
+//        <codeline>/ folder (the minted roster and the prompts) and its .complete-<codeline>[.brownfield] marker — into the
+//        same project of the install, so the pipeline's own reuse step restores them instead of minting and generating
+//        again. Nothing else in the install is written.
 //   amsd-pipeline-workflow run <driver/run.js arguments>   — --install defaults to the install this was installed into
 //   amsd-pipeline-workflow version
 const fs = require('fs');
@@ -9,9 +15,51 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 
 const ROOT = path.resolve(__dirname, '..');
+const PKG = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8'));
 const [cmd, ...rest] = process.argv.slice(2);
-if (cmd === 'version') { process.stdout.write(`${require(path.join(ROOT, 'package.json')).version}\n`); process.exit(0); }
-if (cmd !== 'run') { process.stderr.write('usage: amsd-pipeline-workflow run <driver arguments> | version\n'); process.exit(64); }
+const fail = (m) => { process.stderr.write(`amsd-pipeline-workflow: ${m}\n`); process.exit(1); };
+const opt = (name) => { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : undefined; };
+
+if (cmd === 'version') { process.stdout.write(`${PKG.version}\n`); process.exit(0); }
+
+if (cmd === 'install') {
+  const into = opt('--into'); const cacheDir = opt('--codeline-cache');
+  if (!into) fail('install needs --into <pipeline install>');
+  const inst = path.resolve(into);
+  if (!fs.existsSync(path.join(inst, 'orchestrations', 'scripts')) || !fs.existsSync(path.join(inst, 'orchestrations', 'projects'))) fail(`${inst} is not a pipeline install (no orchestrations/scripts and orchestrations/projects)`);
+  if (cacheDir && !fs.existsSync(path.join(path.resolve(cacheDir), 'orchestrations', 'projects'))) fail(`${cacheDir} holds no codeline cache (no orchestrations/projects)`);
+  // the package: exactly its published files (package.json "files"), into a new folder, then swapped in
+  const dest = path.join(inst, 'claude-workflows'); const tmp = `${dest}.new`;
+  fs.rmSync(tmp, { recursive: true, force: true }); fs.mkdirSync(tmp, { recursive: true });
+  for (const f of [...PKG.files, 'package.json']) {
+    const src = path.join(ROOT, f.replace(/\/$/, ''));
+    if (fs.existsSync(src)) fs.cpSync(src, path.join(tmp, f.replace(/\/$/, '')), { recursive: true });
+  }
+  fs.writeFileSync(path.join(tmp, 'install.json'), `${JSON.stringify({ install: inst }, null, 2)}\n`);
+  fs.rmSync(dest, { recursive: true, force: true }); fs.renameSync(tmp, dest);
+  process.stdout.write(`claude workflows ${PKG.version} → ${dest}\n`);
+  if (cacheDir) {
+    const projects = path.join(path.resolve(cacheDir), 'orchestrations', 'projects');
+    let n = 0;
+    for (const p of fs.readdirSync(projects)) {
+      const src = path.join(projects, p, '.prompt-cache'); const proj = path.join(inst, 'orchestrations', 'projects', p);
+      if (!fs.existsSync(src) || !fs.existsSync(proj)) continue;
+      for (const m of fs.readdirSync(src).filter((x) => x.startsWith('.complete-'))) {
+        const cl = m.replace(/^\.complete-/, '').replace(/\.brownfield$/, '');
+        if (!fs.existsSync(path.join(src, cl))) continue;
+        const dst = path.join(proj, '.prompt-cache'); fs.mkdirSync(dst, { recursive: true });
+        fs.rmSync(path.join(dst, cl), { recursive: true, force: true });
+        fs.cpSync(path.join(src, cl), path.join(dst, cl), { recursive: true });
+        fs.copyFileSync(path.join(src, m), path.join(dst, m));
+        process.stdout.write(`codeline cache: ${p} / ${cl}\n`); n += 1;
+      }
+    }
+    if (!n) process.stdout.write(`codeline cache: ${cacheDir} holds none to carry\n`);
+  }
+  process.exit(0);
+}
+
+if (cmd !== 'run') { process.stderr.write('usage: amsd-pipeline-workflow install --into <pipeline install> [--codeline-cache <dir>] | run <driver arguments> | version\n'); process.exit(64); }
 const args = [...rest];
 const linked = path.join(ROOT, 'install.json');
 if (!args.includes('--install') && fs.existsSync(linked)) args.unshift('--install', JSON.parse(fs.readFileSync(linked, 'utf8')).install);

package/driver/hook-dispatch.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+// THE AGENTS' HOOKS, IN A LIVE SESSION (2026-10-18): the real Workflow tool does not run a hook declared in a workflow
+// agent's frontmatter (tools/hook-probe.js: never fired), but does run one declared in the session's project settings, and
+// its input names the calling agent (agent_type). driver/runtime.js liveCommand installs this one PreToolUse hook there; it
+// runs the calling agent's own hook command — exactly as its definition declares it — with the same input, and passes its
+// output and exit code back unchanged. An agent with no hook for this tool passes through (no output, exit 0).
+//   node driver/hook-dispatch.js <map.json>      map: { "<agent_type>": [{ matcher, command }...] }
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+let input = '';
+process.stdin.on('data', (c) => { input += c; });
+process.stdin.on('end', () => {
+  let ev = {};
+  try { ev = JSON.parse(input); } catch { process.exit(0); }
+  const map = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+  const hooks = (map[ev.agent_type] || []).filter((h) => !h.matcher || new RegExp(`^(?:${h.matcher})$`).test(ev.tool_name || ''));
+  for (const h of hooks) {
+    const r = spawnSync('bash', ['-c', h.command], { input, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+    if (r.stdout) process.stdout.write(r.stdout);
+    if (r.stderr) process.stderr.write(r.stderr);
+    if (r.status !== 0) process.exit(r.status === null ? 1 : r.status);
+  }
+  process.exit(0);
+});

package/driver/run.js

@@ -72,6 +72,10 @@ async function main(a) {
     const ck = path.join(a.install, 'orchestrations', 'projects', a.project, 'runs', a['recorded-run'] || a.run, 'lanes', a['recorded-lane'] || Object.keys(map)[0], 'checkpoint');
     for (const f of ['roster.json', 'agent-profiles.json', 'profiles.json']) if (fs.existsSync(path.join(ck, f))) fs.copyFileSync(path.join(ck, f), path.join(project, f));
   }
+  // the run's profiles: AGENT_PROFILES_FILE defaults to the agents folder's (run-agent-orchestration.sh:404) — the run's
+  // own copy of it when no checkpoint gave one (a fresh install's project holds none); the install's is never written
+  const agentsProfiles = path.join(a.install, 'orchestrations', 'agents', 'profiles.json');
+  if (!fs.existsSync(path.join(project, 'profiles.json')) && fs.existsSync(agentsProfiles)) fs.copyFileSync(agentsProfiles, path.join(project, 'profiles.json'));
   const er = spawnSync('bash', [path.join(__dirname, 'env.sh'), a.install, a.project, a.run, runDir, set], { encoding: 'utf8', env: baseEnv, maxBuffer: 64 * 1024 * 1024 });
   if (er.status !== 0) throw new Error(`the run's environment did not load: ${er.stderr}`);
   let env = { ...JSON.parse(er.stdout), AGENT_PROFILES_FILE: path.join(project, 'profiles.json'), PIPELINE_PROFILES: path.join(project, 'profiles.json'),
@@ -84,7 +88,7 @@ async function main(a) {
     recordedPrd: a.prd ? path.resolve(a.prd) : null, docsFrom: a['docs-from'] ? path.resolve(a['docs-from']) : null,
     // --agents-stage generated (decision 40): the Codeline, Agents workflow runs, from the PRD on disk as given (--prd, its
     // codelines where the run's discovery placed them), the discovery record and the documents a run fetched
-    agentsStage: a['agents-stage'] || 'recorded', seedPrd: a.prd ? path.resolve(a.prd) : null,
+    agentsStage: a['agents-stage'] || 'recorded', seedPrd: a.prd ? path.resolve(a.prd) : null, agentsIssues: a['agents-issues'] ? path.resolve(a['agents-issues']) : null,
     agentsDiscovery: a['agents-discovery'] ? path.resolve(a['agents-discovery']) : null, agentsDocuments: a['agents-documents'] ? path.resolve(a['agents-documents']) : null,
     rewriteCodelines: (f, m) => rewriteCodelines(f, m),
     liveApproved: !!a['live-approved'], launchEnv: launch.env, standin: null };
@@ -116,8 +120,10 @@ async function main(a) {
     if (env.EPAM_BROWNFIELD === '1' && !env.JIRA_CODELINE_ROOT) missing.push('JIRA_CODELINE_ROOT');
     if (missing.length) return outcome({ status: 'failed', exit: 1, reason: `[jira] Missing required env vars: ${missing.join(' ')}` });
     // :514–529 — ingest reads Jira (a client system): the driver only takes the skip, with the PRD on disk
-    if (env.EPAM_SKIP_JIRA_INGEST !== '1') return outcome({ status: 'failed', exit: 1, reason: 'ingest reads Jira: the driver runs only with EPAM_SKIP_JIRA_INGEST=1 (the PRD on disk); a live ingest needs the operator\'s yes' });
-    if (!ctx.recordedPrd && !fs.existsSync(env.PRD_FILE)) return outcome({ status: 'failed', exit: 1, reason: `[jira] resume asked to skip ingest but no PRD exists at ${env.PRD_FILE}` });
+    // a LIVE START (--agents-issues): the story was fetched before the run (GET, operator's yes 2026-10-18) and the stage's own
+    // ingest, in its sandbox, builds the PRD from it — the driver itself reads no client system
+    if (!ctx.agentsIssues && env.EPAM_SKIP_JIRA_INGEST !== '1') return outcome({ status: 'failed', exit: 1, reason: 'ingest reads Jira: the driver runs only with EPAM_SKIP_JIRA_INGEST=1 (the PRD on disk) or a live start (--agents-issues, the story fetched before the run)' });
+    if (!ctx.agentsIssues && !ctx.recordedPrd && !fs.existsSync(env.PRD_FILE)) return outcome({ status: 'failed', exit: 1, reason: `[jira] resume asked to skip ingest but no PRD exists at ${env.PRD_FILE}` });
     if (ctx.recordedPrd) {
       fs.copyFileSync(ctx.recordedPrd, env.PRD_FILE);
       rewriteCodelines(env.PRD_FILE, map);

package/driver/runtime.js

@@ -44,9 +44,32 @@ function liveCommand({ name, script, agentsJson, args, sessionDir, env, cwd }) {
   const wfDir = path.join(home, '.claude', 'workflows');
   fs.mkdirSync(agentsDir, { recursive: true }); fs.mkdirSync(wfDir, { recursive: true });
   const defs = JSON.parse(fs.readFileSync(agentsJson, 'utf8'));
-  for (const [n, d] of Object.entries(defs)) fs.writeFileSync(path.join(agentsDir, `${n}.md`), toMarkdown(n, d));
+  // THE AGENTS' HOOKS RUN FROM THE SESSION'S PROJECT SETTINGS (driver/hook-dispatch.js): the real Workflow tool does not run
+  // a hook in a workflow agent's frontmatter, and does run one in <cwd>/.claude/settings.json, whose input names the agent
+  // (tools/hook-probe.js, 2026-10-18). The frontmatter is written without them, so nothing could ever run twice.
+  const map = {}; const matchers = new Set(); let timeout = 0;
+  for (const [n, d] of Object.entries(defs)) {
+    for (const g of (((d.hooks || {}).PreToolUse) || [])) for (const h of (g.hooks || [])) {
+      (map[n] = map[n] || []).push({ matcher: g.matcher || '', command: h.command });
+      if (g.matcher) matchers.add(g.matcher);
+      timeout = Math.max(timeout, Number(h.timeout || 0));
+    }
+    const { hooks: _h, ...noHooks } = d;
+    fs.writeFileSync(path.join(agentsDir, `${n}.md`), toMarkdown(n, noHooks));
+  }
+  const mapFile = path.join(home, '.claude', 'hook-map.json'); fs.writeFileSync(mapFile, JSON.stringify(map, null, 2));
+  const settingsFile = path.join(home, '.claude', 'settings.json');
+  let settings = {}; try { settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8')); } catch { settings = {}; }
+  const dispatch = `${JSON.stringify(process.execPath)} ${JSON.stringify(path.join(__dirname, 'hook-dispatch.js'))} ${JSON.stringify(mapFile)}`;
+  const pre = (((settings.hooks || {}).PreToolUse) || []).filter((g) => !(g.hooks || []).some((h) => String(h.command || '').includes('hook-dispatch.js')));
+  if (Object.keys(map).length) pre.push({ matcher: [...matchers].join('|') || '.*', hooks: [{ type: 'command', command: dispatch, ...(timeout ? { timeout } : {}) }] });
+  settings.hooks = { ...(settings.hooks || {}), PreToolUse: pre };
+  fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
   fs.copyFileSync(script, path.join(wfDir, `${name}.js`));
-  const prompt = `Run the workflow "${name}" with these args, exactly, and return its result as JSON: ${JSON.stringify(args || {})}`;
+  // THE RUNNER WAITS FOR ITS WORKFLOW (LIVE-AMSD-2974-3, 2026-10-18: the runner answered "It's still running in the
+  // background…" and the session exited, taking the Spec workflow down with it): it answers only with the finished result
+  // the session itself waits for its workflow (CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=0 below); the runner has no task-wait tool
+  const prompt = `Run the workflow "${name}" with these args, exactly: ${JSON.stringify(args || {})}. When it has finished, reply with its result as JSON and nothing else.`;
   const claude = (env && env.CLAUDE_BIN) || 'claude';
   const argv = [path.join(__dirname, '..', 'bin', 'bounded'), claude, '-p', prompt, '--output-format', 'json',
     '--setting-sources', 'project', '--permission-mode', 'bypassPermissions'];
@@ -73,17 +96,41 @@ function pipelineToolEnv(env) {
   try { return require(f).commandEnv(); } catch { return {}; }
 }
 
+/** The workflow's result as the session wrote it: JSON; or the last ```json fence in its closing message, prose around it
+ *  (the live CLI's answer of 2026-10-18: "The workflow finished successfully … Result: ```json {…}```"); null when there
+ *  is no JSON object to read. */
+function resultJson(text) {
+  const t = String(text || '').trim();
+  const tryParse = (x) => { try { const v = JSON.parse(x); return v && typeof v === 'object' ? v : null; } catch { return null; } };
+  const whole = tryParse(t);
+  if (whole) return whole;
+  const fences = [...t.matchAll(/```(?:json)?\s*\n([\s\S]*?)\n?```/g)].map((m) => m[1]);
+  for (let i = fences.length - 1; i >= 0; i -= 1) { const v = tryParse(fences[i].trim()); if (v) return v; }
+  return null;
+}
+
 function runLive(opts) {
   const cmd = liveCommand(opts);
   if (process.env.EPAM_DRIVER_LIVE_APPROVED !== 'yes' || opts.approved !== true) {
     throw new Error(`live runtime refused: a live run spends tokens and needs the operator's yes (EPAM_DRIVER_LIVE_APPROVED=yes and --live-approved). It would run: (cd ${cmd.cwd} && ${cmd.argv.map((x) => JSON.stringify(x)).join(' ')})`);
   }
-  const r = spawnSync(cmd.argv[0], cmd.argv.slice(1), { cwd: cmd.cwd, env: { ...process.env, ...(opts.env || {}) }, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+  // NO IDLE CAP ON THE WAIT FOR THE WORKFLOW (Claude Code docs, headless "Background tasks at exit": a `-p` run "stops whatever
+  // is still running after 10 minutes of continuous idle waiting by default and drops its partial result … set
+  // CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS … to 0 to wait without one"): LIVE-AMSD-2974-3's Spec (16 min) and -4's first leg
+  // (11 min) were cut there. The session's stderr is kept beside it as evidence.
+  const r = spawnSync(cmd.argv[0], cmd.argv.slice(1), { cwd: cmd.cwd, env: { CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: '0', ...process.env, ...(opts.env || {}) }, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+  try { fs.mkdirSync(opts.sessionDir, { recursive: true }); fs.writeFileSync(path.join(opts.sessionDir, `${opts.name}.stderr`), String(r.stderr || '')); } catch { /* evidence only */ }
   if (r.status !== 0) throw new Error(`the live session for ${opts.name} exited ${r.status}: ${(r.stderr || '').slice(-2000)}`);
   const out = JSON.parse(r.stdout);
-  const res = typeof out.result === 'string' ? JSON.parse(out.result) : out.result;
-  // the session's own cost figure (decision 41a): driver/session-cost.js finds its transcripts by this id
-  return { ...res, __session: { sessionId: out.session_id, modelUsage: out.modelUsage || {}, totalCostUsd: out.total_cost_usd } };
+  // the session's own cost figure (decision 41a), taken BEFORE its answer is read: an answer that cannot be read must
+  // never lose what the session spent (found by tools/cost-probe.js, 2026-10-18). driver/session-cost.js finds its
+  // transcripts by this id.
+  const __session = { sessionId: out.session_id, modelUsage: out.modelUsage || {}, totalCostUsd: out.total_cost_usd };
+  const res = typeof out.result === 'string' ? resultJson(out.result) : out.result;
+  if (!res || typeof res !== 'object') {
+    return { status: 'failed', exit: 1, reason: `the ${opts.name} session's answer is not JSON: ${String(out.result).slice(0, 300)}`, __session };
+  }
+  return { ...res, __session };
 }
 
 async function runStandin({ script, agentsJson, args, env, standin, sessionDir }) {

package/driver/session-cost.js

@@ -36,6 +36,30 @@ function transcriptTokens(file) {
   return byModel;
 }
 
+/** ONE AGENT CALL'S CONTENT, AS THE PIPELINE TRACES EACH OF ITS CALLS (lib/cost-emitter.js emitCostSnapshot: input =
+ *  promptForTrace, the call's prompt; output = replyTextFrom, its reply; toolCalls = transcript-tool-calls.js
+ *  toolCallsInTranscript, read from the call's own transcript). For a workflow agent: its prompt is the first user turn of its
+ *  transcript, its reply the answer it gave (its StructuredOutput, else its last text), its tool calls by the pipeline's own
+ *  reader. Operator, 2026-10-18: "I need all llm calls captured"; "Did you not read the code from the current pipeline?" */
+function callContent(file, scriptsDir, agentName) {
+  const lines = fs.readFileSync(file, 'utf8').split('\n').filter((l) => l.trim()).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  const first = lines.find((d) => d.type === 'user' && d.message);
+  const asst = lines.filter((d) => d.type === 'assistant' && d.message && Array.isArray(d.message.content)).flatMap((d) => d.message.content);
+  const so = asst.filter((b) => b && b.type === 'tool_use' && b.name === 'StructuredOutput').pop();
+  const text = asst.filter((b) => b && b.type === 'text' && b.text).map((b) => b.text).pop();
+  // eslint-disable-next-line global-require, import/no-dynamic-require
+  const tx = require(path.join(scriptsDir, 'lib', 'transcript-tool-calls.js'));
+  const ts = lines.map((d) => d.timestamp).filter(Boolean);
+  // the agent's standing instructions: its definition in the session's folder (<cwd>/.claude/agents/<agent>.md, written by
+  // driver/runtime.js liveCommand) — sent to the model as its system prompt, not in the transcript
+  const cwd = (lines.find((d) => d.cwd) || {}).cwd; const agentType = (lines.find((d) => d.agentType) || {}).agentType || agentName;
+  let system = '';
+  try { const md = fs.readFileSync(path.join(cwd, '.claude', 'agents', `${agentType}.md`), 'utf8'); system = md.replace(/^---[\s\S]*?\n---\n+/, ''); } catch { system = ''; }
+  const prompt = first ? first.message.content : '';
+  return { input: system ? { system, prompt } : prompt, output: so ? JSON.stringify(so.input) : (text || ''),   // text: the emitter's output is text
+    toolCalls: tx.toolCallsInTranscript(file), startedAt: ts[0] || null, endedAt: ts[ts.length - 1] || null };
+}
+
 /** The session's folder under the Claude projects folder (found by its id: the folder name is Claude Code's own). */
 function sessionDir(projectsDir, sessionId) {
   if (!sessionId || !fs.existsSync(projectsDir)) return null;
@@ -51,7 +75,7 @@ function sessionEntries(projectsDir, sessionId) {
   const s = sessionDir(projectsDir, sessionId);
   if (!s) return null;
   const out = [];
-  const push = (agent, label, file) => { for (const [model, tokens] of Object.entries(transcriptTokens(file))) out.push({ agent, label, model, tokens }); };
+  const push = (agent, label, file) => { for (const [model, tokens] of Object.entries(transcriptTokens(file))) out.push({ agent, label, model, tokens, file }); };
   push('workflow-runner', 'workflow-runner', s.main);
   const runs = path.join(s.dir, 'subagents', 'workflows');
   if (fs.existsSync(runs)) {
@@ -108,8 +132,11 @@ function recordSession(env, session, { stage, storyId, phase, projectsDir, log }
         rows.push(appendLedgerRecord({ ledgerFile: ledger, agent: e.agent, storyId, phase, model: e.model,
           cost: { costUsd: e.costUsd, tokensIn: e.tokens.in, tokensOut: e.tokens.out, tokensCached: e.tokens.cacheRead, tokensCacheCreate: e.tokens.cacheCreate,
             costIsEstimate: true, costUnknown: e.costUnknown } }));
-        // traced as the pipeline's cost seam traces each call (lib/cost-emitter.js → lib/langfuse-emit.js); off without keys
-        traces.push(emitGeneration({ agent: e.agent, storyId, phase, model: e.model, costUsd: e.costUsd, tokensIn: e.tokens.in, tokensOut: e.tokens.out,
+        // each agent call to Langfuse with its prompt, its answer and its tool calls, as the pipeline's cost seam traces each
+        // of its calls (lib/cost-emitter.js → lib/langfuse-emit.js); off without keys
+        const c = e.file ? callContent(e.file, env.SCRIPT_DIR, e.agent) : {};
+        traces.push(emitGeneration({ agent: e.agent, storyId, phase, model: e.model, startedAt: c.startedAt, endedAt: c.endedAt,
+          input: c.input, output: c.output, toolCalls: c.toolCalls, costUsd: e.costUsd, tokensIn: e.tokens.in, tokensOut: e.tokens.out,
           cacheRead: e.tokens.cacheRead, cacheCreate: e.tokens.cacheCreate, costIsEstimate: true }, { ...process.env, ...env }));
       }
       if (log) log(`[cost] ${stage}: ${rows.length} row(s), $${Number(session.totalCostUsd || 0).toFixed(4)} (the session's own figure; per call by tokens, estimated)`);
@@ -129,4 +156,4 @@ function recordSession(env, session, { stage, storyId, phase, projectsDir, log }
   }
 }
 
-module.exports = { recordSession, sessionEntries, allocate, transcriptTokens };
+module.exports = { recordSession, sessionEntries, allocate, transcriptTokens, callContent };

package/driver/stages.js

@@ -38,14 +38,22 @@ async function runCodelineAgents(ctx) {
 // the roster, briefs and prompts linked at the pause. Then the driver's own post-roster checkpoint and pause, as above.
 async function runGeneratedAgents(ctx) {
   const { env, log } = ctx;
-  for (const k of ['seedPrd', 'agentsDiscovery']) if (!ctx[k]) return { status: 'failed', exit: 1, reason: `the generated Codeline, Agents stage needs --${k === 'seedPrd' ? 'prd' : 'agents-discovery'}` };
+  // LIVE START (--agents-issues, operator 2026-10-18: reuse only the agents and prompts): the issues the tracker returned
+  // for this run, fetched live before it; the stage's own ingest builds the PRD and runs codeline discovery. Otherwise the
+  // PRD on disk and a recorded discovery (decision 37).
+  const liveStart = !!ctx.agentsIssues;
+  if (!liveStart) for (const k of ['seedPrd', 'agentsDiscovery']) if (!ctx[k]) return { status: 'failed', exit: 1, reason: `the generated Codeline, Agents stage needs --${k === 'seedPrd' ? 'prd' : 'agents-discovery'} (or --agents-issues)` };
   const w1 = path.join(ctx.runDir, 'w1'); const out = path.join(w1, 'gen'); const state = path.join(w1, 'state'); const estate = path.join(w1, 'estate');
   fs.rmSync(w1, { recursive: true, force: true }); fs.mkdirSync(estate, { recursive: true });
   const root = env.JIRA_CODELINE_ROOT;
   if (!root) return { status: 'failed', exit: 1, reason: 'JIRA_CODELINE_ROOT is unset: the stage cannot place the codelines' };
   // the estate: a directory per codeline the discovery names under the root — this run's copy mounted over it, an empty
   // repository where the run has none (the prompts name only directories and paths)
-  const disc = JSON.parse(fs.readFileSync(ctx.agentsDiscovery, 'utf8'));
+  // the estate: with a recorded discovery, its codelines; live, every codeline copy of this run (each where it lies, under the root)
+  // live: every codeline copy, placed at <root>/<its folder> inside the sandbox — the copy itself stays where it is, outside
+  // the root (a copy inside the root would be hidden by the estate laid over the root first)
+  const disc = liveStart ? { codelines: Object.entries(ctx.map).map(([name, p]) => ({ name, path: path.join(root, path.basename(p)) })) } : JSON.parse(fs.readFileSync(ctx.agentsDiscovery, 'utf8'));
+  for (const p of Object.values(ctx.map)) if (path.dirname(p) === root) return { status: 'failed', exit: 1, reason: `the codeline copy ${p} lies inside the codeline root ${root}: the stage's estate would hide it — keep copies outside the root` };
   const mounts = [];
   for (const c of disc.codelines || []) {
     if (path.dirname(c.path) !== root) return { status: 'failed', exit: 1, reason: `discovery places ${c.name} at ${c.path}, outside the codeline root ${root}` };
@@ -55,15 +63,16 @@ async function runGeneratedAgents(ctx) {
   }
   const first = (disc.codelines || []).map((c) => ctx.map[c.name]).find(Boolean);
   if (!first) return { status: 'failed', exit: 1, reason: 'no codeline the discovery names has a copy in --codeline-map' };
-  const issues = path.join(w1, 'issues.json'); fs.writeFileSync(issues, '[]\n');   // the ingest is skipped (decision 37)
+  const issues = path.join(w1, 'issues.json');
+  if (liveStart) fs.copyFileSync(ctx.agentsIssues, issues); else fs.writeFileSync(issues, '[]\n');   // decision 37: no ingest
   gen('generate-agents.js', ['--install', ctx.install, '--project', ctx.project, '--run', ctx.run, '--out', out, '--state', state,
     '--codeline-root', root, '--estate', estate, '--codeline', first, '--issues', issues, '--set', ctx.set, ...mounts,
-    '--seed-prd', ctx.seedPrd, '--seed-log', `codeline-discovery.json=${ctx.agentsDiscovery}`,
+    ...(liveStart ? [] : ['--seed-prd', ctx.seedPrd, '--seed-log', `codeline-discovery.json=${ctx.agentsDiscovery}`]),
     ...(ctx.agentsDocuments ? ['--documents', ctx.agentsDocuments] : []), ...(env.JIRA_TICKET ? ['--ticket', env.JIRA_TICKET] : []),
     ...(env.EPAM_ESTIMATION_MANIFEST ? ['--estimation-manifest', env.EPAM_ESTIMATION_MANIFEST] : [])], env);
   const plan = JSON.parse(fs.readFileSync(path.join(out, 'plan.json'), 'utf8'));
   const res = await runtime.run({ runtime: ctx.runtime, log: ctx.log, name: 'codeline-agents', script: path.join(out, 'workflows', 'codeline-agents.js'),
-    agentsJson: path.join(out, 'agents.json'), args: withFeatures(ctx, {}), env: { ...env, EPAM_SKIP_JIRA_INGEST: '1' },
+    agentsJson: path.join(out, 'agents.json'), args: withFeatures(ctx, {}), env: liveStart ? (({ EPAM_SKIP_JIRA_INGEST: _s, ...rest }) => rest)(env) : { ...env, EPAM_SKIP_JIRA_INGEST: '1' },   // a live start runs the stage's own ingest
     standin: ctx.standin && ctx.standin('codeline-agents', { plan, out }), sessionDir: path.join(out, 'session'), approved: ctx.liveApproved });
   log(`[driver] Codeline, Agents: ${res.status}${res.reason ? ` — ${res.reason}` : ''} (${res.calls || 0} question(s); phases: ${(res.phases || []).join(' → ') || 'none'})`);
   fs.writeFileSync(path.join(w1, 'result.json'), JSON.stringify(res, null, 2));

package/generator/agents-workflow.js

@@ -18,8 +18,21 @@ function emit(plan) {
   return `export const meta = {
   name: 'codeline-agents',
   description: 'Codeline, Agents stage: reset, resume, ingest (discovery, AC gate, PRD), agents (survey, mint, roster, roles, prompts), pause 1',
-  phases: [{ title: 'Codeline, Agents' }, ...${JSON.stringify(plan.stagePhases.map((x) => ({ title: x.title })))}],
+  phases: ${JSON.stringify([{ title: 'Codeline, Agents' }, ...plan.stagePhases.map((x) => ({ title: x.title }))])},
 }
+
+// AN AGENT THAT NEVER CALLS StructuredOutput: the real Workflow tool throws for it ("subagent completed without calling
+// StructuredOutput"), it does not return null — LIVE-AMSD-2974-4b's Spec stage died on it. The pipeline takes the same
+// failure as no answer (runAgentForJson), so it is null here and the caller's own no-answer path follows. Any other error
+// (an abort, the budget) still stops the run.
+async function agentOrNull(prompt, opts) {
+  try { return await agent(prompt, opts) } catch (e) {
+    if (!/without calling StructuredOutput/.test(String(e && e.message))) throw e
+    log(\`\${(opts && opts.label) || 'an agent'}: no StructuredOutput — taken as no answer\`)
+    return null
+  }
+}
+
 // GENERATED by amsd-pipeline-workflow/generator — do not edit. Source: ${plan.source}
 const PLAN = ${JSON.stringify(plan)}
 const REPLY = ${JSON.stringify(REPLY_SCHEMA)}
@@ -69,11 +82,11 @@ async function ask(step, req) {
   }
   calls++
   asked.push({ step, phase: phaseAt >= 0 ? PLAN.stagePhases[phaseAt].title : null, agent: req.agent, model: req.model })
-  const a = await agent(req.prompt, { agentType, ...(req.model ? { model: req.model } : {}), ...(req.effort ? { effort: req.effort } : {}),
+  const a = await agentOrNull(req.prompt, { agentType, ...(req.model ? { model: req.model } : {}), ...(req.effort ? { effort: req.effort } : {}),
     schema: REPLY, label: \`\${step}: \${req.agent} (#\${calls})\`, phase: phaseAt >= 0 ? PLAN.stagePhases[phaseAt].title : 'Codeline, Agents' })
   if (a && a.step) return a.step
   log(\`\${step}: \${req.agent} gave no answer — the pipeline is told the call failed\`)
-  const f = await agent('Reply now.', { agentType: PLAN.runners.failed, schema: RUN, label: \`\${step}: \${req.agent} failed\`, phase: 'Codeline, Agents' })
+  const f = await agentOrNull('Reply now.', { agentType: PLAN.runners.failed, schema: RUN, label: \`\${step}: \${req.agent} failed\`, phase: 'Codeline, Agents' })
   return (f && f.step) || { step, error: 'the failed-call step runner gave no result' }
 }
 
@@ -81,7 +94,7 @@ phase('Codeline, Agents')
 for (const step of PLAN.steps) {
   // Decision 18: the agents step without the project prompt layer, when 'project-prompts' is off.
   const runner = (step === 'agents' && !FEATURES.includes('project-prompts')) ? PLAN.runners['agents:no-project-prompts'] : PLAN.runners[step]
-  const s = await agent('Reply now.', { agentType: runner, schema: RUN, label: \`step \${step}\`, phase: 'Codeline, Agents' })
+  const s = await agentOrNull('Reply now.', { agentType: runner, schema: RUN, label: \`step \${step}\`, phase: 'Codeline, Agents' })
   let r = (s && s.step) || { step, error: 'the step runner gave no result' }
   while (r.needs) {
     if (calls >= PLAN.maxCalls) return done({ status: 'stopped', exit: 1, step, reason: \`the stage reached its question cap (\${PLAN.maxCalls}) inside step \${step}\` })

package/generator/gateway.js

@@ -0,0 +1,40 @@
+'use strict';
+// THE GATEWAY EVERY GENERATED WORKFLOW ASKS ITS AGENTS THROUGH (Spec, Writer) — defined once, included by each template
+// (generator/spec-workflow.js, generator/writer-workflow.js). The workflow-script code lives in gateway.wf.js (the gateway)
+// and mailbox.wf.js (agent-to-agent messages); it needs PLAN.call {attempts, failed, story, agents}, PLAN.messages, the
+// workflow's agentOrNull and log.
+const fs = require('fs');
+const path = require('path');
+const text = `\n${fs.readFileSync(path.join(__dirname, 'gateway.wf.js'), 'utf8')}`;
+const mailbox = `\n${fs.readFileSync(path.join(__dirname, 'mailbox.wf.js'), 'utf8')}`;
+
+/**
+ * The gateway's text for a plan: the mailbox only when the stage has messaging (plan.messages), its delivery wording the
+ * shared component's own deliveryBlock (lib/agent-messages.js), embedded at generation so it is defined once.
+ */
+function textFor(plan) {
+  if (!plan.messages) return `\nconst deliveryBlock = () => ''\nfunction withMessages(s) { return s }\nfunction mailFor() { return [] }\nfunction post() {}\nconst MAILBOX = {}\n${text}`;
+  return `\nconst deliveryBlock = ${plan.messages.deliverySrc}\n${mailbox}\n${text}`;
+}
+
+/**
+ * Messaging for a stage: every agent definition (not the step runners) gets the hook that writes its messages to the
+ * run's bus; the agents map (definition → pipeline agent) is written; the plan's messages settings returned. Off, and
+ * said, when the shared component is not installed (no lib/agent-messages.js in the install).
+ */
+function messagesSetup({ defs, outDir, busDir, router, story, install, scripts }) {
+  const lib = path.join(scripts, 'lib', 'agent-messages.js');
+  if (!fs.existsSync(lib)) { process.stderr.write(`[generate] messages OFF: the shared component is not installed (${lib})\n`); return null; }
+  const map = Object.fromEntries(defs.filter((d) => !d.name.startsWith('pipeline-step-')).map((d) => [d.name, d.pipelineAgent || d.name]));
+  const mapFile = path.join(outDir, 'messages-agents.json'); fs.writeFileSync(mapFile, JSON.stringify(map, null, 2));
+  const q = (x) => `'${String(x).replace(/'/g, "'\\''")}'`;
+  const cmd = [process.execPath, path.resolve(__dirname, '..', 'hooks', 'messages-out.js'), 'answer', '--bus', busDir, '--map', mapFile, '--router', router,
+    '--install', install, ...(story ? ['--story', story] : [])].map(q).join(' ');
+  for (const d of defs) {
+    if (d.name.startsWith('pipeline-step-')) continue;
+    d.frontmatter.hooks = d.frontmatter.hooks || {};
+    d.frontmatter.hooks.PreToolUse = [...(d.frontmatter.hooks.PreToolUse || []), { matcher: 'StructuredOutput', hooks: [{ type: 'command', command: cmd }] }];
+  }
+  return { router, bus: busDir, deliverySrc: require(lib).deliveryBlock.toString() };
+}
+module.exports = { text, textFor, messagesSetup };

package/generator/gateway.wf.js

@@ -0,0 +1,38 @@
+// EVERY AGENT CALL THROUGH THE PIPELINE'S GATEWAY (llm-handler.sh "UNIFORM CALL RESILIENCE" :977–1090; operator 2026-10-18:
+// retries and self-heal for ALL agents). An attempt that produced no usable answer — no answer at all, or no
+// StructuredOutput — goes to the gateway's failed-call step (hooks/step-call-failed.sh: the failure on the agent's ladder,
+// its next rung, the previous-refusal block, the KB episode, by the pipeline's own functions), and the call is asked again
+// on that rung with that block, up to the hub's EPAM_CALL_MAX_ATTEMPTS. Only then is it no answer, and the caller's own
+// no-answer path runs. A call that answers is asked once. Step runners are not agents: asked once.
+const CALLSTEP = { type: 'object', properties: { done: { type: 'boolean' }, call: { type: 'object' } } }
+async function agentCall(prompt, opts) {
+  const who = (PLAN.call && PLAN.call.agents || {})[opts.agentType]
+  if (!who) return agentOrNull(prompt, opts)
+  const story = (String(opts.label || '').match(/^([A-Z][A-Z0-9]+-\d+):/) || [])[1] || PLAN.call.story || 'global'
+  const mail = mailFor(who.agent)
+  let model = opts.model || who.model, p = prompt + deliveryBlock(mail), attempt = 1
+  const schema = withMessages(opts.schema)
+  for (; ; attempt++) {
+    let a = null, why = ''
+    try { a = await agent(p, { ...opts, ...(schema ? { schema } : {}), ...(model ? { model } : {}) }) } catch (e) {
+      if (!/without calling StructuredOutput/.test(String(e && e.message))) throw e
+      why = 'the agent ended without calling StructuredOutput — its answer was never submitted'
+    }
+    if (a !== null && a !== undefined) {
+      if (mail.length) MAILBOX[who.agent] = []
+      if (a && typeof a === 'object' && a.messages) post(who.agent, a.messages)
+      return a
+    }
+    if (!why) why = 'the agent produced no answer'
+    if (attempt >= PLAN.call.attempts) break
+    const f = await agentOrNull(`Reply at once with this structured answer, copied exactly: ${JSON.stringify({ done: true, call: { agent: who.agent, model, story, reason: why, attempt } })}`,
+      { agentType: PLAN.call.failed, schema: CALLSTEP, label: `${opts.label || who.agent}: call failed (attempt ${attempt}/${PLAN.call.attempts})`, phase: opts.phase })
+    const r = f && f.result
+    if (!r || r.error || r.ran === false) { log(`${opts.label || who.agent}: the gateway's failed-call step gave no result (${r ? r.reason : 'no answer'}) — no further attempt`); break }
+    log(`${opts.label || who.agent}: ${r.line}${r.episode ? ' · KB episode recorded' : ' · NO KB episode'}`)
+    if (r.model) model = r.model
+    p = p + (r.block || '')
+  }
+  log(`${opts.label || who.agent}: no usable answer after ${attempt} attempt(s) — taken as no answer`)
+  return null
+}

package/generator/generate-agents.js

@@ -84,6 +84,29 @@ function hubSi(art, agent, codelineRoot, work, projectEnv) {
   return relativizeLocalPaths(fs.readFileSync(out, 'utf8'), [codelineRoot]);
 }
 
+/** THE ROSTER THE RUN STARTS FROM (lib/mint-and-spec.sh:156–232). When this run's codeline has a completion marker and a
+ *  recorded roster, the pipeline restores that roster before the mint (both of its reuse branches, :170–175 and :183–192)
+ *  and the hub reads each agent's SI from it at call time; the stage's agents are generated from that roster — by the
+ *  pipeline's own restoreMinted, on a scratch copy of the project (the install is never written). Otherwise the project's
+ *  roster as it is. The codeline: EPAM_CODELINE_ID, else the PRD's single output folder (codelineFromPrd, :157–165). */
+function siProjectDir(art, prdFile, projectEnv, work) {
+  const env = { ...process.env, ...projectEnv };
+  if (env.EPAM_REGENERATE_CODELINE_ASSETS === '1') return art.projectDir;
+  const b = require(path.join(art.scripts, 'lib', 'project-prompt-builder.js'));
+  const cl = String(env.EPAM_CODELINE_ID || '').trim() || b.codelineFromPrd(prdFile);
+  if (!cl) return art.projectDir;
+  const marker = path.join(art.projectDir, '.prompt-cache', `.complete-${cl}${env.EPAM_BROWNFIELD === '1' ? '.brownfield' : ''}`);   // prompt-variant.sh:15–21
+  if (!fs.existsSync(marker) || !b.hasMintedSnapshot({ projectConfigDir: art.projectDir, codeline: cl })) return art.projectDir;
+  const dir = path.join(work, 'si-project'); fs.rmSync(dir, { recursive: true, force: true }); fs.mkdirSync(dir, { recursive: true });
+  for (const f of fs.readdirSync(art.projectDir)) {
+    if (f === 'runs' || f === 'prompts') continue;
+    if (f === '.prompt-cache') fs.symlinkSync(path.join(art.projectDir, f), path.join(dir, f));
+    else fs.cpSync(path.join(art.projectDir, f), path.join(dir, f), { recursive: true });
+  }
+  b.restoreMinted({ projectConfigDir: dir, codeline: cl });
+  return dir;
+}
+
 function stepRunner(name, description, hookArgs, firstTier) {
   return { name, pipelineAgent: null, seam: null, ladder: '',
     frontmatter: { name, description, model: firstTier.startModel,
@@ -158,8 +181,9 @@ function main(a) {
   const scratch = path.join(work, 'seam'); fs.mkdirSync(scratch, { recursive: true });
   const defs = []; const agentMap = {}; const si = {}; const noSi = [];
   const projectEnv = pipe.projectEnv(art);
+  const siArt = { ...art, projectDir: siProjectDir(art, seedPrd, projectEnv, work) };
   for (const s of seamNames) {
-    const body = hubSi(art, s, path.resolve(a['codeline-root']), work, projectEnv);
+    const body = hubSi(siArt, s, path.resolve(a['codeline-root']), work, projectEnv);
     // A seam the hub has no SI for is a call the hub itself refuses (llm-handler.sh: "refusing the call"); it gets no
     // agent here either, and is listed.
     if (body == null) { noSi.push(s); continue; }

package/generator/generate-spec.js

@@ -250,6 +250,15 @@ function main(a) {
         ...((firstTier.rungs || [])[0] && firstTier.rungs[0].reasoningEffort ? { effort: firstTier.rungs[0].reasoningEffort } : {}),
         maxTurns: 3, tools: [], omitClaudeMd: true, hooks: hook(event, extra) },
       body: 'Reply at once by giving your structured answer {"done": true}. Do nothing else: a hook runs the step, and its result is the answer.' }); return name; };
+    // THE GATEWAY'S FAILED-CALL STEP (hooks/step-call-failed.sh, through the step runners' hook hooks/pipeline-step.js):
+    // the same step the Writer's gateway hands a failed call to — the pipeline's ladder, previous-refusal and KB episode.
+    defs.push({ name: 'pipeline-step-call-failed', pipelineAgent: null, seam: null, ladder: '',
+      frontmatter: { name: 'pipeline-step-call-failed', description: "Hands a failed agent call to the pipeline's gateway step (its hook decides).",
+        model: firstTier.startModel, ...((firstTier.rungs || [])[0] && firstTier.rungs[0].reasoningEffort ? { effort: firstTier.rungs[0].reasoningEffort } : {}),
+        maxTurns: 3, tools: [], omitClaudeMd: true,
+        hooks: { PreToolUse: [{ matcher: 'StructuredOutput', hooks: [{ type: 'command', command: [process.execPath,
+          path.resolve(__dirname, '..', 'hooks', 'pipeline-step.js'), 'answer', '--step', 'call-failed', '--pipeline', pjFile, '--state', state].map(q).join(' ') }] }] } },
+      body: 'Reply at once by giving your structured answer: {"done": true, "call": <the JSON object your task gives, copied exactly>}. Do nothing else: a hook runs the step, and its result is the answer.' });
     const A = { assign: copy(bases.coordinator, 'spec-assign', 'assign', [], 'the spec agents\' assignment'),
       review: copy(bases.coordinator, 'spec-review', 'review', [], 'the coordinator\'s review of the specs'),
       model: copy(bases.coordinator, 'spec-model', 'model', [], 'the model review'),
@@ -390,6 +399,13 @@ function main(a) {
     P.assign = rel(P.assign); P.review = rel(P.review); P.model = rel(P.model);
     for (const sid of Object.keys(P.stories)) for (const k of Object.keys(P.stories[sid])) P.stories[sid][k] = rel(P.stories[sid][k]);
     for (const d of defs) d.body = rel(d.body);
+    // EVERY AGENT CALL THROUGH THE GATEWAY (generator/gateway.js): the pipeline agent each definition stands for and its
+    // start model; the step runners are asked once. A Spec call names its story in its label; others are run-wide.
+    plan.call = { attempts: Number(process.env.EPAM_CALL_MAX_ATTEMPTS || 3), failed: 'pipeline-step-call-failed', story: 'global',
+      agents: Object.fromEntries(defs.filter((d) => !d.name.startsWith('pipeline-step-')).map((d) => [d.name, { agent: d.pipelineAgent || d.name, model: d.frontmatter.model || '' }])) };
+    // AGENT-TO-AGENT MESSAGES (generator/gateway.js messagesSetup): the coordinator (its review) is the Spec stage's router
+    plan.messages = require('./gateway.js').messagesSetup({ defs, outDir: a.out, busDir: path.join(state, 'messages'),
+      router: (defs.find((d) => d.name === A.review) || {}).pipelineAgent || A.review, install: a.install, scripts: art.scripts });
     return { plan, defs };
   });