@smartmemory/compose 0.2.57-beta → 0.3.0

package/lib/result-normalizer.js

@@ -13,6 +13,7 @@ import { calculateCost } from './model-pricing.js';
 import { resolveAgentConfig } from './agent-string.js';
 import { normalizeReviewResult } from './review-normalize.js';
 import { KNOWN_VERSIONS } from './build-stream-schema.js';
+import { runLocalClaudeAgent } from './local-claude-connector.js';
 
 // ---------------------------------------------------------------------------
 // Error classes
@@ -83,6 +84,65 @@ export function outputFieldsToJsonSchema(outputFields) {
   };
 }
 
+/**
+ * Build a nested JSON Schema from a consumer descriptor's contract CLOSURE
+ * (`{ root, contracts }`), resolving the engine's type grammar so the agent-facing
+ * schema — and thus the ENGINE's strict validation — see the same shapes:
+ *   - `X?`          optional field (omitted from `required`)
+ *   - `X[]`         typed array (recursively; nests as `X[][]`)
+ *   - `(a|b)[]`     enum array
+ *   - `a|b`         enum
+ *   - `Name`        named record reference, resolved against the closure
+ *   - primitives / `object` / `array` as before
+ *
+ * The flat `outputFieldsToJsonSchema` only mapped primitives, so a named record
+ * (`Artifact`) or typed array (`Artifact[]`) degraded to `{}`, leaving the agent
+ * blind to nested fields the engine still requires. Returns null for a malformed
+ * closure so callers can fall back to the flat schema.
+ */
+export function contractClosureToJsonSchema(closure) {
+  if (!closure || typeof closure !== 'object') return null;
+  const { root, contracts } = closure;
+  if (typeof root !== 'string' || !contracts || typeof contracts !== 'object') return null;
+  if (!Object.hasOwn(contracts, root)) return null;
+
+  function typeToSchema(typeStr, seen) {
+    let raw = String(typeStr);
+    let optional = false;
+    if (raw.endsWith('?')) { optional = true; raw = raw.slice(0, -1); }
+
+    const enumArray = /^\(([^()]+)\)\[\]$/.exec(raw);
+    if (enumArray) {
+      return { optional, schema: { type: 'array', items: { enum: enumArray[1].split('|') } } };
+    }
+    if (raw.endsWith('[]')) {
+      return { optional, schema: { type: 'array', items: typeToSchema(raw.slice(0, -2), seen).schema } };
+    }
+    const lower = raw.toLowerCase();
+    if (TYPE_MAP[lower]) return { optional, schema: { ...TYPE_MAP[lower] } };
+    if (Object.hasOwn(contracts, raw)) return { optional, schema: buildRecord(raw, seen) };
+    if (raw.includes('|')) return { optional, schema: { enum: raw.split('|') } };
+    return { optional, schema: {} }; // unknown → unconstrained
+  }
+
+  function buildRecord(name, seen) {
+    if (seen.has(name)) return { type: 'object' }; // cycle guard (engine forbids recursion)
+    const fields = contracts[name];
+    if (!fields || typeof fields !== 'object') return { type: 'object' };
+    const nextSeen = new Set(seen).add(name);
+    const properties = {};
+    const required = [];
+    for (const [field, typeStr] of Object.entries(fields)) {
+      const { schema, optional } = typeToSchema(typeStr, nextSeen);
+      properties[field] = schema;
+      if (!optional) required.push(field);
+    }
+    return { type: 'object', required, properties };
+  }
+
+  return buildRecord(root, new Set());
+}
+
 // ---------------------------------------------------------------------------
 // JSON extraction helpers
 // ---------------------------------------------------------------------------
@@ -150,6 +210,20 @@ export class AgentTimeoutError extends Error {
   }
 }
 
+/**
+ * D3: raised when an `onAgentEvent` observer asks to stop an in-flight agent run
+ * (e.g. the GSD stuck detector tripped mid-execution). Carries the observer's
+ * reason so the caller can render a diagnostic and halt.
+ */
+export class AgentAbortedError extends Error {
+  constructor(stepId, reason) {
+    super(`Agent run on step "${stepId}" aborted by observer`);
+    this.name = 'AgentAbortedError';
+    this.stepId = stepId;
+    this.reason = reason;
+  }
+}
+
 /**
  * STRAT-DEDUP-AGENTRUN-V3: `runAndNormalize` is now a thin wrapper around the
  * Python connector tier exposed through `stratum_agent_run`. Events arrive as
@@ -178,13 +252,35 @@ export async function runAndNormalize(_connectorIgnored, prompt, stepDispatch, o
 
   const stepId = stepDispatch.step_id ?? 'unknown';
   const agentType = stepDispatch.agent ?? 'claude';
-  const cfg = resolveAgentConfig(agentType);
+  // D6: the engine ships only the bare provider literal (stepDispatch.agent), so
+  // the full profile string (with tool restrictions + model tier) is supplied
+  // compose-side via opts.profile, keyed off the compose-owned sidecar. It
+  // overrides the bare literal for capability resolution; the provider is
+  // unchanged. Absent → bare literal (no restrictions), preserving old behavior.
+  const cfg = resolveAgentConfig(opts.profile || agentType);
+  // A read-only profile (no Edit/Write/Bash) also maps to a read-only sandbox so
+  // the restriction binds at the engine's connector, not just at this invocation.
+  const readOnlyProfile = Array.isArray(cfg.disallowedTools)
+    && ['Edit', 'Write'].every((tool) => cfg.disallowedTools.includes(tool));
+  const sandboxMode = readOnlyProfile ? 'read-only' : undefined;
 
   const outputFields = stepDispatch.output_fields;
   const hasSchema = outputFields && typeof outputFields === 'object' && Object.keys(outputFields).length > 0;
   let actualPrompt = prompt;
   let schema = null;
-  if (hasSchema) {
+  // Consumer-fanout dispatch carries the full contract CLOSURE so nested named
+  // records and typed arrays reach the agent (and match the engine's strict
+  // validation). Fall back to the flat field→primitive schema otherwise.
+  const closureSchema = contractClosureToJsonSchema(stepDispatch.output_contract_closure);
+  // A valid but EMPTY root contract ({}) yields zero fields, so `hasSchema` is
+  // false while a real (empty-object) closure schema exists. Structured
+  // extraction must be gated on "a contract is declared", not "the root has
+  // fields" — otherwise the agent's `{}` is discarded and the item wedges.
+  const hasStructuredOutput = Boolean(closureSchema) || hasSchema;
+  if (closureSchema) {
+    schema = closureSchema;
+    actualPrompt = injectSchema(prompt, schema);
+  } else if (hasSchema) {
     schema = outputFieldsToJsonSchema(outputFields);
     actualPrompt = injectSchema(prompt, schema);
   }
@@ -206,6 +302,25 @@ export async function runAndNormalize(_connectorIgnored, prompt, stepDispatch, o
   let timedOut = false;
   let userInterruptAction = null;
   let timeoutHandle = null;
+  // D3: an onAgentEvent observer (e.g. the GSD stuck detector) may ask to stop
+  // the run mid-stream by returning a truthy reason from a tool event.
+  let abortReason = null;
+
+  // V2/V3: CONTROLLED claude executions (consumer items, review fanout) run via
+  // the compose-LOCAL connector — the only seam that can enforce claude tool
+  // restrictions AND be interrupted (the sync engine agent_run can do neither;
+  // its background mode is codex+read-only-only). Abort replaces cancelAgentRun
+  // as the stop mechanism, and the connector streams real tool events so the
+  // stuck detector / timeout actually stop a runaway agent.
+  const useLocalClaude = opts.localExecution === true && cfg.provider === 'claude';
+  const abortController = useLocalClaude ? new AbortController() : null;
+  const stopRun = () => {
+    if (abortController) {
+      try { abortController.abort(); } catch { /* already aborted */ }
+    } else {
+      stratum.cancelAgentRun(correlationId).catch(() => {});
+    }
+  };
 
   // Subscribe BEFORE calling agentRun — events fire during the call.
   const unsub = stratum.onEvent(correlationId, subStepId, (env) => {
@@ -271,12 +386,22 @@ export async function runAndNormalize(_connectorIgnored, prompt, stepDispatch, o
       default:
         break;
     }
+    // D3: let an observer inspect every processed envelope and request a stop
+    // (returns a truthy reason). Cancel the in-flight run once; the post-run
+    // guard rethrows as AgentAbortedError.
+    if (opts.onAgentEvent) {
+      const stop = opts.onAgentEvent(env);
+      if (stop && !abortReason) {
+        abortReason = stop;
+        stopRun();
+      }
+    }
   });
 
   if (maxDurationMs) {
     timeoutHandle = setTimeout(() => {
       timedOut = true;
-      stratum.cancelAgentRun(correlationId).catch(() => {});
+      stopRun();
     }, maxDurationMs);
   }
 
@@ -284,34 +409,118 @@ export async function runAndNormalize(_connectorIgnored, prompt, stepDispatch, o
   if (progress?.on) {
     onInterrupt = () => {
       userInterruptAction = progress.consumeAction?.() ?? 'skip';
-      stratum.cancelAgentRun(correlationId).catch(() => {});
+      stopRun();
     };
     progress.on('interrupt', onInterrupt);
   }
 
+  // V2/V3: on the local path the connector's tool_use events (not engine
+  // progress notifications) drive narration + the stuck detector. This bridge
+  // mirrors the engine onEvent handler's tool handling and lets the observer
+  // abort a spinning run.
+  const localOnToolUse = ({ tool, input }) => {
+    if (onToolUse) onToolUse({ tool, input, timestamp: Date.now() });
+    if (streamWriter) streamWriter.write({ type: 'tool_use', tool, input: input ?? {} });
+    if (progress) progress.toolUse(tool, input?.command ?? input?.pattern ?? input?.file_path ?? '');
+    if (opts.onAgentEvent && !abortReason) {
+      const env = { schema_version: '0.2.6', kind: 'tool_use_summary', metadata: { tool, input: input ?? {}, summary: '', output: '' } };
+      const stop = opts.onAgentEvent(env);
+      if (stop) { abortReason = stop; stopRun(); }
+    }
+  };
+
   let runResult;
   try {
-    runResult = await stratum.agentRun(agentType, actualPrompt, {
-      modelID:          cfg.modelID ?? undefined,
-      allowedTools:     cfg.allowedTools ?? undefined,
-      disallowedTools:  cfg.disallowedTools ?? undefined,
-      thinking:         cfg.thinking ?? undefined,
-      effort:           cfg.effort ?? undefined,
-      cwd:              opts.cwd ?? undefined,
-      correlationId,
-    });
+    if (useLocalClaude) {
+      // Test seam: an installed factory shim exposes an SDK-shaped query adapter
+      // so the goldens drive the local path without spawning a real claude.
+      // Gated on NODE_ENV=test so production always uses the real SDK.
+      const localQuery = opts.localQuery
+        ?? (process.env.NODE_ENV === 'test' && stratum ? stratum._localQuery : undefined);
+      runResult = await runLocalClaudeAgent(actualPrompt, {
+        cwd:             opts.cwd ?? undefined,
+        model:           cfg.modelID ?? undefined,
+        allowedTools:    cfg.allowedTools ?? undefined,
+        disallowedTools: cfg.disallowedTools ?? undefined,
+        thinking:        cfg.thinking ?? undefined,
+        abortController,
+        onToolUse:       localOnToolUse,
+        ...(localQuery ? { query: localQuery } : {}),
+      });
+    } else {
+      runResult = await stratum.agentRun(agentType, actualPrompt, {
+        modelID:          cfg.modelID ?? undefined,
+        allowedTools:     cfg.allowedTools ?? undefined,
+        disallowedTools:  cfg.disallowedTools ?? undefined,
+        thinking:         cfg.thinking ?? undefined,
+        effort:           cfg.effort ?? undefined,
+        sandboxMode,
+        cwd:              opts.cwd ?? undefined,
+        correlationId,
+      });
+    }
   } catch (err) {
-    if (timedOut) throw new AgentTimeoutError(stepId, Date.now() - startTime);
+    // F3/G3: preserve any billable usage the failed run reported (the local
+    // connector attaches it on a non-success result / usage-bearing rejection) so
+    // the consumer failure envelope can still debit the engine/GSD ledgers. G3:
+    // the timeout/abort throws happen here too — attach the usage to THOSE errors
+    // (not only the generic AgentError) so timeout/stuck attempts are billed.
+    const errUsage = (err && typeof err === 'object' && err.usage) ? err.usage : null;
+    if (timedOut) {
+      const e = new AgentTimeoutError(stepId, Date.now() - startTime);
+      if (errUsage) e.usage = errUsage;
+      throw e;
+    }
     if (userInterruptAction) throw new UserInterruptError(stepId, userInterruptAction);
-    throw new AgentError(err?.message ?? 'Agent run failed');
+    if (abortReason) {
+      const e = new AgentAbortedError(stepId, abortReason);
+      if (errUsage) e.usage = errUsage;
+      throw e;
+    }
+    const agentError = new AgentError(err?.message ?? 'Agent run failed');
+    if (errUsage) agentError.usage = errUsage;
+    throw agentError;
   } finally {
     if (timeoutHandle) clearTimeout(timeoutHandle);
     if (onInterrupt && progress?.removeListener) progress.removeListener('interrupt', onInterrupt);
     unsub();
   }
 
-  if (timedOut) throw new AgentTimeoutError(stepId, Date.now() - startTime);
+  // H2: when the underlying run RESOLVES late (rather than rejecting) after a
+  // timeout/abort fired, its billable usage is on runResult.usage. Copy it onto
+  // the thrown error — the same single channel the rejection path (G3) uses — so
+  // the consumer timeout envelope / stuck-ledger accounting still bill the attempt.
+  // Throwing here means usageTotals is never returned, so this is the ONLY channel
+  // (no double count).
+  const lateUsage = (runResult && typeof runResult === 'object' && runResult.usage && typeof runResult.usage === 'object')
+    ? runResult.usage
+    : null;
+  if (timedOut) {
+    const e = new AgentTimeoutError(stepId, Date.now() - startTime);
+    if (lateUsage) e.usage = lateUsage;
+    throw e;
+  }
   if (userInterruptAction) throw new UserInterruptError(stepId, userInterruptAction);
+  if (abortReason) {
+    const e = new AgentAbortedError(stepId, abortReason);
+    if (lateUsage) e.usage = lateUsage;
+    throw e;
+  }
+
+  // D2(b): the TS agent_run path returns a synchronous `complete` envelope with
+  // aggregate usage ({usd?, tokens, ms}) and streams NO step_usage progress
+  // events — without folding it in, budget accounting debits nothing on the TS
+  // route. The python / factory-shim path streams step_usage events (usageTotals
+  // already populated), so adopt runResult.usage only when the event stream
+  // contributed nothing (avoids double counting).
+  const runUsage = runResult && typeof runResult === 'object' ? runResult.usage : null;
+  const usageFromEvents = usageTotals.input_tokens || usageTotals.output_tokens || usageTotals.cost_usd;
+  if (runUsage && typeof runUsage === 'object' && !usageFromEvents) {
+    if (typeof runUsage.tokens === 'number') usageTotals.output_tokens += runUsage.tokens;
+    if (typeof runUsage.usd === 'number') usageTotals.cost_usd += runUsage.usd;
+    if (typeof runUsage.ms === 'number') usageTotals.duration_ms = (usageTotals.duration_ms ?? 0) + runUsage.ms;
+    if (!usageTotals.model && runResult.telemetry?.model) usageTotals.model = runResult.telemetry.model;
+  }
 
   const text = (runResult && typeof runResult.text === 'string' && runResult.text.length > 0)
     ? runResult.text
@@ -350,7 +559,7 @@ export async function runAndNormalize(_connectorIgnored, prompt, stepDispatch, o
     return { text, result: reviewResult, usage: usageTotals };
   }
 
-  if (!hasSchema) {
+  if (!hasStructuredOutput) {
     return { text, result: null, usage: usageTotals };
   }
 
@@ -362,7 +571,13 @@ export async function runAndNormalize(_connectorIgnored, prompt, stepDispatch, o
       process.stderr.write('    ⚠ Could not extract JSON from agent output, using fallback\n');
     }
     const summary = text.slice(0, 200).replace(/\n/g, ' ').trim();
-    return { text, result: { summary: summary || 'Step complete' }, usage: usageTotals };
+    const normalizationFailure = summary || 'Could not extract structured output';
+    return {
+      text,
+      result: { summary: normalizationFailure },
+      usage: usageTotals,
+      normalizationFailure,
+    };
   }
 
   return { text, result, usage: usageTotals };

package/lib/review-lenses.js

@@ -158,7 +158,7 @@ export function shouldRunCrossModel(filesChanged, lineCount = null) {
  * Triage: decide which lenses to activate.
  *
  * @param {string[]} fileList - list of changed file paths
- * @returns {Array<object>} LensTask[] for parallel_dispatch
+ * @returns {Array<object>} lens items for TS consumer fanout
  */
 export function triageLenses(fileList) {
   const activeLensIds = [...BASELINE_LENSES];

package/lib/step-prompt.js

@@ -71,6 +71,36 @@ export function buildStepPrompt(stepDispatch, context) {
 
   sections.push(`## Intent\n${stepDispatch.intent}`);
 
+  // D7(a): restore the exact TaskResult filename contract. The engine renders
+  // only whole `${item}` (dotted `${item.id}` is REF_INVALID), so the per-item
+  // output path is rendered compose-side from the item's id. When the consumer
+  // loop supplies it, spell out the exact path so the agent cannot misname the
+  // file the blackboard reader expects.
+  if (context.taskResultPath) {
+    sections.push(
+      `## TaskResult Output File\n`
+      + `Write your TaskResult JSON to EXACTLY this path (do not choose a different name):\n`
+      + `\`${context.taskResultPath}\``,
+    );
+  }
+
+  // A retried issuance (e.g. a consumer-fanout item that failed its contract,
+  // ensure, or connector on a prior attempt) carries the engine's structured
+  // previousFailure. Render its reason so the retry can fix the cause rather
+  // than repeat it.
+  if (stepDispatch.previousFailure) {
+    const pf = stepDispatch.previousFailure;
+    const reason = typeof pf === 'string'
+      ? pf
+      : (typeof pf.reason === 'string' ? pf.reason : JSON.stringify(pf));
+    if (reason) {
+      const attemptNote = typeof pf === 'object' && Number.isInteger(pf.attempt)
+        ? ` (attempt ${pf.attempt})`
+        : '';
+      sections.push(`## Previous Attempt Failed${attemptNote}\nYour previous attempt was rejected. Fix the cause before finishing:\n${reason}`);
+    }
+  }
+
   sections.push(`## Inputs\n${JSON.stringify(stepDispatch.inputs, null, 2)}`);
 
   if (Array.isArray(stepDispatch.output_fields) && stepDispatch.output_fields.length > 0) {
@@ -133,127 +163,19 @@ export function buildStepPrompt(stepDispatch, context) {
     }
   }
 
-  return sections.join('\n\n');
-}
-
-/**
- * Build a "File Ownership Conflicts" section for decompose-step retry prompts.
- *
- * @param {Array<{task_a: string, task_b: string, files: string[]}>} conflicts
- * @returns {string}
- */
-function buildConflictSection(conflicts) {
-  const lines = [
-    '## File Ownership Conflicts — Resolution Required',
-    '',
-    'The following task pairs share `files_owned` entries but have no `depends_on`',
-    'relationship. Independent tasks may not both claim the same file.',
-    'Add a `depends_on` edge from the later task to the earlier task to resolve each conflict:',
-    '',
-  ];
-
-  for (const { task_a, task_b, files } of conflicts) {
-    lines.push(`- **${task_a}** and **${task_b}** both own:`);
-    for (const f of files) lines.push(`    - \`${f}\``);
-    lines.push(`  → Add \`depends_on: [${task_a}]\` to \`${task_b}\` (or vice versa).`);
-    lines.push('');
-  }
-
-  return lines.join('\n');
-}
-
-// COMP-PAR-MERGE-QUEUE-CONSUMER-RETRY: pre-merge bounce context (gate_failed /
-// merge_conflict) is injected into a re-dispatched task's prompt on BOTH paths:
-// - server-dispatch: SERVER-SIDE in Stratum's ParallelExecutor._render_prompt
-//   (the server re-resolves the task list from flow state on each re-dispatch).
-// - consumer-dispatch: COMPOSE-SIDE via formatBounceForPrompt() below, appended
-//   in executeParallelDispatch's retry loop (Compose, not Stratum, builds the
-//   per-task prompt on that path). This is the Compose mirror of
-//   parallel_exec.py `_format_bounce_for_prompt`.
-
-/**
- * Format a ParMergeBounce record (contracts/par-merge-bounce.json) as a prompt
- * section telling a re-dispatched task its prior attempt was rejected before
- * merge. Mirrors Stratum's `_format_bounce_for_prompt` (parallel_exec.py).
- * Degrades to '' on null/non-object input so a malformed bounce never breaks a
- * re-run prompt.
- *
- * @param {{task_id?:string, reason?:string, command?:string|null,
- *          exit_code?:number|null, files?:string[], excerpt?:string}} bounce
- * @returns {string}
- */
-export function formatBounceForPrompt(bounce) {
-  if (!bounce || typeof bounce !== 'object') return '';
-  const files = Array.isArray(bounce.files) && bounce.files.length
-    ? bounce.files.join(', ')
-    : '(none reported)';
-  const lines = ['## Previous attempt was rejected before merge — fix this before finishing'];
-  if (bounce.reason === 'gate_failed') {
-    const code = bounce.exit_code == null ? '?' : String(bounce.exit_code);
-    lines.push(`Your last attempt FAILED the pre-merge gate \`${bounce.command ?? '?'}\` (exit ${code}). It was not merged.`);
-  } else if (bounce.reason === 'merge_conflict') {
-    lines.push("Your last attempt produced changes that CONFLICTED with another task's changes at merge time. It was not merged.");
-  } else {
-    lines.push('Your last attempt was rejected before merge.');
-  }
-  lines.push(`Files involved: ${files}`);
-  if (bounce.excerpt) {
-    lines.push('Failure output:', '```', String(bounce.excerpt), '```');
-  }
-  return lines.join('\n');
-}
-
-/**
- * Build a retry prompt when postconditions failed.
- *
- * @param {object}   stepDispatch - Original step dispatch
- * @param {string[]} violations   - List of postcondition violations
- * @param {object}   context      - Execution context
- * @param {Array<{task_a, task_b, files}>} [conflicts] - Structured file conflicts (optional)
- * @returns {string}
- */
-export function buildRetryPrompt(stepDispatch, violations, context, conflicts) {
-  const violationLines = violations.map(v => `- ${v}`).join('\n');
-  const header = `RETRY — Previous attempt failed postconditions:\n${violationLines}\n\nFix these issues and try again.`;
-
-  const sections = [header, buildStepPrompt(stepDispatch, context)];
-
-  if (conflicts && conflicts.length > 0) {
-    sections.push(buildConflictSection(conflicts));
-  }
-
-  let prompt = sections.join('\n\n');
-
-  // COMP-FIX-HARD T6: in bug-mode diagnose retries, prepend a digest of
-  // previously rejected hypotheses so the next attempt avoids dead ends.
-  // Guard: silent no-op if any precondition fails (regression-safe).
-  if (
-    context && context.mode === 'bug'
-    && stepDispatch && stepDispatch.step_id === 'diagnose'
-    && context.bug_code && context.cwd
-  ) {
-    try {
-      const entries = readHypotheses(context.cwd, context.bug_code);
-      const block = formatRejectedHypotheses(entries);
-      if (block) prompt = block + '\n' + prompt;
-    } catch {
-      // best-effort: never let ledger I/O break a retry
-    }
+  // COMP-FIX-HARD T6: on a bug-mode DIAGNOSE (re)attempt, surface the previously
+  // REJECTED hypotheses from the per-bug ledger at the very TOP of the prompt so
+  // the agent does not re-propose a diagnosis already ruled out. The TS diagnose
+  // retry reissues through buildStepPrompt (there is no separate buildRetryPrompt
+  // in v1), so the ledger context — which previousFailure.reason alone dropped —
+  // is restored here. Only bug mode + the diagnose step + a populated ledger of
+  // rejected entries renders anything; every other step is byte-identical.
+  if (context.mode === 'bug' && context.bug_code && stepDispatch.step_id === 'diagnose') {
+    const rejectedBlock = formatRejectedHypotheses(readHypotheses(context.cwd, context.bug_code));
+    if (rejectedBlock) sections.unshift(rejectedBlock.trimEnd());
   }
 
-  return prompt;
-}
-
-/**
- * Build a prompt for a child flow step within a larger workflow.
- *
- * @param {object} flowDispatch - Flow dispatch (child_flow_name, child_step)
- * @param {object} context      - Execution context
- * @returns {string}
- */
-export function buildFlowStepPrompt(flowDispatch, context) {
-  const header = `You are executing a sub-workflow "${flowDispatch.child_flow_name}" as part of a larger workflow.`;
-  return `${header}\n\n${buildStepPrompt(flowDispatch.child_step, context)}`;
+  return sections.join('\n\n');
 }
 
 /**