amsd-pipeline-workflow 0.1.1 → 0.1.6

package/README.md

@@ -1,24 +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
 
-Into an existing AMSD pipeline install (the pipeline itself is not changed):
+Three steps, in this order, into one install:
 
 ```bash
-npx amsd-pipeline@<version> --dest <dir> --ref v<version> --no-docker     # the pipeline, as always
-npx amsd-pipeline-workflow install --into <dir> [--codeline-cache <cache>]
+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
 ```
 
-This writes only `<dir>/claude-workflows/` and, with `--codeline-cache`, each codeline's cached roster and prompts
+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/`.
+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
@@ -29,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/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

@@ -88,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 };
@@ -120,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,44 @@ 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;
+  // THE SESSION'S ANSWER, KEPT (the self-heal listener, tools/live-tracker.js): a stage ended by an agent error the gateway
+  // did not take must be visible in the run's own records — the driver logs only "failed".
+  try { fs.writeFileSync(path.join(opts.sessionDir, `${opts.name}.result.json`), `${JSON.stringify(res && typeof res === 'object' ? res : { status: 'failed', unreadable: String(out.result).slice(0, 2000) }, null, 2)}\n`); } catch { /* evidence only */ }
+  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

@@ -1,4 +1,5 @@
 'use strict';
+const gateway = require('./gateway.js');
 // THE CODELINE, AGENTS WORKFLOW: plan (data) + emitted script (decisions 10, 15, 16, 25).
 //
 // The script holds the stage's ORDER — the pipeline's own: the launcher's reset (orchestrate.sh), the resume
@@ -18,8 +19,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 (!${gateway.NO_ANSWER}.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 +83,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 +95,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,46 @@
+'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');
+// AN ANSWER THE AGENT NEVER GAVE IN USABLE FORM — the Workflow tool's own errors for it: the agent ended without calling
+// StructuredOutput; or it called it and its output never matched the schema (the tool's retry cap). Each is a failed call,
+// as the pipeline takes it (no usable output); any other error (an abort, the budget) is not. Defined once, used by the
+// gateway and by every template's agentOrNull. (LIVE-AMSD-2974-4b: the retry-cap error went unrecognised and took the
+// Writer down.)
+const NO_ANSWER = String.raw`/without calling StructuredOutput|StructuredOutput retry cap|does not match required schema/`;
+const text = `\n${fs.readFileSync(path.join(__dirname, 'gateway.wf.js'), 'utf8')}`.split('__NO_ANSWER__').join(NO_ANSWER);
+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, NO_ANSWER };

package/generator/gateway.wf.js

@@ -0,0 +1,40 @@
+// 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) {
+      const msg = String(e && e.message)
+      if (!__NO_ANSWER__.test(msg)) throw e
+      why = /without calling StructuredOutput/.test(msg) ? 'the agent ended without calling StructuredOutput — its answer was never submitted'
+        : `the answer did not match its required format (${msg.replace(/^[\s\S]*?(StructuredOutput error: |does not match)/, '$1').slice(0, 400)}) — give the answer in exactly that format`
+    }
+    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-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 };
   });
 

package/generator/generate.js

@@ -232,6 +232,17 @@ function main(a) {
           path.resolve(__dirname, '..', 'hooks', 'pipeline-step.js'), 'answer', '--step', step, '--pipeline', pipelineJson, '--state', checksState].map(q).join(' ') }] }] } },
       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.' });
   }
+  // THE GATEWAY'S FAILED-CALL STEP (hooks/step-call-failed.sh; llm-handler.sh "UNIFORM CALL RESILIENCE"): after an agent call
+  // that produced no usable answer the workflow hands this runner the call ({agent, model, story, reason, attempt}); its hook
+  // records the failure on the agent's ladder, resolves the next rung, renders the previous-refusal block and records the
+  // KB episode — the pipeline's own functions — and the workflow re-asks on what it returns.
+  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', pipelineJson, '--state', checksState].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.' });
   // THE DYNAMIC TOOL'S REVIEW (failure-healing.sh _write_reviewed_dynamic_tool → prd-change-review.sh
   // run_change_with_reviewer_retry "tool_creation"): the prd-change-reviewer under its own name for this change type, its
   // hook writing the tool on "pass" (hooks/tool-record.js review); the prd-change-summarizer, its hook post-processing the
@@ -387,6 +398,11 @@ function main(a) {
         path.resolve(__dirname, '..', 'hooks', 'pipeline-step.js'), 'answer', '--step', 'no-change', '--pipeline', pipelineJson, '--state', checksState].map(q).join(' ') }] }] } } });
   }
   for (const d of defs) d.body = rel(d.body);
+  // AGENT-TO-AGENT MESSAGES (generator/gateway.js messagesSetup): the reviewer is the Writer's router; the bus is the stage's.
+  // Before the definitions are written: it adds the messages hook to each.
+  fs.mkdirSync(a.out, { recursive: true });
+  const messagesPlan = require('./gateway.js').messagesSetup({ defs, outDir: a.out, busDir: path.join(checksState, 'messages'),
+    router: (defs.find((d) => d.name === nameOf(roles.reviewer)) || {}).pipelineAgent || nameOf(roles.reviewer), story: a.story, install: a.install, scripts: art.scripts });
   agents.writeDefinitions(defs, path.join(a.out, 'agents'));
 
   // THE CHECKS BASELINE, recorded once on the untouched pause-2 copy by the codeline's own declarations (D5, C1).
@@ -577,6 +593,11 @@ function main(a) {
   // The bases travel to the script: values filled at run time pass through the same rewrite when sent (the hub does it).
   plan.relativeBases = bases;
   for (const k of ['analyst', 'reviewer', 'changeReviewer', 'remediator']) fs.writeFileSync(path.join(a.out, 'prompts', `${k}.md`), plan.prompts[k]);
+  // EVERY AGENT CALL THROUGH THE GATEWAY: the pipeline agent each definition stands for and the model it starts on (the
+  // ladder steps from it); the step runners are not agents and are asked once. EPAM_CALL_MAX_ATTEMPTS as the hub reads it.
+  plan.call = { attempts: Number(process.env.EPAM_CALL_MAX_ATTEMPTS || 3), failed: 'pipeline-step-call-failed', story: a.story,
+    agents: Object.fromEntries(defs.filter((d) => !d.name.startsWith('pipeline-step-')).map((d) => [d.name, { agent: d.pipelineAgent || d.name, model: d.frontmatter.model || '' }])) };
+  plan.messages = messagesPlan;
   fs.writeFileSync(path.join(a.out, 'plan.json'), JSON.stringify(plan, null, 2));
   fs.mkdirSync(path.join(a.out, 'workflows'), { recursive: true });
   fs.writeFileSync(path.join(a.out, 'workflows', 'writer.js'), writerWorkflow.emit(plan));

package/generator/mailbox.wf.js

@@ -0,0 +1,20 @@
+// THE MAILBOX (agent-to-agent messages, the shared component lib/agent-messages.js; operator 2026-10-18): what agents send
+// with their answers (`messages`), held for the recipient's next call and put at the end of its prompt — the hook
+// (hooks/messages-out.js) has already written them to the run's bus and marks them read when the recipient answers.
+// "router" or no recipient → the stage's router. None of this asks a model: no extra call.
+const MAILBOX = {}
+const MSG_FIELD = { type: 'array', description: 'Optional: messages to other agents on this run — each {to: an agent name, or "router" (the stage\'s router), type, subject, text}.',
+  items: { type: 'object', required: ['subject', 'text'], properties: { to: { type: 'string' }, type: { type: 'string' }, subject: { type: 'string' }, text: { type: 'string' } } } }
+function withMessages(schema) {
+  if (!PLAN.messages || !schema || typeof schema !== 'object' || !schema.properties || schema.properties.messages) return schema
+  return { ...schema, properties: { ...schema.properties, messages: MSG_FIELD } }
+}
+function mailFor(agent) { return MAILBOX[agent] || [] }
+function post(from, messages) {
+  for (const m of [].concat(messages || [])) {
+    if (!m || !m.subject || !m.text) continue
+    const to = (!m.to || String(m.to).toLowerCase() === 'router') ? PLAN.messages.router : String(m.to)
+    ;(MAILBOX[to] = MAILBOX[to] || []).push({ from_agent: from, type: m.type || 'info', priority: m.priority || 'normal', subject: m.subject, body: { text: m.text } })
+    log(`message: ${from} → ${to}: ${m.subject}`)
+  }
+}

package/generator/spec-workflow.js

@@ -1,4 +1,5 @@
 'use strict';
+const gateway = require('./gateway.js');
 // THE SPEC WORKFLOW (Spec → pause 2): the order of spec-mode-runner.js run() and its callees, re-expressed as a script
 // (decisions 10, 15, 16). Every model call is an agent with its seam's definition; every judgement on an answer is the
 // pipeline's own code, run by the hook on that answer (hooks/spec-step.js) — the script only follows the result: which
@@ -13,6 +14,19 @@ function emit(plan) {
   description: 'Spec stage for one lane: spec coordinator, ticket links, detective, openspec with its verification-criteria guard, change review, speckit, coordinator and model review, pause 2',
   phases: [{ title: 'Spec' }, { title: 'Review' }, { title: 'Pause 2' }],
 }
+
+// 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 (!${gateway.NO_ANSWER}.test(String(e && e.message))) throw e
+    log(\`\${(opts && opts.label) || 'an agent'}: no StructuredOutput — taken as no answer\`)
+    return null
+  }
+}
+${gateway.textFor(plan)}
 // GENERATED by amsd-pipeline-workflow/generator/generate-spec.js — do not edit. Source: ${plan.source}
 const PLAN = ${JSON.stringify(plan)}
 const A = PLAN.agents, P = PLAN.prompts, M = PLAN.models, E = PLAN.efforts, L = PLAN.limits, SCH = PLAN.schemas
@@ -30,13 +44,13 @@ const halted = (reason) => ({ status: 'failed', exit: 1, reason, features: FEATU
 const broken = (r) => !r || r.error === true
 // An agent whose answer reached its hook: the hook's result. null: the agent produced nothing (a runner failure).
 async function ask(prompt, opts) {
-  const a = await agent(prompt, { ...opts, phase: current })
+  const a = await agentCall(prompt, { ...opts, phase: current })
   if (a === null) return null
   if (!a.result) return { error: true, reason: \`\${opts.label}: the answer reached no hook result\` }
   return a.result
 }
 async function step(name, label) {
-  const a = await agent('Reply now.', { agentType: name, schema: STEP, label, phase: current })
+  const a = await agentCall('Reply now.', { agentType: name, schema: STEP, label, phase: current })
   if (!a || !a.result) return { error: true, reason: \`\${label}: the step runner gave no result\` }
   return a.result
 }
@@ -291,7 +305,7 @@ async function replayed(R, schemas, what) {
   while (r && r.pending) {
     const q = r.pending, agentType = R.agents[q.agent]
     if (!agentType) return { error: true, reason: \`\${what} asked '\${q.agent}', which this stage has no definition for\` }
-    const ans = await agent(q.prompt, { agentType, ...(q.model ? { model: q.model } : {}), schema: schemas[q.agent] || SCH.cr,
+    const ans = await agentCall(q.prompt, { agentType, ...(q.model ? { model: q.model } : {}), schema: schemas[q.agent] || SCH.cr,
       label: \`\${what}: call \${q.n} (\${q.agent})\`, phase: 'Pause 2' })
     r = ans ? (ans.cpa || ans.next) : await step(R.fail, \`\${what}: call \${q.n} got no answer\`)
   }

package/generator/writer-workflow.js

@@ -1,4 +1,5 @@
 'use strict';
+const gateway = require('./gateway.js');
 // THE WRITER WORKFLOW: plan (data) + emitted script (decisions 10, 12, 15, 16).
 //
 // The plan is everything decided at generation from the pipeline's artefacts and functions: the agents (by role), the
@@ -70,6 +71,20 @@ function emit(plan) {
   description: 'Writer stage for one story: writer, checks (hook-owned verdict), failure analyst, model ladder, review cycle',
   phases: [{ title: 'Writer' }, { title: 'Review' }],
 }
+
+// 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 (!${gateway.NO_ANSWER}.test(String(e && e.message))) throw e
+    log(\`\${(opts && opts.label) || 'an agent'}: no StructuredOutput — taken as no answer\`)
+    return null
+  }
+}
+
+${gateway.textFor(plan)}
 // GENERATED by amsd-pipeline-workflow/generator — do not edit. Source: ${plan.source}
 const PLAN = ${JSON.stringify(plan)}
 
@@ -301,12 +316,12 @@ function appendCriteria(acs, texts) {
 async function remediateRejection(issues, label) {
   const findings = (issues || []).filter((i) => /^(blocker|critical|major)$/i.test((i && i.severity) || ''))
   if (!findings.length) { log(\`\${label}: no blocker/major finding — nothing to remediate\`); return 0 }
-  const rm = await agent(fill(PLAN.prompts.remediator, { review_findings: JSON.stringify(findings), existing_acs: JSON.stringify(state.acs) }),
+  const rm = await agentCall(fill(PLAN.prompts.remediator, { review_findings: JSON.stringify(findings), existing_acs: JSON.stringify(state.acs) }),
     { agentType: PLAN.agents.remediator, schema: SCHEMAS.remediation, label: \`remediation \${label}\`, phase: 'Review' })
   if (!rm) { log(\`\${label}: the remediator returned nothing — the writer retries with the review text only\`); return 0 }
   const after = appendCriteria(state.acs, rm.acs)
   if (after.length === state.acs.length) return 0
-  const cr = await agent(fill(PLAN.prompts.changeReviewer, { before: JSON.stringify(state.acs), after: JSON.stringify(after) }),
+  const cr = await agentCall(fill(PLAN.prompts.changeReviewer, { before: JSON.stringify(state.acs), after: JSON.stringify(after) }),
     { agentType: PLAN.agents.changeReviewer, schema: SCHEMAS.changeReview, label: \`change review \${label}\`, phase: 'Review' })
   if (!cr || cr.verdict !== 'pass') { log(\`\${label}: the proposed criteria were not approved (\${cr ? cr.verdict : 'no verdict'}) — nothing added\`); return 0 }
   const added = after.length - state.acs.length
@@ -359,7 +374,7 @@ async function reproStep(prep) {
   if (prep.error) { log(\`\${at}: the test writer cannot run — \${prep.error}\${prep.findingMode ? '' : ' (Step 3.55 will block)'}\`); return { committed: false, reason: prep.error } }
   let source = null
   if (prep.targetQuestion) {
-    const q = await agent(relativize(prep.targetQuestion), { agentType: PLAN.agents.reproWriter, schema: SCHEMAS.reproTarget, label: 'repro: which file', phase: 'Writer' })
+    const q = await agentCall(relativize(prep.targetQuestion), { agentType: PLAN.agents.reproWriter, schema: SCHEMAS.reproTarget, label: 'repro: which file', phase: 'Writer' })
     const f = q ? fileFromText(q.text) : ''
     if (f && (prep.testable || []).includes(f) && prep.candidates[f]) source = f
     else if (f) log(\`3.54: target choice '\${f}' is not a testable file of this change — ignoring\`)
@@ -371,7 +386,7 @@ async function reproStep(prep) {
   const fb = { typecheck: '', assertions: '', commit_rejected: '' }
   for (let i = 0; i < PLAN.repro.maxAttempts; i++) {
     const model = PLAN.repro.ladder[Math.min(i, PLAN.repro.ladder.length - 1)]
-    const a = await agent(relativize(cand.prompt) + fb.typecheck + fb.assertions + fb.commit_rejected,
+    const a = await agentCall(relativize(cand.prompt) + fb.typecheck + fb.assertions + fb.commit_rejected,
       { agentType: PLAN.agents.reproWriter, model, schema: SCHEMAS.repro, label: \`repro test #\${i + 1}\`, phase: 'Writer' })
     const v = (a && a.validation) || { valid: false, committed: false, class: 'no_file', feedback: '', reason: a ? 'the answer carries no validation' : 'the agent ended without an answer' }
     if (v.valid) return { committed: !!v.committed, attempts: i + 1, test: a.test, reason: v.reason }
@@ -387,7 +402,7 @@ async function reproStep(prep) {
 // and records it as where the next writer attempt starts (hooks/step-review-refresh.sh). A failure says so in the diff's
 // place — never an empty diff — and leaves the tree unknown.
 async function refreshed(prev, label) {
-  const a = await agent('Reply now.', { agentType: PLAN.agents.stepReviewRefresh, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label, phase: 'Writer' })
+  const a = await agentCall('Reply now.', { agentType: PLAN.agents.stepReviewRefresh, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label, phase: 'Writer' })
   const res = a && a.result
   if (!res || res.error) {
     const why = \`[the story's change could not be computed for the review: \${res ? res.reason : 'the step runner gave no result'}]\`
@@ -401,7 +416,7 @@ const isTestWork = (i) => !!i && typeof i === 'object' && i.work === 'tests'
 // result is never a pass: it says why.
 async function stepResult(agentType, label) {
   if (!agentType) return { error: true, reason: \`no step-runner definition for \${label}\` }
-  const s = await agent('Reply now.', { agentType, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label, phase: 'Writer' })
+  const s = await agentCall('Reply now.', { agentType, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label, phase: 'Writer' })
   return (s && s.result) || { error: true, reason: s ? 'the step runner returned no result' : 'the step runner ended without an answer' }
 }
 
@@ -418,7 +433,7 @@ async function retryExtension(retry) {
   const pr = await stepResult(at.prep, 'retry extension: question')
   if (pr.error) { log(\`retry extension: the question could not be prepared — \${pr.reason}\`); return 0 }
   if (!pr.ask) { log(\`retry extension: not asked — \${pr.decidedBy}\${pr.reason ? \`: \${pr.reason}\` : ''}\`); return 0 }
-  const a = await agent(relativize(pr.prompt), { agentType: PLAN.agents.retryCoordinator, schema: SCHEMAS.retryExt, label: 'retry extension', phase: 'Writer' })
+  const a = await agentCall(relativize(pr.prompt), { agentType: PLAN.agents.retryCoordinator, schema: SCHEMAS.retryExt, label: 'retry extension', phase: 'Writer' })
   if (!a) log('retry extension: the coordinator ended without an answer')
   const ap = await stepResult(at.apply, 'retry extension: decision')
   if (ap.error) { log(\`retry extension: the decision could not be applied — \${ap.reason}\`); return 0 }
@@ -431,7 +446,7 @@ async function tcWriter(attempt) {
   if (p.error) { log(\`attempt \${attempt + 1}: the tc-writer's question could not be built — \${p.reason}\`); return }
   if (!p.needed) { if (p.message) log(p.message); return }
   log(\`  [tc-writer] Generating TCs for phase '\${p.phase || '<unset>'}' (post-impl, pre-test)...\`)
-  await agent(relativize(p.prompt), { agentType: PLAN.agents.tcWriter, ...(p.model ? { model: p.model } : {}), schema: SCHEMAS.tc,
+  await agentCall(relativize(p.prompt), { agentType: PLAN.agents.tcWriter, ...(p.model ? { model: p.model } : {}), schema: SCHEMAS.tc,
     label: \`tc-writer after #\${attempt + 1}\`, phase: 'Writer' })
   const r = await stepResult(PLAN.agents.stepTcApply, \`tc-writer apply #\${attempt + 1}\`)
   if (r.ok && r.testCriteria) {
@@ -500,7 +515,7 @@ async function phaseGates(attempt) {
   // (and reverted) by the step runner
   if (s20.fix) {
     for (let i = 1; i <= s20.fix.maxAttempts; i++) {
-      await agent(relativize(s20.fix.prompt), { agentType: PLAN.agents.lintFixer, schema: { type: 'object', properties: { summary: { type: 'string' } } },
+      await agentCall(relativize(s20.fix.prompt), { agentType: PLAN.agents.lintFixer, schema: { type: 'object', properties: { summary: { type: 'string' } } },
         label: \`Step 20: lint repair #\${i}\`, phase: 'Review' })
       const v = await stepResult(PLAN.agents.lintFixVerifyAt[i], \`Step 20: verify repair #\${i}\`)
       if (v.repaired) { log('Step 20: findings repaired in place — lint clean, types compile, tests still pass'); return fin({ status: 'done', exit: 0, step19: s19, step20: { ...s20, repaired: true } }) }
@@ -512,22 +527,22 @@ async function phaseGates(attempt) {
   // the gate-finding-analyst: one retry on no answer, in the template's retry form, on ESCALATION_MODEL_HIGH when set
   const gfSchema = { type: 'object', required: ['story_id'], properties: { gate: { type: 'string' }, story_id: { type: 'string' }, file: { type: 'string' },
     line: { type: 'integer' }, rule: { type: 'string' }, message: { type: 'string' }, suggested_fix: { type: 'string' } } }
-  let finding = await agent(relativize(s20.remediation.findingPrompt), { agentType: PLAN.agents.gateAnalyst, schema: gfSchema, label: 'Step 20: lint finding', phase: 'Review' })
-  if (!finding) finding = await agent(relativize(s20.remediation.findingRetryPrompt), { agentType: PLAN.agents.gateAnalyst, schema: gfSchema,
+  let finding = await agentCall(relativize(s20.remediation.findingPrompt), { agentType: PLAN.agents.gateAnalyst, schema: gfSchema, label: 'Step 20: lint finding', phase: 'Review' })
+  if (!finding) finding = await agentCall(relativize(s20.remediation.findingRetryPrompt), { agentType: PLAN.agents.gateAnalyst, schema: gfSchema,
     ...(PLAN.lint.escalationModelHigh ? { model: PLAN.lint.escalationModelHigh } : {}), label: 'Step 20: lint finding (retry)', phase: 'Review' })
   const sid = finding && typeof finding.story_id === 'string' ? finding.story_id : ''
   if (!sid) return failed('could not map the lint failure to a story')
   // the story-ac-remediator (template lint-ac-remediator); its criteria judged by the prd-change-reviewer (lib/reviewed-acs.sh)
   const remPrompt = fill(PLAN.prompts['lint.remediator'], { current_acs: sid === story.id ? pyJsonIndent2(state.acs) : '', lint_story_id: sid, finding: JSON.stringify(finding) })
   const remSchema = { type: 'object', required: ['new_acs'], properties: { new_acs: { type: 'array', items: { type: 'string' } } } }
-  let rm = await agent(remPrompt, { agentType: PLAN.agents.remediator, schema: remSchema, label: 'Step 20: lint remediation', phase: 'Review' })
-  if (!rm) rm = await agent(fill(PLAN.prompts['lint.remediatorRetry'], { lint_ac_prompt: remPrompt }), { agentType: PLAN.agents.remediator, schema: remSchema,
+  let rm = await agentCall(remPrompt, { agentType: PLAN.agents.remediator, schema: remSchema, label: 'Step 20: lint remediation', phase: 'Review' })
+  if (!rm) rm = await agentCall(fill(PLAN.prompts['lint.remediatorRetry'], { lint_ac_prompt: remPrompt }), { agentType: PLAN.agents.remediator, schema: remSchema,
     ...(PLAN.lint.escalationModelHigh ? { model: PLAN.lint.escalationModelHigh } : {}), label: 'Step 20: lint remediation (retry)', phase: 'Review' })
   let added = 0
   if (rm && sid === story.id) {
     const after = appendLintCriteria(state.acs, rm.new_acs)
     if (after.length !== state.acs.length) {
-      const cr = await agent(fill(PLAN.prompts.changeReviewer, { before: JSON.stringify(state.acs), after: JSON.stringify(after) }),
+      const cr = await agentCall(fill(PLAN.prompts.changeReviewer, { before: JSON.stringify(state.acs), after: JSON.stringify(after) }),
         { agentType: PLAN.agents.changeReviewer, schema: SCHEMAS.changeReview, label: 'Step 20: change review', phase: 'Review' })
       if (cr && cr.verdict === 'pass') { added = after.length - state.acs.length; state.acs = after }
       else log(\`Step 20: the proposed criteria were not approved (\${cr ? cr.verdict : 'no verdict'}) — nothing added\`)
@@ -546,11 +561,11 @@ async function implementedSteps(checks, attempt) {
     // when it is red, the agent (its write fence: only tests that existed before the story) updates them or reports a
     // regression, and its judge decides. An unresolved RED suite blocks after the reproduction gate (below).
     if (PLAN.brownfield) {
-      const uc = await agent('Reply now.', { agentType: PLAN.agents.stepUitCheck, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label: '3.545 suite check', phase: 'Writer' })
+      const uc = await agentCall('Reply now.', { agentType: PLAN.agents.stepUitCheck, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label: '3.545 suite check', phase: 'Writer' })
       const ucr = (uc && uc.result) || { needed: false, error: true, reason: uc ? 'the step runner returned no result' : 'the step runner ended without an answer' }
       uit = { passed: !ucr.error, reason: ucr.reason }
       if (ucr.needed) {
-        const ua = await agent(relativize(ucr.prompt || ''), { agentType: PLAN.agents.invalidatedTests, model: PLAN.repro.ladder[0],
+        const ua = await agentCall(relativize(ucr.prompt || ''), { agentType: PLAN.agents.invalidatedTests, model: PLAN.repro.ladder[0],
           schema: { type: 'object', required: ['verdict'], properties: { verdict: { type: 'string', enum: ['updated', 'regression', 'none'] }, summary: { type: 'string' } } },
           label: '3.545 invalidated tests', phase: 'Writer' })
         uit = (ua && ua.result) || { passed: false, reason: ua ? 'the answer carries no judgement' : 'the agent ended without an answer' }
@@ -560,7 +575,7 @@ async function implementedSteps(checks, attempt) {
     // STEP 3.55 — the bug-reproduction gate (brownfield-repro-test-gate.sh, run by the step runner's hook): a block stops the
     // story before review, exit 2, as run-agent-orchestration.sh does.
     if (PLAN.brownfield) {
-      const g = await agent('Reply now.', { agentType: PLAN.agents.stepReproGate, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label: '3.55 reproduction gate', phase: 'Writer' })
+      const g = await agentCall('Reply now.', { agentType: PLAN.agents.stepReproGate, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label: '3.55 reproduction gate', phase: 'Writer' })
       const res = (g && g.result) || { ran: false, passed: false, reason: g ? 'the step runner returned no result' : 'the step runner ended without an answer' }
       gate = res
       if (!res.passed) return end({ status: 'blocked', exit: 2, story: story.id, attempts: attempt + 1, reason: \`Step 3.55: the reproduction gate blocked the story — \${res.reason || 'no reason'}\` })
@@ -569,12 +584,12 @@ async function implementedSteps(checks, attempt) {
       if (uit && !uit.passed) return end({ status: 'blocked', exit: 2, story: story.id, attempts: attempt + 1, reason: \`Step 3.55: the test suite is RED and Step 3.545 could not reconcile it — \${uit.reason}\` })
       // STEP 3.56 — advisory: does the story's test cover each verification criterion (vc-coverage-check.sh, one question
       // per criterion, in order)? The uncovered ones reach the reviewer; nothing here fails the story.
-      const vp = await agent('Reply now.', { agentType: PLAN.agents.stepVcPrep, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label: '3.56 coverage questions', phase: 'Writer' })
+      const vp = await agentCall('Reply now.', { agentType: PLAN.agents.stepVcPrep, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label: '3.56 coverage questions', phase: 'Writer' })
       const vpr = (vp && vp.result) || { needed: false, reason: 'the step runner gave no result' }
       coverage = { reason: vpr.reason, testFile: vpr.testFile || null, results: [] }
       if (vpr.needed) {
         for (const [i, q] of (vpr.prompts || []).entries()) {
-          const v = await agent(relativize(q.prompt), { agentType: PLAN.agents.coverage, schema: { type: 'object', required: ['covered'],
+          const v = await agentCall(relativize(q.prompt), { agentType: PLAN.agents.coverage, schema: { type: 'object', required: ['covered'],
             properties: { covered: { type: 'boolean' }, case: { type: 'string' }, why: { type: 'string' } } }, label: \`3.56 criterion \${i + 1}\`, phase: 'Writer' })
           // no answer is NOT evidence of a gap: recorded as unknown, counted neither way
           coverage.results.push(v ? { ...v, vc: q.vc } : { vc: q.vc, covered: null })
@@ -632,7 +647,7 @@ if (FEATURES.includes('plan-mode')) {
   while (pr && pr.pending) {
     const q = pr.pending, def = PLAN.agents.plan.agents[q.agent]
     if (!def) { pr = { error: true, reason: \`the planning functions asked '\${q.agent}', which this stage has no definition for\` }; break }
-    const ans = await agent(relativize(q.prompt), { agentType: def.name, ...(q.model ? { model: q.model } : {}), schema: def.text ? SCHEMAS.planText : SCHEMAS.planReview,
+    const ans = await agentCall(relativize(q.prompt), { agentType: def.name, ...(q.model ? { model: q.model } : {}), schema: def.text ? SCHEMAS.planText : SCHEMAS.planReview,
       label: \`plan: call \${q.n} (\${q.agent})\`, phase: 'Writer' })
     pr = ans ? ans.plan : await stepResult(PLAN.agents.plan.fail, \`plan: call \${q.n} got no answer\`)
   }
@@ -666,7 +681,7 @@ for (; attempt <= budget; attempt++) {
     // was changed, and this rung's starting point is recorded.
     const re = (PLAN.agents.rungEntryAt[attempt] || {})[prevModel]
     if (re) {
-      const e = await agent('Reply now.', { agentType: re, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label: \`rung entry #\${attempt + 1}\`, phase: 'Writer' })
+      const e = await agentCall('Reply now.', { agentType: re, schema: { type: 'object', properties: { done: { type: 'boolean' } } }, label: \`rung entry #\${attempt + 1}\`, phase: 'Writer' })
       const er = (e && e.result) || { error: true, reason: e ? 'the step runner returned no result' : 'the step runner ended without an answer' }
       if (er.error) log(\`attempt \${attempt + 1}: the rung-entry step could not run — \${er.reason}\`)
       else if (er.reset) log(\`attempt \${attempt + 1}: the codeline was reset to the baseline (the attempt changed no fix site the spec requires)\`)
@@ -705,7 +720,7 @@ for (; attempt <= budget; attempt++) {
   const pre = await stepResult(PLAN.agents.preAttemptAt[attempt], \`pre-attempt #\${attempt + 1}\`)
   if (pre.error) log(\`attempt \${attempt + 1}: the pre-attempt step could not run — \${pre.reason}\`)
   else escalationHistory = pre.escalationHistory || ''
-  const w = await agent(prompt,
+  const w = await agentCall(prompt,
     { agentType: (PLAN.agents.writerAt[attempt] || {})[rung.model] || PLAN.agents.writer, model: rung.model, effort: rung.effort, schema: SCHEMAS.writer, label: \`writer #\${attempt + 1} (rung \${rung.rung})\`, phase: 'Writer' })
   invocations++
   if (w === null) {
@@ -757,7 +772,7 @@ for (; attempt <= budget; attempt++) {
       // computed it (the pipeline's _attempt_change_summary) — never the writer's own account of its work.
       // __VERIFICATION_FAILURE__: the failure text, or — when the pipeline has none — the "## Attempt Failure — <class>"
       // summary (failure-healing.sh:1139–1157, built by the classify hook)
-      const a = await agent(fill(PLAN.prompts.analyst, { ...base, story_acs: analystCriteria(), verification_failure: fl && typeof fl.analystFailure === 'string' ? fl.analystFailure : problems,
+      const a = await agentCall(fill(PLAN.prompts.analyst, { ...base, story_acs: analystCriteria(), verification_failure: fl && typeof fl.analystFailure === 'string' ? fl.analystFailure : problems,
         attempt_changes: checks.changes, healing_history: healingHistory(healing) }),
         { agentType: PLAN.agents.analystAt[attempt] || PLAN.agents.analyst, schema: SCHEMAS.analyst, label: \`analyst after #\${attempt + 1}\`, phase: 'Writer' })
       a0 = a
@@ -782,13 +797,13 @@ for (; attempt <= budget; attempt++) {
         if (hv.toolReview) {
           let current = hv.toolReview.candidate, verdict = null
           for (let i = 1; i <= PLAN.toolReview.maxAttempts; i++) {
-            const tr = await agent(fill(PLAN.prompts['tool.review'], { before: hv.toolReview.before, after: current }),
+            const tr = await agentCall(fill(PLAN.prompts['tool.review'], { before: hv.toolReview.before, after: current }),
               { agentType: PLAN.agents.toolReviewer, schema: SCHEMAS.changeReview, label: \`tool review #\${i} after #\${attempt + 1}\`, phase: 'Writer' })
             // a reviewer that could not be reached is a rejection (run_prd_change_reviewer's fallback answer)
             verdict = tr || { verdict: 'fail', issues: ['the reviewer could not be reached — the change was NOT reviewed'] }
             if (verdict.verdict === 'pass') break
             if (i < PLAN.toolReview.maxAttempts) {
-              const sm = await agent(fill(PLAN.prompts['tool.summarize'], { issues: (verdict.issues || []).map(String).join('; ') || 'no details', rejected_text: current }),
+              const sm = await agentCall(fill(PLAN.prompts['tool.summarize'], { issues: (verdict.issues || []).map(String).join('; ') || 'no details', rejected_text: current }),
                 { agentType: PLAN.agents.toolSummarizer, schema: { type: 'object', required: ['script'], properties: { script: { type: 'string' } } },
                   label: \`tool rewrite #\${i} after #\${attempt + 1}\`, phase: 'Writer' })
               if (sm && typeof sm.script === 'string') current = sm.script
@@ -807,13 +822,13 @@ for (; attempt <= budget; attempt++) {
         if (hv.kb && hv.kb.review) {
           let current = hv.kb.review.candidate, kbPass = false
           for (let i = 1; i <= 3; i++) {
-            const kr = await agent(fill(PLAN.prompts['kb.review'], { before: hv.kb.review.before, after: current }),
+            const kr = await agentCall(fill(PLAN.prompts['kb.review'], { before: hv.kb.review.before, after: current }),
               { agentType: PLAN.agents.kbReviewer, schema: SCHEMAS.changeReview, label: \`KB review #\${i} after #\${attempt + 1}\`, phase: 'Writer' })
             const v = kr ? kr.verdict : null
             if (v === 'pass') { kbPass = true; break }
             if (v !== 'fail') { log(\`analyst after #\${attempt + 1}: the KB entry was NOT reviewed (verdict '\${v || 'none'}') — not kept\`); break }
             if (i < 3) {
-              const sm = await agent(fill(PLAN.prompts['kb.summarize'], { issues: ((kr && kr.issues) || []).map(String).join('; ') || 'no details', rejected_text: current }),
+              const sm = await agentCall(fill(PLAN.prompts['kb.summarize'], { issues: ((kr && kr.issues) || []).map(String).join('; ') || 'no details', rejected_text: current }),
                 { agentType: PLAN.agents.kbSummarizer, schema: { type: 'object', required: ['text'], properties: { text: { type: 'string' } } },
                   label: \`KB rewrite #\${i} after #\${attempt + 1}\`, phase: 'Writer' })
               if (sm && typeof sm.text === 'string') current = sm.text
@@ -831,7 +846,7 @@ for (; attempt <= budget; attempt++) {
           const { after, refused } = checkFixes(state.acs, a.ac_patches)
           if (refused.length) log(\`analyst after #\${attempt + 1}: criteria fix refused — \${refused.join('; ')}\`)
           if (JSON.stringify(after) !== JSON.stringify(state.acs)) {
-            const cr = await agent(fill(PLAN.prompts.changeReviewer, { before: JSON.stringify(state.acs), after: JSON.stringify(after) }),
+            const cr = await agentCall(fill(PLAN.prompts.changeReviewer, { before: JSON.stringify(state.acs), after: JSON.stringify(after) }),
               { agentType: PLAN.agents.changeReviewer, schema: SCHEMAS.changeReview, label: \`change review after #\${attempt + 1}\`, phase: 'Writer' })
             kept = !!cr && cr.verdict === 'pass'
             if (kept) state.acs = after
@@ -856,7 +871,7 @@ for (; attempt <= budget; attempt++) {
               const ob = [...(((state.otherTc || {})[sid]) || (PLAN.otherTcFacts || {})[sid] || [])]
               const oa = applyTcPatches(ob, a.tc_patches.filter((pt) => pt && pt.storyId === sid))
               if (JSON.stringify(oa) === JSON.stringify(ob)) continue
-              const ocr = await agent(fill(tpl, { before: JSON.stringify(ob), after: JSON.stringify(oa) }),
+              const ocr = await agentCall(fill(tpl, { before: JSON.stringify(ob), after: JSON.stringify(oa) }),
                 { agentType: PLAN.agents.changeReviewer, schema: SCHEMAS.changeReview, label: \`test-criteria review of \${sid} after #\${attempt + 1}\`, phase: 'Writer' })
               if (ocr && ocr.verdict === 'pass') { state.otherTc = { ...(state.otherTc || {}), [sid]: oa }; log(\`analyst after #\${attempt + 1}: \${sid}'s test criteria patched (reviewed)\`) }
               else log(\`analyst after #\${attempt + 1}: TC patch on \${sid} not approved by the reviewer (\${ocr ? ocr.verdict : 'no verdict'}) — reverting\`)
@@ -865,7 +880,7 @@ for (; attempt <= budget; attempt++) {
           const before = [...(state.tcFacts || [])]
           const after = applyTcPatches(before, mine)
           if (tgt === 'tc' || JSON.stringify(after) !== JSON.stringify(before)) {
-            const cr = await agent(fill(PLAN.prompts['changeReviewer.tc'], { before: JSON.stringify(before), after: JSON.stringify(after) }),
+            const cr = await agentCall(fill(PLAN.prompts['changeReviewer.tc'], { before: JSON.stringify(before), after: JSON.stringify(after) }),
               { agentType: PLAN.agents.changeReviewer, schema: SCHEMAS.changeReview, label: \`test-criteria review after #\${attempt + 1}\`, phase: 'Writer' })
             if (cr && cr.verdict === 'pass') {
               if (JSON.stringify(after) !== JSON.stringify(before)) { state.tcFacts = after; state.tc = { ...(state.tc || {}), facts: after }; kept = true }
@@ -924,7 +939,7 @@ for (; attempt <= budget; attempt++) {
   // too, as team-lead-review.sh records it (reviewIncomplete) — is in the reviewer's memory.
   let r = null
   for (;;) {
-    r = await agent(fill(PLAN.prompts.reviewer, { ...base, story_acs: noTrail(criteriaBlock(state.acs, 'ACCEPTANCE CRITERIA:')),
+    r = await agentCall(fill(PLAN.prompts.reviewer, { ...base, story_acs: noTrail(criteriaBlock(state.acs, 'ACCEPTANCE CRITERIA:')),
       prior_review: priorReviews(), story_diff: checks.storyDiff, test_files: checks.testFiles, uncovered_vc_block: uncoveredVc !== null ? uncoveredVc : checks.uncoveredVc }),
       // team-lead-review.sh: on the writer's model (the rung that produced this work); effort stays the reviewer's own.
       { agentType: PLAN.agents.reviewer, model: rung.model, schema: SCHEMAS.review, label: \`review #\${reviews.length + 1}\`, phase: 'Review' })
@@ -955,7 +970,7 @@ for (; attempt <= budget; attempt++) {
   // writer in gate-finding mode, which commits the strengthened test; it leaves the implementer's findings whatever the
   // test writer's outcome. In greenfield the implementer owns its tests and keeps them.
   if (PLAN.brownfield && kept.some(isTestWork)) {
-    const rt = await agent('Reply now.', { agentType: PLAN.agents.stepReviewTests, schema: { type: 'object', properties: { done: { type: 'boolean' } } },
+    const rt = await agentCall('Reply now.', { agentType: PLAN.agents.stepReviewTests, schema: { type: 'object', properties: { done: { type: 'boolean' } } },
       label: \`review #\${reviews.length}: test findings\`, phase: 'Review' })
     const res = (rt && rt.result) || { routed: 0, reason: rt ? 'the step runner returned no result' : 'the step runner ended without an answer' }
     if (res.prep) {

package/hooks/agents-sandbox.sh

@@ -80,6 +80,17 @@ MOUNTS="$STATE/run/mounts.sh"
     jq -r '(.seedLogs // {}) | to_entries[] | [.key, .value] | @tsv' "$PJ" | while IFS=$'\t' read -r name src; do
       printf '[ -e %q ] || cp %q %q\n' "$ORCH/logs/$name" "$src" "$ORCH/logs/$name"
     done
+    # THE CODELINE FACTS OF A RECORDED DISCOVERY: discovery is the single writer of <project>/codeline-facts.json
+    # (lib/codeline-discovery.js:739–748, writeCodelineFacts from its own output), and pre-run-reset.sh:1029–1038 clears it
+    # every launch; with the discovery recorded (the ingest skipped, decision 37) it is written here from that output, by
+    # the same function — never over a file the run already has. Without it no plan codeline can become a lane
+    # (lib/plan-scope.js adoptPlanCodelines).
+    _disc="$(j '.seedLogs["codeline-discovery.json"] // empty')"
+    if [ -n "$_disc" ]; then
+      printf '[ -e %q ] || EPAM_PROJECT_CONFIG_DIR=%q %q -e %q %q %q\n' "$ORCH/projects/$PROJECT/codeline-facts.json" "$ORCH/projects/$PROJECT" \
+        "$NODE20" 'require(process.argv[1]).writeCodelineFacts({ projectConfigDir: process.env.EPAM_PROJECT_CONFIG_DIR, codelines: JSON.parse(require("fs").readFileSync(process.argv[2], "utf8")).codelines })' \
+        "$ORCH/scripts/lib/codeline-facts.js" "$ORCH/logs/codeline-discovery.json"
+    fi
     # THE PRD ON DISK (pipeline.json seedPrd; decision 37 — initial testing skips the Jira ingest): the launcher's reset
     # clears a brownfield PRD to its empty sentinel (orchestrate.sh:316–328), and with EPAM_SKIP_JIRA_INGEST=1 nothing
     # writes it again; the PRD the run starts from is placed after the reset, once — never over one the run has grown

package/hooks/messages-out.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+'use strict';
+// AGENT-TO-AGENT MESSAGES, ON THE RUN'S BUS (operator, 2026-10-18; the shared component amsd-pipeline-shared
+// lib/agent-messages.js, laid into the install by its own install). On an agent's structured answer: every message it sends
+// (`messages`: [{to, type, subject, text}]) is written to the bus from that agent — "router" or no recipient goes to the
+// stage's router — and the messages delivered to it in this call (the gateway put them in its prompt) are marked read.
+// Never blocks the answer: a bus that cannot be written is said on stderr and the answer passes unchanged.
+//   messages-out.js answer --bus <dir> --map <agents map json> --router <pipeline agent> --install <install> [--story <id>]
+//   stdin: the PreToolUse hook's JSON. stdout: nothing (the answer is not changed).
+const fs = require('fs');
+const path = require('path');
+
+function args(argv) { const a = {}; for (let i = 0; i < argv.length; i += 2) a[argv[i].replace(/^--/, '')] = argv[i + 1]; return a; }
+
+if (require.main === module) {
+  const a = args(process.argv.slice(3));
+  let input = {};
+  try { input = JSON.parse(fs.readFileSync(0, 'utf8') || '{}'); } catch { process.exit(0); }
+  if (input.tool_name !== 'StructuredOutput') process.exit(0);
+  const lib = path.join(a.install || '', 'orchestrations', 'scripts', 'lib', 'agent-messages.js');
+  if (!fs.existsSync(lib)) { process.stderr.write(`[messages] the shared messages component is not installed (${lib}) — messages NOT sent\n`); process.exit(0); }
+  const m = require(lib);
+  let map = {}; try { map = JSON.parse(fs.readFileSync(a.map, 'utf8')); } catch { map = {}; }
+  const me = map[input.agent_type] || input.agent_type || 'agent';
+  try {
+    for (const x of [].concat((input.tool_input || {}).messages || [])) {
+      if (!x || !x.subject || !x.text) continue;
+      m.send({ dir: a.bus, from: me, to: x.to, router: a.router, type: x.type || 'info', subject: x.subject, text: x.text, story: a.story || '', priority: x.priority || 'normal' });
+    }
+    m.receive({ dir: a.bus, agent: me, markRead: true });
+  } catch (e) { process.stderr.write(`[messages] ${e.message}\n`); }
+  process.exit(0);
+}

package/hooks/pipeline-step.js

@@ -13,7 +13,7 @@ const STEPS = { 'repro-gate': 'step-repro-gate.sh', 'uit-check': 'step-uit-check
   'pre-review': 'step-pre-review.sh', 'kb-section': 'step-kb-section.sh', 'lint-gate': 'step-lint-gate.sh', 'lint-fix-verify': 'step-lint-fix-verify.sh',
   'no-change': 'step-no-change.sh', 'tc-prep': 'step-tc-prep.sh', 'tc-apply': 'step-tc-apply.sh', 'kb-fallback': 'step-kb-fallback.sh',
   'retry-ext-prep': 'step-retry-ext-prep.sh', 'retry-ext-apply': 'step-retry-ext-apply.sh',
-  'plan-start': 'step-plan-start.sh', 'plan-fail': 'step-plan-fail.sh' };   // the step scripts, beside this file
+  'plan-start': 'step-plan-start.sh', 'plan-fail': 'step-plan-fail.sh', 'call-failed': 'step-call-failed.sh' };   // the step scripts, beside this file
 function args(argv) { const a = {}; for (let i = 0; i < argv.length; i += 2) a[argv[i].replace(/^--/, '')] = argv[i + 1]; return a; }
 
 if (require.main === module) {
@@ -27,7 +27,10 @@ if (require.main === module) {
   else {
     // a per-attempt step runner's own values (decision 27): its retry and the model the previous attempt ran on
     const env = { ...process.env, ...(a.retry !== undefined ? { RUNG_RETRY: String(a.retry) } : {}), ...(a['prev-model'] ? { RUNG_PREV_MODEL: a['prev-model'] } : {}),
-      ...(a.model ? { RUNG_MODEL: a.model } : {}) };
+      ...(a.model ? { RUNG_MODEL: a.model } : {}),
+      // a failed agent call (the gateway, hooks/step-call-failed.sh): the call the step runner was told to hand on
+      ...(() => { const c = (input.tool_input || {}).call || {}; return { CALL_AGENT: String(c.agent || ''), CALL_MODEL: String(c.model || ''),
+        CALL_STORY: String(c.story || 'global'), CALL_REASON: String(c.reason || ''), CALL_ATTEMPT: String(c.attempt || 1) }; })() };
     const r = spawnSync('bash', [path.join(__dirname, script), a.pipeline, a.state], { encoding: 'utf8', env, maxBuffer: 64 * 1024 * 1024 });
     try { result = JSON.parse(r.stdout); } catch { result = { ran: false, passed: false, reason: (r.stderr || `exit ${r.status}`).slice(-400) }; }
   }

package/hooks/step-call-failed.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# A FAILED AGENT CALL, AS THE PIPELINE'S GATEWAY TAKES IT (llm-handler.sh "UNIFORM CALL RESILIENCE" :977–998, :1080–1082),
+# by the pipeline's own functions, run by the step runner's hook. The workflow's gateway calls this after an attempt that
+# produced no usable answer, then re-asks on what it returns — retry, ladder and self-heal for EVERY agent (operator,
+# 2026-10-18). No AI.
+#   step-call-failed.sh <pipeline.json> <state-dir>     env CALL_AGENT (the pipeline agent), CALL_MODEL (the model just used),
+#                                                       CALL_STORY, CALL_REASON (why the attempt failed), CALL_ATTEMPT
+# 1. agent_ladder_record_failure, then agent_ladder_model: the next rung on the chain this agent's archetype declares;
+# 2. the previous-refusal block (the hub's _ai_prompt_with_failure: the reason, redacted, its tail) for the next prompt;
+# 3. kb_record_episode: the episode, so self-heal learns from it (the hub's _ai_kb_after_failure).
+# Prints {"model": "<next>", "decision": "escalating|top|no-chain", "block": "<previous-refusal>", "episode": bool, "line": "..."}.
+set -uo pipefail
+PJ="${1:?pipeline.json}" STATE="${2:?state dir}"
+INSTALL=$(jq -r .install "$PJ") PROJECT=$(jq -r .project "$PJ")
+S="$INSTALL/orchestrations/scripts"
+: "${CALL_AGENT:?}" "${CALL_MODEL:=}" "${CALL_STORY:=global}" "${CALL_REASON:=the agent produced no usable answer}" "${CALL_ATTEMPT:=1}"
+export EPAM_PROJECT_CONFIG_DIR="${EPAM_PROJECT_CONFIG_DIR:-$(jq -r '.projectConfig // empty' "$PJ")}"
+[ -n "$EPAM_PROJECT_CONFIG_DIR" ] && [ -d "$EPAM_PROJECT_CONFIG_DIR" ] || EPAM_PROJECT_CONFIG_DIR="$INSTALL/orchestrations/projects/$PROJECT"
+# the ladder's state lives with the run (agent-ladder.sh: "THE STATE DIES WITH THE RUN") — this stage's state folder
+export LOG_DIR="$STATE/gateway"; mkdir -p "$LOG_DIR"
+export NODE_BIN="${NODE_BIN:-$(command -v node)}"
+_log="$LOG_DIR/call-failed.log"
+{
+  # shellcheck source=/dev/null
+  . "$S/lib/model-ladders.sh"
+  # the project's chains, EPAM_MODEL_LADDER_<TIER> (sourcing only defines the exporter — the hub's model-ladder.sh calls it)
+  export_model_ladders "$EPAM_PROJECT_CONFIG_DIR/llm-settings.json"
+  # shellcheck source=/dev/null
+  . "$S/lib/agent-ladder.sh"
+  # shellcheck source=/dev/null
+  . "$S/lib/kb-apply.sh"
+} >>"$_log" 2>&1 || { jq -cn --rawfile m "$_log" '{error:true, reason:"the pipeline ladder/KB libraries did not load", message:$m}'; exit 0; }
+declare -F agent_ladder_model >/dev/null || { jq -cn '{error:true, reason:"agent_ladder_model is not defined"}'; exit 0; }
+
+agent_ladder_record_failure "$CALL_AGENT" "$CALL_STORY"
+next="$(agent_ladder_model "$CALL_AGENT" "$CALL_STORY" "$CALL_MODEL" 2>>"$_log")"
+if [ -n "$next" ] && [ "$next" != "$CALL_MODEL" ]; then
+  decision=escalating; line="[ai-run] attempt $((CALL_ATTEMPT + 1)) for '${CALL_AGENT}' — escalating ${CALL_MODEL} -> ${next}"
+elif agent_ladder_exhausted "$CALL_AGENT" "$CALL_STORY" "$CALL_MODEL" 2>>"$_log"; then
+  decision=top; next="$CALL_MODEL"; line="[ai-run] attempt $((CALL_ATTEMPT + 1)) for '${CALL_AGENT}' — at the top of its declared chain (${CALL_MODEL:-default}), retrying the same rung"
+else
+  decision=no-chain; next="$CALL_MODEL"; line="[ai-run] attempt $((CALL_ATTEMPT + 1)) for '${CALL_AGENT}' — no chain declared for this agent's tier, retrying on ${CALL_MODEL:-default}"
+fi
+
+# the hub's _ai_prompt_with_failure: never a credential in a prompt; bounded, the tail kept
+why="$(printf '%s' "$CALL_REASON" | sed -E 's/(sk-[A-Za-z0-9_-]{8,}|ey[A-Za-z0-9_-]{20,}|[A-Za-z0-9_-]{32,})/[REDACTED]/g' | tail -c 1200)"
+block="$("$NODE_BIN" -e '
+  try {
+    const { renderEngineTemplate } = require(process.argv[1] + "/lib/engine-prompt.js");
+    process.stdout.write(renderEngineTemplate("previous-refusal", { __REASON__: process.argv[2], __ARTEFACT__: process.argv[3] || "answer" }));
+  } catch (e) { process.stdout.write(""); }
+' "$S" "$why" "$CALL_AGENT" 2>>"$_log")"
+
+episode=false
+if declare -F kb_record_episode >/dev/null; then
+  printf '%s' "$CALL_REASON" | kb_record_episode "$CALL_STORY" "$CALL_AGENT" "model call produced no usable output" 2>>"$_log" && episode=true
+fi
+printf '%s\n' "$line" >>"$_log"
+# THE SELF-HEAL LISTENER'S RECORD (tools/live-tracker.js "Abort-class checks"): one event per failed call, in the run's own
+# folder — what failed, on which model, where the ladder sent it, whether the KB learned it.
+jq -cn --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" --arg agent "$CALL_AGENT" --arg story "$CALL_STORY" --argjson attempt "$CALL_ATTEMPT" \
+  --arg from "$CALL_MODEL" --arg to "$next" --arg decision "$decision" --argjson episode "$episode" --arg reason "$CALL_REASON" \
+  '{ts:$ts, kind:"call-failed", agent:$agent, story:$story, attempt:$attempt, from:$from, to:$to, decision:$decision, episode:$episode, reason:$reason}' \
+  >> "$LOG_DIR/events.jsonl"
+jq -cn --arg model "$next" --arg decision "$decision" --arg block "$block" --argjson episode "$episode" --arg line "$line" \
+  '{model:$model, decision:$decision, block:$block, episode:$episode, line:$line}'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amsd-pipeline-workflow",
-  "version": "0.1.1",
+  "version": "0.1.6",
   "description": "The AMSD pipeline as Claude workflows. Installed by the amsd-pipeline installer: install.sh --workflows",
   "license": "UNLICENSED",
   "bin": {
@@ -20,6 +20,7 @@
     "node": ">=20"
   },
   "amsdPipeline": {
-    "tested": "2.0.78"
+    "tested": "2.0.78",
+    "shared": "0.2.0"
   }
 }

package/test/layer1/harness.js

@@ -28,8 +28,15 @@ function fromSchema(schema, overrides) {
 async function run(source, args, answer) {
   const metaMatch = source.match(/^\s*export const meta\s*=\s*(\{[\s\S]*?\n\})\s*\n/);
   if (!metaMatch) throw new Error('script does not start with `export const meta = {…}`');
+  // THE WORKFLOW TOOL'S OWN RULES, as the live tool enforced them on 2026-10-18 ("meta must be a pure literal: spread not
+  // allowed in meta"): meta holds no spread, template literal or call — checked with the strings taken out
+  const unstring = (x) => x.replace(/"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/g, '""');
+  const metaCode = unstring(metaMatch[1]);
+  if (/\.\.\.|`|\(/.test(metaCode)) throw new Error('Invalid workflow script: meta must be a pure literal (no spread, template literal or call)');
   const meta = vm.runInNewContext(`(${metaMatch[1]})`, {});      // a literal, or this throws
   const body = source.slice(metaMatch[0].length);
+  // and the body never reads the clock or randomness (they would break resume)
+  if (/\bDate\.now\s*\(|\bMath\.random\s*\(|\bnew Date\s*\(\s*\)/.test(unstring(body))) throw new Error('Invalid workflow script: Date.now(), Math.random() and argless new Date() are not available');
   const calls = []; const phases = []; const logs = [];
   const agent = async (prompt, opts = {}) => {
     const call = { n: calls.length + 1, prompt: String(prompt), opts, phase: phases[phases.length - 1] || null };

package/test/layer1/hook-harness.js

@@ -2,7 +2,8 @@
 // THE LAYER-1 HARNESS WITH THE AGENTS' HOOKS (docs/TESTING.md). test/layer1/harness.js runs the real script with a
 // stand-in for every agent; this runs, in addition, each agent definition's own PreToolUse hook on the stand-in's answer
 // — the generated command, from the generated agents file — exactly as Claude Code would when the agent submits its
-// StructuredOutput: the hook's `updatedInput` becomes the answer the script sees. An agent the stand-in fails (null)
+// StructuredOutput: the hook's `updatedInput` becomes the answer the script sees. Its input names the calling agent
+// (agent_type), as the real tool's does. An agent the stand-in fails (null)
 // never answers, so its hook never runs. No AI.
 const fs = require('fs');
 const { spawnSync } = require('child_process');
@@ -25,7 +26,7 @@ async function runWithHooks(source, args, agentsFile, answer) {
     const pre = ((def.hooks || {}).PreToolUse || []).filter((h) => new RegExp(`^(${h.matcher})$`).test('StructuredOutput'));
     let input = a;
     for (const h of pre) for (const c of h.hooks || []) {
-      const res = spawnSync('bash', ['-c', c.command], { input: JSON.stringify({ hook_event_name: 'PreToolUse', tool_name: 'StructuredOutput', tool_input: input }),
+      const res = spawnSync('bash', ['-c', c.command], { input: JSON.stringify({ hook_event_name: 'PreToolUse', tool_name: 'StructuredOutput', tool_input: input, agent_type: call.opts.agentType }),
         encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
       hookRuns.push({ agentType: call.opts.agentType, status: res.status, stderr: (res.stderr || '').slice(-2000) });
       if (res.status !== 0) throw new Error(`hook of ${call.opts.agentType} exited ${res.status}: ${(res.stderr || '').slice(-1500)}`);