melchizedek-agents 1.0.2 → 1.1.0

package/dist/lib/runtime/native/interrupts.js

@@ -80,14 +80,42 @@
  *      builds its request. A later step finds the agent's own events last,
  *      so the call runs once.
  *
+ * PAUSES INSIDE DELEGATED SUBAGENTS (WS6-2a, ADR 0110). A subagent runs in
+ * its own child session (delegate.ts); an approval request or question it
+ * leaves open ends its run paused, and its caller leaves the delegated
+ * call open (no response stored) and ends paused too, up to the turn.
+ * delegatedPauses finds such a pause from any session by walking down:
+ * each call its agent left open (openCalls) leads to the child session
+ * under the call's name, whose own open request or question is the pause,
+ * or whose own open call leads one level further. The answer travels back
+ * down the same way: before each step, the loop resumes the open call
+ * whose pause the latest user message answers (agentLoop.ts), and the
+ * child reads the same answer from its own session, as it would at the top.
+ *
+ * NESTED SYNDICATES (WS6-2b, ADR 0111). The child session of a call is the
+ * one runSubagent files it under: the agent path (delegate.ts childAppName),
+ * else, for a conversation stored before ADR 0111, the subagent's name
+ * alone (legacyChild). A nested delegate syndicate is its orchestrator
+ * there, so the walk goes on through its open calls. A nested workflow
+ * syndicate holds a paused walk there instead: its own pause record (the
+ * workflow's event naming every interrupt it left open, authored by the
+ * workflow under the call's name) makes an approval request an agent node
+ * raised, or an ask_user node's question, the pause, with the node that
+ * asked at the end of the path. The walk stops there: a pause inside a
+ * workflow node's own delegation does not run (lib/workflow/agentNode.ts).
+ *
  * ADK stays out of this file: an ADK tool an agent still lists is asked
  * whether it gates through its own checkRequireConfirmation, by shape.
  */
 import { isDeepStrictEqual } from 'node:util';
 import { nativeToolOf } from '../../models/schemaNormalize.js';
 import { instructionToolOf, isTool, toolOf } from '../../tools/tool.js';
+import { inputRequestFrom } from '../../workflowConfig.js';
+import { pendingApproval } from '../approvals.js';
 import { getFunctionCalls, getFunctionResponses } from '../events.js';
-import { REQUEST_CONFIRMATION_CALL, REQUEST_CREDENTIAL_CALL, isSegmentPrefix } from './history.js';
+import { ASK_USER, pendingQuestion } from '../questions.js';
+import { childAppName, legacyChild } from './delegate.js';
+import { REQUEST_CONFIRMATION_CALL, REQUEST_CREDENTIAL_CALL, REQUEST_INPUT_CALL, isSegmentPrefix } from './history.js';
 import { isToolset } from './request.js';
 /** A confirmation that does not bind to its pinned call: ADK's IntentMismatchError, by name and text. */
 export class IntentMismatchError extends Error {
@@ -308,3 +336,175 @@ export async function grantedCalls(agent, scope) {
     }
     return undefined;
 }
+/** The deepest a chain of delegated pauses is followed: nested syndicates stop at 16 levels (lib/compile.ts). */
+const MAX_DELEGATION_DEPTH = 16;
+/** The engine's own long-running calls: never a delegation. */
+const FRAMEWORK_CALLS = new Set([REQUEST_CONFIRMATION_CALL, REQUEST_CREDENTIAL_CALL, ASK_USER]);
+const hasUserText = (e) => e.author === 'user' && (e.content?.parts ?? []).some((p) => typeof p.text === 'string' && p.text.trim() !== '' && !p.thought);
+/**
+ * The calls an agent made that are still open: no later event answers it,
+ * and the person has not written since. Only an agent's calls count (a
+ * call in a user-authored event is never one), and the engine's own
+ * framework calls are left out. `author`, when given, keeps one agent's
+ * calls. Latest event first, calls in call order.
+ */
+export function openCalls(events, author) {
+    const answered = new Set();
+    const open = [];
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (hasUserText(event))
+            break;
+        for (const r of getFunctionResponses(event))
+            if (r.id)
+                answered.add(r.id);
+        if (!event.author || event.author === 'user' || (author !== undefined && event.author !== author))
+            continue;
+        for (const call of getFunctionCalls(event)) {
+            if (!call.id || !call.name || FRAMEWORK_CALLS.has(call.name) || answered.has(call.id))
+                continue;
+            open.push({ author: event.author, call });
+        }
+    }
+    return open;
+}
+/**
+ * What waits inside the delegated call `call` that `caller` left open: the
+ * child session under the call's name (where runSubagent runs it), and its
+ * own open approval request or question, else a pause inside a call it left
+ * open, one level down. Only the subagent's own requests count: a request
+ * or question authored by anyone else is none.
+ */
+async function pauseBelow(key, caller, call, depth, seen) {
+    const name = call.name;
+    const id = call.id;
+    if (depth >= MAX_DELEGATION_DEPTH || seen.has(name))
+        return undefined;
+    // Where runSubagent filed the call (ADR 0111), else where it filed it before.
+    const own = key.appName === undefined ? undefined : await key.sessions.get({ appName: childAppName({ appName: key.appName, delegated: key.delegated === true }, caller, name), userId: key.userId, sessionId: key.sessionId });
+    const child = own ?? (await legacyChild(key.sessions, key, name, true));
+    if (!child)
+        return undefined;
+    const here = [caller, name];
+    const walked = workflowPause(child.events, name);
+    if (walked) {
+        const path = [...here, walked.asker];
+        return {
+            path,
+            callIds: [id],
+            ...(walked.approval ? { approval: { ...walked.approval, path } } : {}),
+            ...(walked.question ? { question: { ...walked.question, path } } : {}),
+        };
+    }
+    const approval = pendingApproval(child.events);
+    if (approval && approval.agent === name)
+        return { path: here, callIds: [id], approval: { ...approval, path: here } };
+    const question = pendingQuestion(child.events);
+    if (question && question.node === name)
+        return { path: here, callIds: [id], question: { ...question, path: here } };
+    const [first] = await delegatedPauses({ ...key, appName: child.appName, delegated: true }, child.events, name, depth + 1, new Set([...seen, name]));
+    if (!first)
+        return undefined;
+    const path = [caller, ...first.path];
+    return {
+        path,
+        callIds: [id, ...first.callIds],
+        ...(first.approval ? { approval: { ...first.approval, path } } : {}),
+        ...(first.question ? { question: { ...first.question, path } } : {}),
+    };
+}
+/**
+ * The pause a nested workflow's walk holds in its child session (ADR 0111):
+ * the workflow's own pause record, the last event, authored by the
+ * workflow (`name`) at its own path with no content, names the open
+ * interrupts; the approval request or ask_user question among them is the
+ * pause, and the node that raised it the asker. Undefined when the session
+ * holds no paused walk of `name`'s.
+ */
+function workflowPause(events, name) {
+    const record = events[events.length - 1];
+    if (!record || record.author !== name || (record.content?.parts ?? []).length > 0 || record.nodeInfo?.path !== name)
+        return undefined;
+    const open = new Set(record.longRunningToolIds ?? []);
+    if (open.size === 0)
+        return undefined;
+    const approval = pendingApproval(events);
+    if (approval && open.has(approval.id) && approval.agent && approval.agent !== 'user')
+        return { asker: approval.agent, approval };
+    // The ask_user node's request the record names: the walk stores node inputs as user turns, so a later one may follow it.
+    for (let i = events.length - 2; i >= 0; i--) {
+        const event = events[i];
+        if (!event.author || event.author === 'user')
+            continue;
+        for (const call of getFunctionCalls(event)) {
+            if (call.name !== REQUEST_INPUT_CALL || !call.id || !open.has(call.id))
+                continue;
+            const question = inputRequestFrom(event.author, call);
+            if (question && question.id === call.id)
+                return { asker: event.author, question };
+        }
+    }
+    return undefined;
+}
+/**
+ * Every pause waiting inside a delegated call still open in `events` (one
+ * session's events), latest call first: each open call whose child session
+ * holds an open approval request or question, at any depth. `author`, when
+ * given, keeps one agent's calls. A call the person has written past is no
+ * longer open, and neither is anything waiting below it.
+ */
+export async function delegatedPauses(key, events, author, depth = 0, seen = new Set()) {
+    const out = [];
+    for (const { author: caller, call } of openCalls(events, author)) {
+        const pause = await pauseBelow(key, caller, call, depth, seen);
+        if (pause)
+            out.push(pause);
+    }
+    return out;
+}
+/** The interrupt a delegated pause waits on: the approval request's id, or the question's. */
+export function interruptIdOf(pause) {
+    return pause.approval?.id ?? pause.question?.id;
+}
+/**
+ * The delegated calls `agent` left open that the latest user message
+ * answers (ADR 0110): the message's approval decisions and question
+ * answers (function responses to `adk_request_confirmation` or `ask_user`)
+ * matched, by interrupt id, to the pause below each open call. Undefined
+ * when the message answers none. The child binds the answer itself: an
+ * approval is checked against its pinned call there (approvedCalls), as at
+ * the top.
+ */
+export async function resumedDelegations(agent, scope, sessions) {
+    const events = scope.session.events;
+    let latest;
+    for (let i = events.length - 1; i >= 0 && !latest; i--)
+        if (events[i]?.author === 'user')
+            latest = events[i];
+    if (!latest)
+        return undefined;
+    const answerParts = (latest.content?.parts ?? []).filter((p) => {
+        const r = p.functionResponse;
+        return !!r?.id && (r.name === REQUEST_CONFIRMATION_CALL || r.name === ASK_USER);
+    });
+    if (answerParts.length === 0)
+        return undefined;
+    const pauses = await delegatedPauses({ sessions, userId: scope.session.userId, sessionId: scope.session.id, appName: scope.session.appName, delegated: scope.delegated === true }, events, agent.name);
+    if (pauses.length === 0)
+        return undefined;
+    const open = new Map(openCalls(events, agent.name).map(({ call }) => [call.id, call]));
+    const answers = new Map();
+    const waiting = [];
+    for (const pause of pauses) {
+        const callId = pause.callIds[0];
+        const parts = answerParts.filter((p) => p.functionResponse?.id === interruptIdOf(pause));
+        if (parts.length)
+            answers.set(callId, [...(answers.get(callId) ?? []), ...parts]);
+        else
+            waiting.push(callId);
+    }
+    if (answers.size === 0)
+        return undefined;
+    const calls = [...answers.keys()].map((id) => open.get(id)).filter((c) => !!c);
+    return { calls, answers, waiting: waiting.filter((id) => !answers.has(id)), tools: await toolsOf(agent, scope) };
+}

package/dist/lib/runtime/native/request.d.ts

@@ -13,8 +13,12 @@
  *
  * THE REQUEST, in the order ADK built it:
  *   1. The agent's generateContentConfig, and its output schema when it has
- *      no tools (or the model takes a schema beside tools: Gemini 2 and
- *      later on Vertex AI).
+ *      no tools, or when every model the step may call (its own and its
+ *      fallback_model) takes a schema beside tools in one request: Claude
+ *      from Opus 4.8, Sonnet 5 and Haiku 5.5 on, OpenAI, Gemini 2 and later
+ *      on Vertex AI (outputSchemaBesideTools, lib/models/capabilities.ts,
+ *      ADR 0109). That is how an orchestrator that delegates answers in a
+ *      schema without a set_model_response call.
  *   2. The system prompt, each piece joined to the last by a blank line:
  *      - the identity lines ("You are an agent. Your internal name is …"),
  *        unless the agent may transfer to no one (an output schema rules
@@ -112,6 +116,8 @@ export interface NativeAgent {
     fallbackModel?: string;
     /** `context:` (ADR 0033): compact the history into a summary past a token threshold. The loop runs it before each step (compaction.ts). */
     context?: ContextConfig;
+    /** The syndicate's `max_concurrency` (ADR 0116): delegated calls one step runs at once. Default DEFAULT_MAX_CONCURRENCY (delegate.ts). */
+    maxConcurrency?: number;
 }
 /** What an instruction function reads. */
 export interface InstructionContext {
@@ -166,7 +172,11 @@ export interface BuiltRequest {
 export declare const SET_MODEL_RESPONSE = "set_model_response";
 /** set_model_response as an own Tool: its answer is the arguments, as JSON text, and it ends the step. */
 export declare function setModelResponseTool(outputSchema: Record<string, unknown>): Tool;
-/** Whether the model takes an output schema beside tools in one request (ADK: Vertex AI, Gemini 2 and later). */
+/**
+ * ADK's rule for whether the model takes an output schema beside tools in one
+ * request (Vertex AI, Gemini 2 and later). `mode: task` keeps it as it is,
+ * for the instruction line ADK's processor writes there.
+ */
 export declare function outputSchemaWithTools(model: string): boolean;
 /**
  * What ADK's runLlmAgentAsNode puts in a node agent's invocation context

package/dist/lib/runtime/native/request.js

@@ -13,8 +13,12 @@
  *
  * THE REQUEST, in the order ADK built it:
  *   1. The agent's generateContentConfig, and its output schema when it has
- *      no tools (or the model takes a schema beside tools: Gemini 2 and
- *      later on Vertex AI).
+ *      no tools, or when every model the step may call (its own and its
+ *      fallback_model) takes a schema beside tools in one request: Claude
+ *      from Opus 4.8, Sonnet 5 and Haiku 5.5 on, OpenAI, Gemini 2 and later
+ *      on Vertex AI (outputSchemaBesideTools, lib/models/capabilities.ts,
+ *      ADR 0109). That is how an orchestrator that delegates answers in a
+ *      schema without a set_model_response call.
  *   2. The system prompt, each piece joined to the last by a blank line:
  *      - the identity lines ("You are an agent. Your internal name is …"),
  *        unless the agent may transfer to no one (an output schema rules
@@ -66,6 +70,7 @@
  * and defineTool, as registerTool refuses one (ADR 0107).
  */
 import { contentsToMessages, reasoningOf, samplingOf, systemText, toolChoiceOf } from '../../models/genaiMapping.js';
+import { outputSchemaBesideTools } from '../../models/capabilities.js';
 import { providerForModel } from '../../models/providerMap.js';
 import { contractToolDeclaration, nativeToolOf, toContractJsonSchema } from '../../models/schemaNormalize.js';
 import { createToolContext, instructionToolOf, isTool, toolOf } from '../../tools/tool.js';
@@ -131,10 +136,26 @@ function vertexAi() {
         return envFlag('GOOGLE_GENAI_USE_ENTERPRISE');
     return envFlag('GOOGLE_GENAI_USE_VERTEXAI');
 }
-/** Whether the model takes an output schema beside tools in one request (ADK: Vertex AI, Gemini 2 and later). */
+/**
+ * ADK's rule for whether the model takes an output schema beside tools in one
+ * request (Vertex AI, Gemini 2 and later). `mode: task` keeps it as it is,
+ * for the instruction line ADK's processor writes there.
+ */
 export function outputSchemaWithTools(model) {
     return vertexAi() && isGemini2OrAbove(model);
 }
+/**
+ * Whether the agent's output schema travels beside its tools as the
+ * provider's own structured-output field (ADR 0109): on every model the step
+ * may call, its own and its fallback_model, since a fallback answers the same
+ * request. ADK's Gemini rule still holds; the capability matrix's
+ * `structured_output_with_tools` adds Claude's current generations and
+ * OpenAI. Anywhere else the schema is the set_model_response tool.
+ */
+function schemaBesideTools(agent) {
+    const models = agent.fallbackModel ? [agent.model, agent.fallbackModel] : [agent.model];
+    return models.every((m) => outputSchemaWithTools(m) || outputSchemaBesideTools(m));
+}
 // ── Session state in an instruction (ADK's injectSessionState) ───────────────
 const STATE_PREFIXES = ['app:', 'user:', 'temp:'];
 const ARTIFACT_PREFIX = 'artifact.';
@@ -437,7 +458,10 @@ export async function buildModelRequest(agent, ctx) {
         throw new Error('Response schema must be set via LlmAgent.output_schema.');
     const listed = agent.tools ?? [];
     const taskMode = agent.mode === 'task';
-    const schemaWithTools = !!agent.outputSchema && listed.length > 0 && !outputSchemaWithTools(model);
+    // An output schema beside tools: set_model_response unless the step's models take both in one request
+    // (ADR 0109). Task mode keeps ADK's rule: finish_task carries the schema there.
+    const besideTools = !!agent.outputSchema && listed.length > 0;
+    const schemaWithTools = besideTools && !(taskMode ? outputSchemaWithTools(model) : schemaBesideTools(agent));
     // 1. Basic: the config, and the output schema where the model takes it (never in task mode: finish_task carries it).
     if (agent.outputSchema && !schemaWithTools && !taskMode) {
         cfg.responseSchema = agent.outputSchema;

package/dist/lib/runtime/native/telemetry.js

@@ -40,10 +40,11 @@ import { SpanStatusCode, context, trace } from '@opentelemetry/api';
 import { resolveAdapter } from '../../models/registry.js';
 import { RUNTIME_SPAN_SCOPE } from '../../observability/lineage.js';
 import { payloadPolicyFromEnv } from '../../observability/supabaseSpanExporter.js';
-import { initializeTracing } from '../../observability/tracer.js';
+import { startEngineSpan } from '../../observability/tracer.js';
 /** The most a payload attribute holds, as for a failed call's (lib/observability/tracer.ts). */
 const PAYLOAD_MAX_CHARS = 200_000;
-const runtimeTracer = () => trace.getTracer(RUNTIME_SPAN_SCOPE);
+/** A loop span in scope melchizedek.runtime; a non-recording one in a turn that opted out of tracing. */
+const startRuntimeSpan = (name, options) => startEngineSpan(RUNTIME_SPAN_SCOPE, name, options);
 /** JSON that never throws and never exceeds the cap. */
 function payloadJson(value) {
     let json;
@@ -85,8 +86,7 @@ function failed(span, error) {
 }
 /** The agent's run as an `agent.invoke <name>` span, opened when the run starts. */
 export async function* traceAgentInvocation(agent, ctx, run) {
-    initializeTracing();
-    const span = runtimeTracer().startSpan(`agent.invoke ${agent.name}`, {
+    const span = startRuntimeSpan(`agent.invoke ${agent.name}`, {
         attributes: {
             'gen_ai.operation.name': 'invoke_agent',
             'gen_ai.agent.name': agent.name,
@@ -116,8 +116,7 @@ export async function* traceAgentInvocation(agent, ctx, run) {
  * provider that answered (the fallback's, when a fallback answered).
  */
 export async function* traceModelCall(agent, ctx, step) {
-    initializeTracing();
-    const span = runtimeTracer().startSpan('model.call', {
+    const span = startRuntimeSpan('model.call', {
         attributes: {
             'gen_ai.operation.name': 'chat',
             'gen_ai.agent.name': agent.name,
@@ -173,7 +172,7 @@ function recordModelCall(span, result, provider) {
         span.setAttribute('llm.error_code', String(response.error.code));
         return;
     }
-    if (payloadPolicyFromEnv().mode === 'off')
+    if (!span.isRecording() || payloadPolicyFromEnv().mode === 'off')
         return;
     const { signal: _signal, ...request } = result.request;
     span.setAttribute('llm.payload.request', payloadJson(request));
@@ -181,10 +180,9 @@ function recordModelCall(span, result, provider) {
 }
 /** One tool call as a `tool.execute <name>` span, under the agent's. */
 export async function traceToolCall(call, tool, run) {
-    initializeTracing();
     const name = call.name || '<unnamed>';
     const description = tool && typeof tool === 'object' ? tool.description : undefined;
-    const span = runtimeTracer().startSpan(`tool.execute ${name}`, {
+    const span = startRuntimeSpan(`tool.execute ${name}`, {
         attributes: {
             'gen_ai.operation.name': 'execute_tool',
             'gen_ai.tool.name': name,
@@ -221,8 +219,7 @@ export async function traceToolCall(call, tool, run) {
 // attributes each model call to the node's agent, as on ADK.
 /** The walk as a `workflow.invoke <name>` span; every node span opens under it. */
 export async function traceWorkflowInvocation(workflow, ctx, run) {
-    initializeTracing();
-    const span = runtimeTracer().startSpan(`workflow.invoke ${workflow.name}`, {
+    const span = startRuntimeSpan(`workflow.invoke ${workflow.name}`, {
         attributes: {
             'gen_ai.operation.name': 'invoke_workflow',
             'gen_ai.conversation.id': ctx.sessionId,
@@ -248,8 +245,7 @@ export async function traceWorkflowInvocation(workflow, ctx, run) {
  * attempts the run made.
  */
 export async function traceNodeExecution(node, run) {
-    initializeTracing();
-    const span = runtimeTracer().startSpan(`node.execute ${node.name}`, {
+    const span = startRuntimeSpan(`node.execute ${node.name}`, {
         attributes: {
             'gen_ai.operation.name': 'execute_node',
             'adk.node.path': node.path,
@@ -274,9 +270,8 @@ export async function traceNodeExecution(node, run) {
 }
 /** A tool node's call as a `tool.execute <name>` span, under its node's (ToolNodeContext.traceCall). */
 export async function traceToolNodeCall(call, tool, run) {
-    initializeTracing();
     const description = tool && typeof tool === 'object' ? tool.description : undefined;
-    const span = runtimeTracer().startSpan(`tool.execute ${call.name}`, {
+    const span = startRuntimeSpan(`tool.execute ${call.name}`, {
         attributes: {
             'gen_ai.operation.name': 'execute_tool',
             'gen_ai.tool.name': call.name,

package/dist/lib/runtime/questions.d.ts

@@ -17,10 +17,13 @@
  * (lib/workflow.ts) and an approval (ADR 0028); a client handles all three
  * by showing `result.input` (or the approval) and sending the next message.
  *
- * WHERE: only on an agent the turn runs directly (the orchestrator, or a
- * plan-dispatch route), as with approval gates: inside a delegated
- * subagent the pause cannot reach the person. Not inside a workflow node
- * yet. The schema refuses both.
+ * WHERE: on any agent of a delegate or dispatch syndicate, as with approval
+ * gates. Inside a delegated subagent the question waits in the child's
+ * session, below the call its caller left open, and reaches the person
+ * with the agent path (`result.input.path`, ADR 0110); the next message is
+ * stored as the answer and carried down to the child
+ * (lib/runtime/native/interrupts.ts). Not inside a workflow node yet; the
+ * schema refuses it there.
  *
  * RESUME: the answer is an ordinary function response, so the loop resumes
  * a question ADK opened before 1.0.0 as one it opened itself (ADR 0079); no

package/dist/lib/runtime/sessions.d.ts

@@ -37,7 +37,7 @@
 import type { TurnEvent } from './events.ts';
 /** A conversation's address. Stores key it as `<appName>:<userId>:<sessionId>`. */
 export interface SessionKey {
-    /** The syndicate (or, for a DELEGATE subagent's own row, the subagent's name). */
+    /** The syndicate (or, for a DELEGATE subagent's own row, its agent path: lib/runtime/native/delegate.ts childAppName). */
     appName: string;
     userId: string;
     sessionId: string;

package/dist/lib/runtime/syndicateTurn.d.ts

@@ -144,7 +144,13 @@ export interface SyndicateTurnOptions {
     maxLlmCalls?: number;
     /** Ask adapters for token-by-token partial events (the REPL's live view). */
     streaming?: boolean;
-    /** Root-span metadata; `false` disables tracing for the turn. */
+    /**
+     * Root-span metadata. `false` disables tracing for the turn: it records no
+     * span, so no row reaches the ledger (adk_telemetry, adk_turns,
+     * adk_payloads), the console exporter, the in-process listeners or an OTLP
+     * endpoint, and the turn does not start the tracer. The step budget and
+     * the usage in the result are unaffected. Default: traced.
+     */
     trace?: TraceOptions | false;
     events?: TurnEvents;
     /**

package/dist/lib/runtime/syndicateTurn.js

@@ -63,10 +63,14 @@ import { isDispatchSyndicate, matchRouteOverride, resolveRoute } from '../dispat
 import { collectGrounding, describeGrounding, newGroundingState, webSourcesLine } from '../grounding.js';
 import { resolveGuards } from '../guards/index.js';
 import { collectGuards, nestedLoader } from '../loadSyndicate.js';
+import { context } from '@opentelemetry/api';
+import core from '@opentelemetry/core';
+const { suppressTracing } = core;
 import { traceAgentRun } from '../observability/tracer.js';
 import { ProjectedSessionService, renderTranscriptDigest } from '../session/transcript.js';
 import { approvalDecisionIn, describeApproval, interruptedTurnStart, pendingApproval } from './approvals.js';
 import { pendingQuestion, questionAnswerPart, questionFrom, turnStartOfCall } from './questions.js';
+import { delegatedPauses } from './native/interrupts.js';
 export { ASK_USER, pendingQuestion, questionAnswerPart } from './questions.js';
 export { approvalResponsePart, describeApproval, pendingApproval } from './approvals.js';
 import { RemoteA2AAgent, remoteContextId, remoteToolOutput } from '../a2a/remoteAgent.js';
@@ -274,9 +278,15 @@ export async function runSyndicateTurn(opts) {
         maxLlmCalls: opts.maxLlmCalls ?? config.max_steps ?? DEFAULT_MAX_STEPS,
         deadlineMs: opts.deadlineMs,
         signal: opts.signal,
+        // `trace: false`: no span from anything the turn runs, to any sink.
+        untraced: opts.trace === false,
     });
     try {
-        return await runWithTurnControl(control, () => runTurnInner(opts, control, runtime));
+        const run = () => runWithTurnControl(control, () => runTurnInner(opts, control, runtime));
+        // A span a library opens through OpenTelemetry's own API (not the
+        // engine's, which read control.untraced) is suppressed too, while a
+        // registered tracer is there to read the suppression.
+        return await (control.untraced ? context.with(suppressTracing(context.active()), run) : run());
     }
     finally {
         control.dispose();
@@ -360,16 +370,25 @@ async function runTurnInner(opts, control, _runtime) {
     // A message answering an approval resumes the agent that asked; the answer
     // must name the request still open in this conversation.
     const decision = approvalDecisionIn(parts);
+    // Pauses inside delegated subagents (ADR 0110): what waits below a call an agent of this conversation left open.
+    const delegationKey = { sessions: sessionService, userId, sessionId, appName };
+    /** The first pause waiting below an open delegated call in this conversation, `author`'s calls only when given. */
+    const pauseBelow = async (events, author) => isWorkflowSyndicate(config) ? undefined : (await delegatedPauses(delegationKey, events, author))[0];
+    let resumingBelow;
     let resuming;
     if (decision) {
         resuming = pendingApproval(existing?.events ?? []);
+        if (!resuming) {
+            resumingBelow = await pauseBelow(existing?.events ?? []);
+            resuming = resumingBelow?.approval;
+        }
         if (!resuming || resuming.id !== decision.id) {
             result.status = 'failed';
             result.error = { code: 'NO_PENDING_APPROVAL', message: `No approval ${decision.id} is waiting in this conversation.` };
             return finish();
         }
         // The log names the call, not its arguments: they are user content.
-        ev.log?.(`✓ Approval ${decision.approved ? 'granted' : 'refused'}: ${resuming.agent} → ${resuming.tool}`);
+        ev.log?.(`✓ Approval ${decision.approved ? 'granted' : 'refused'}: ${(resuming.path ?? [resuming.agent]).join(' → ')} → ${resuming.tool}`);
     }
     // ── Consent (lib/runtime/credentials.ts, ADR 0085) ────────────────────────
     // While a call waits for an OAuth grant, the next message resumes it once
@@ -411,24 +430,30 @@ async function runTurnInner(opts, control, _runtime) {
     // answer: it becomes that call's response, and the agent that asked
     // resumes its own tool loop (the loop reads the response from its history;
     // ADR 0079). A workflow's pauses are its walk's own business.
+    // A question asked inside a delegated subagent (ADR 0110) is answered the same way: the answer is stored here, and the
+    // open call that leads to the asker carries it down; `answering` names that call and the agent that made it.
     let answering;
     if (!decision && !granting && !isWorkflowSyndicate(config)) {
-        const question = pendingQuestion(existing?.events ?? []);
         const plainText = parts.length > 0 && parts.every((p) => typeof p.text === 'string');
-        if (question && plainText) {
-            answering = { agent: question.node, id: question.id };
+        const own = plainText ? pendingQuestion(existing?.events ?? []) : undefined;
+        const below = plainText && !own ? await pauseBelow(existing?.events ?? []) : undefined;
+        const question = own ?? below?.question;
+        if (question) {
+            answering = below ? { agent: below.path[0], id: below.callIds[0] } : { agent: question.node, id: question.id };
             parts = [questionAnswerPart(question.id, messageText)];
-            ev.log?.(`✓ Answer to ${question.node}'s question`);
+            ev.log?.(`✓ Answer to ${(question.path ?? [question.node]).join(' → ')}'s question`);
         }
     }
     /** The agent a dispatch turn must resume, and the call its interrupted turn holds. */
-    const resumeTarget = resuming
-        ? { agent: resuming.agent, id: resuming.id, why: 'resuming an approval' }
-        : granting
-            ? { agent: granting.agent, id: granting.id, why: 'resuming after an authorization' }
-            : answering
-                ? { ...answering, why: 'answering its question' }
-                : undefined;
+    const resumeTarget = resumingBelow
+        ? { agent: resumingBelow.path[0], id: resumingBelow.callIds[0], why: 'resuming an approval' }
+        : resuming
+            ? { agent: resuming.agent, id: resuming.id, why: 'resuming an approval' }
+            : granting
+                ? { agent: granting.agent, id: granting.id, why: 'resuming after an authorization' }
+                : answering
+                    ? { ...answering, why: 'answering its question' }
+                    : undefined;
     /** After the answering run: is a call now waiting for a grant? */
     const awaitingConsent = async (agentName) => {
         if (!opts.toolCredentials?.consent)
@@ -454,11 +479,26 @@ async function runTurnInner(opts, control, _runtime) {
         ev.log?.(`⏸ Input needed: ${describeInput(input)}`);
         return finish();
     };
+    /** After the answering run: does a pause wait inside a delegated call `agentName` left open (ADR 0110)? */
+    const pausedBelow = async (agentName) => {
+        const after = await sessionService.get({ appName, userId, sessionId });
+        const below = await pauseBelow(after?.events ?? [], agentName);
+        if (below?.approval)
+            return pause(below.approval);
+        if (below?.question) {
+            result.status = 'input-required';
+            result.input = below.question;
+            result.text = below.question.message;
+            ev.log?.(`⏸ Input needed: ${describeInput(below.question)} (${below.path.join(' → ')})`);
+            return finish();
+        }
+        return undefined;
+    };
     const pause = (pending) => {
         result.status = 'input-required';
         result.approval = pending;
         result.text = `Approval needed: ${describeApproval(pending)}.`;
-        ev.log?.(`⏸ Approval needed: ${pending.agent} → ${pending.tool}`);
+        ev.log?.(`⏸ Approval needed: ${(pending.path ?? [pending.agent]).join(' → ')} → ${pending.tool}`);
         return finish();
     };
     /** Run ONE agent against ONE session, under the turn's controls. */
@@ -690,13 +730,15 @@ async function runTurnInner(opts, control, _runtime) {
                     userParts: parts,
                     // Resuming an approval or answering a question: the interrupted turn
                     // is replayed raw, so the loop finds the call the message answers.
-                    sessions: new ProjectedSessionService(sessionService, routeCfg.name, resuming
-                        ? { rawFrom: (events) => interruptedTurnStart(events, resuming.id) }
-                        : answering
-                            ? { rawFrom: (events) => turnStartOfCall(events, answering.id) }
-                            : granting
-                                ? { rawFrom: (events) => turnStartOfCall(events, granting.id) }
-                                : {}),
+                    sessions: new ProjectedSessionService(sessionService, routeCfg.name, resumingBelow
+                        ? { rawFrom: (events) => turnStartOfCall(events, resumingBelow.callIds[0]) }
+                        : resuming
+                            ? { rawFrom: (events) => interruptedTurnStart(events, resuming.id) }
+                            : answering
+                                ? { rawFrom: (events) => turnStartOfCall(events, answering.id) }
+                                : granting
+                                    ? { rawFrom: (events) => turnStartOfCall(events, granting.id) }
+                                    : {}),
                     stage: 'dispatch',
                     route: resolution,
                     publishToolStatus: true,
@@ -709,11 +751,16 @@ async function runTurnInner(opts, control, _runtime) {
             result.error = answer.error;
             return finish();
         }
-        if (!routeCfg.a2a_agent_url && agentGates(routeCfg)) {
+        if (!routeCfg.a2a_agent_url && (agentGates(routeCfg) || routeCfg.yaml_reference)) {
             const pending = await awaitingApproval(routeCfg.name);
             if (pending)
                 return pause(pending);
         }
+        if (!routeCfg.a2a_agent_url) {
+            const below = await pausedBelow(routeCfg.name);
+            if (below)
+                return below;
+        }
         if (!routeCfg.a2a_agent_url) {
             const consent = await awaitingConsent(routeCfg.name);
             if (consent)
@@ -835,6 +882,11 @@ async function runTurnInner(opts, control, _runtime) {
         const consent = await awaitingConsent(config.orchestrator.name);
         if (consent)
             return consentPause(consent);
+        if (config.subagents?.length) {
+            const below = await pausedBelow(config.orchestrator.name);
+            if (below)
+                return below;
+        }
         const askedOrchestrator = asked(answer);
         if (askedOrchestrator)
             return askedOrchestrator;