@herbertgao/pi-subagents 0.22.0-local.2 → 0.22.1-local.1

package/src/agent-runner.ts

@@ -42,7 +42,11 @@ import {
   getMaxSubagentDepth,
   type NestedAgentManager,
 } from "./nested-tools.js"
-import { buildAgentPrompt, type PromptExtras } from "./prompts.js"
+import {
+  buildAgentPrompt,
+  inheritableParentPrompt,
+  type PromptExtras,
+} from "./prompts.js"
 import { preloadSkills } from "./skill-loader.js"
 import {
   createStructuredCapture,
@@ -722,6 +726,91 @@ function finalTurnError(
   return undefined
 }
 
+/** The per-run callbacks a spawn and a resume share, plus the resolved turn limit. */
+type RunObserverOptions = Pick<
+  RunOptions,
+  | "onTurnEnd"
+  | "onTextDelta"
+  | "onToolActivity"
+  | "onAssistantUsage"
+  | "onCompaction"
+> & {
+  /** Already resolved: undefined = unlimited. */
+  maxTurns?: number
+}
+
+/**
+ * Observe one prompt of a session — a spawn's or a resume's — and enforce its
+ * turn limit: steer once at `maxTurns`, hard-abort after the grace turns.
+ * `steered` / `aborted` are live fields, read while the prompt is still in
+ * flight (the structured-output retry) and after it settles (the result).
+ * Shared by `runAgent` and `resumeAgent` so a resumed run is bounded exactly
+ * like the first one (#368).
+ */
+function observeRun(session: AgentSession, options: RunObserverOptions) {
+  let turnCount = 0
+  let currentMessageText = ""
+  const run = {
+    steered: false,
+    aborted: false,
+    unsubscribe: () => {},
+  }
+  run.unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+    if (event.type === "turn_end") {
+      turnCount++
+      options.onTurnEnd?.(turnCount)
+      if (options.maxTurns != null) {
+        if (!run.steered && turnCount >= options.maxTurns) {
+          run.steered = true
+          session.steer(
+            "You have reached your turn limit. Wrap up immediately — provide your final answer now.",
+          )
+        } else if (run.steered && turnCount >= options.maxTurns + graceTurns) {
+          run.aborted = true
+          session.abort()
+        }
+      }
+    }
+    if (event.type === "message_start") {
+      currentMessageText = ""
+    }
+    if (
+      event.type === "message_update" &&
+      event.assistantMessageEvent.type === "text_delta"
+    ) {
+      currentMessageText += event.assistantMessageEvent.delta
+      options.onTextDelta?.(
+        event.assistantMessageEvent.delta,
+        currentMessageText,
+      )
+    }
+    if (event.type === "tool_execution_start") {
+      options.onToolActivity?.({ type: "start", toolName: event.toolName })
+    }
+    if (event.type === "tool_execution_end") {
+      options.onToolActivity?.({ type: "end", toolName: event.toolName })
+    }
+    if (event.type === "message_end" && event.message.role === "assistant") {
+      const u = (event.message as any).usage
+      if (u)
+        options.onAssistantUsage?.({
+          input: u.input ?? 0,
+          output: u.output ?? 0,
+          cacheWrite: u.cacheWrite ?? 0,
+          cacheRead: u.cacheRead ?? 0,
+          cost: u.cost?.total ?? 0,
+        })
+    }
+    if (event.type === "compaction_end" && !event.aborted && event.result) {
+      options.onCompaction?.({
+        reason: event.reason,
+        tokensBefore: event.result.tokensBefore,
+      })
+    }
+  })
+  return run
+}
+
 /**
  * Wire an AbortSignal to abort a session.
  * Returns a cleanup function to remove the listener.
@@ -764,8 +853,12 @@ export async function runAgent(
 
   const env = await detectEnv(options.pi, effectiveCwd)
 
-  // Get parent system prompt for append-mode agents
-  const parentSystemPrompt = ctx.getSystemPrompt()
+  // Get parent system prompt for append-mode agents, without the sections the
+  // child session renders itself (skills, cwd, extension sections).
+  const parentSystemPrompt = inheritableParentPrompt(
+    ctx.getSystemPrompt(),
+    ctx.cwd,
+  )
 
   // Build prompt extras (memory, skill preloading)
   const extras: PromptExtras = {}
@@ -1072,8 +1165,12 @@ export async function runAgent(
     options.model ??
     resolveDefaultModel(ctx.model, ctx.modelRegistry, agentConfig?.model)
 
-  // Resolve thinking level: explicit option > agent config > undefined (inherit)
-  const thinkingLevel = options.thinkingLevel ?? agentConfig?.thinking
+  // Resolve thinking level: explicit option > agent config > parent session level.
+  // Without the parent step, an unset level falls through to pi's
+  // defaultThinkingLevel (e.g. "max") instead of matching the spawning session.
+  // Same idiom as mention-clone.ts.
+  const thinkingLevel =
+    options.thinkingLevel ?? agentConfig?.thinking ?? ctx.thinkingLevel
 
   const disallowedSet = agentConfig?.disallowedTools
     ? new Set(agentConfig.disallowedTools)
@@ -1316,65 +1413,9 @@ export async function runAgent(
 
   options.onSessionCreated?.(session)
 
-  // Track turns for graceful max_turns enforcement
-  let turnCount = 0
-  const maxTurns = resolveEffectiveMaxTurns(type, options.maxTurns)
-  let softLimitReached = false
-  let aborted = false
-
-  let currentMessageText = ""
-  const unsubTurns = session.subscribe((event: AgentSessionEvent) => {
-    if (event.type === "turn_end") {
-      turnCount++
-      options.onTurnEnd?.(turnCount)
-      if (maxTurns != null) {
-        if (!softLimitReached && turnCount >= maxTurns) {
-          softLimitReached = true
-          session.steer(
-            "You have reached your turn limit. Wrap up immediately — provide your final answer now.",
-          )
-        } else if (softLimitReached && turnCount >= maxTurns + graceTurns) {
-          aborted = true
-          session.abort()
-        }
-      }
-    }
-    if (event.type === "message_start") {
-      currentMessageText = ""
-    }
-    if (
-      event.type === "message_update" &&
-      event.assistantMessageEvent.type === "text_delta"
-    ) {
-      currentMessageText += event.assistantMessageEvent.delta
-      options.onTextDelta?.(
-        event.assistantMessageEvent.delta,
-        currentMessageText,
-      )
-    }
-    if (event.type === "tool_execution_start") {
-      options.onToolActivity?.({ type: "start", toolName: event.toolName })
-    }
-    if (event.type === "tool_execution_end") {
-      options.onToolActivity?.({ type: "end", toolName: event.toolName })
-    }
-    if (event.type === "message_end" && event.message.role === "assistant") {
-      const u = (event.message as any).usage
-      if (u)
-        options.onAssistantUsage?.({
-          input: u.input ?? 0,
-          output: u.output ?? 0,
-          cacheWrite: u.cacheWrite ?? 0,
-          cacheRead: u.cacheRead ?? 0,
-          cost: u.cost?.total ?? 0,
-        })
-    }
-    if (event.type === "compaction_end" && !event.aborted && event.result) {
-      options.onCompaction?.({
-        reason: event.reason,
-        tokensBefore: event.result.tokensBefore,
-      })
-    }
+  const run = observeRun(session, {
+    ...options,
+    maxTurns: resolveEffectiveMaxTurns(type, options.maxTurns),
   })
 
   const collector = collectResponseText(session)
@@ -1407,14 +1448,14 @@ export async function runAgent(
     if (
       structuredCapture !== undefined &&
       structuredCapture.json === undefined &&
-      !aborted &&
+      !run.aborted &&
       options.signal?.aborted !== true
     ) {
       structuredRetried = true
       await session.prompt(structuredRetryPrompt(structuredCapture))
     }
   } finally {
-    unsubTurns()
+    run.unsubscribe()
     collector.unsubscribe()
     cleanupAbort()
   }
@@ -1433,8 +1474,8 @@ export async function runAgent(
   return {
     responseText,
     session,
-    aborted,
-    steered: softLimitReached,
+    aborted: run.aborted,
+    steered: run.steered,
     failure: finalTurnError(session, startLen) ?? structuredFailure,
     ...(structuredCapture?.json !== undefined
       ? { structuredJson: structuredCapture.json }
@@ -1444,77 +1485,54 @@ export async function runAgent(
 }
 
 /**
- * Send a new prompt to an existing session (resume).
+ * Send a new prompt to an existing session (resume). A fresh run of the same
+ * agent: the turn limit is resolved as `runAgent` resolves it — an explicit
+ * `maxTurns`, else the agent type's own `max_turns`, else the project default
+ * — and counted from this prompt (#368).
  */
 export async function resumeAgent(
   session: AgentSession,
   prompt: string,
-  options: {
-    onToolActivity?: (activity: ToolActivity) => void
-    onAssistantUsage?: (usage: LifetimeUsage) => void
-    onCompaction?: (info: {
-      reason: "manual" | "threshold" | "overflow"
-      tokensBefore: number
-    }) => void
-    signal?: AbortSignal
-  } = {},
-): Promise<{ text: string; failure?: string }> {
+  options: Pick<
+    RunOptions,
+    | "maxTurns"
+    | "onTurnEnd"
+    | "onToolActivity"
+    | "onAssistantUsage"
+    | "onCompaction"
+    | "signal"
+  > & {
+    /** The agent's type, for its own `max_turns`. */
+    type: SubagentType
+  },
+): Promise<
+  { text: string; failure?: string } & Pick<RunResult, "aborted" | "steered">
+> {
   // Boundary for the history fallback: the session already holds prior turns,
   // so only assistant text produced by THIS resume prompt counts as its output
   // — a failed resume must not surface the previous turn's answer (#144).
   const startLen = session.messages.length
   const collector = collectResponseText(session)
   const cleanupAbort = forwardAbortSignal(session, options.signal)
-
-  const unsubEvents =
-    options.onToolActivity || options.onAssistantUsage || options.onCompaction
-      ? session.subscribe((event: AgentSessionEvent) => {
-          if (event.type === "tool_execution_start")
-            options.onToolActivity?.({
-              type: "start",
-              toolName: event.toolName,
-            })
-          if (event.type === "tool_execution_end")
-            options.onToolActivity?.({ type: "end", toolName: event.toolName })
-          if (
-            event.type === "message_end" &&
-            event.message.role === "assistant"
-          ) {
-            const u = (event.message as any).usage
-            if (u)
-              options.onAssistantUsage?.({
-                input: u.input ?? 0,
-                output: u.output ?? 0,
-                cacheWrite: u.cacheWrite ?? 0,
-                cacheRead: u.cacheRead ?? 0,
-                cost: u.cost?.total ?? 0,
-              })
-          }
-          if (
-            event.type === "compaction_end" &&
-            !event.aborted &&
-            event.result
-          ) {
-            options.onCompaction?.({
-              reason: event.reason,
-              tokensBefore: event.result.tokensBefore,
-            })
-          }
-        })
-      : () => {}
+  const run = observeRun(session, {
+    ...options,
+    maxTurns: resolveEffectiveMaxTurns(options.type, options.maxTurns),
+  })
 
   try {
     // Already aborted: not prompted, as in `runAgent`.
     if (options.signal?.aborted !== true) await session.prompt(prompt)
   } finally {
     collector.unsubscribe()
-    unsubEvents()
+    run.unsubscribe()
     cleanupAbort()
   }
 
   return {
     text: collector.getText().trim() || getLastAssistantText(session, startLen),
     failure: finalTurnError(session, startLen),
+    aborted: run.aborted,
+    steered: run.steered,
   }
 }
 

package/src/cross-extension-rpc.ts

@@ -1,7 +1,7 @@
 /**
  * Cross-extension RPC handlers for the subagents extension.
  *
- * Exposes ping, spawn, stop, and consume RPCs over the pi.events event bus,
+ * Exposes ping, spawn, stop, consume, and steer RPCs over the pi.events event bus,
  * using per-request scoped reply channels.
  *
  * Reply envelope follows pi-mono convention:
@@ -58,6 +58,11 @@ export interface SpawnCapable {
    * one. False when there is no such agent, or it has not settled yet.
    */
   consumeResult(id: string): boolean
+  /**
+   * Deliver a message to a running or queued agent's conversation — what
+   * `steer_subagent` does. False when the agent is unknown or has settled.
+   */
+  steer(id: string, message: string): boolean
 }
 
 export interface RpcDeps {
@@ -72,6 +77,7 @@ export interface RpcHandle {
   unsubSpawn: () => void
   unsubStop: () => void
   unsubConsume: () => void
+  unsubSteer: () => void
 }
 
 /**
@@ -100,7 +106,7 @@ function handleRpc<P extends { requestId: string }>(
 }
 
 /**
- * Register ping, spawn, stop, and consume RPC handlers on the event bus.
+ * Register ping, spawn, stop, consume, and steer RPC handlers on the event bus.
  * Returns unsub functions for cleanup.
  */
 export function registerRpcHandlers(deps: RpcDeps): RpcHandle {
@@ -184,21 +190,25 @@ export function registerRpcHandlers(deps: RpcDeps): RpcHandle {
     return { id }
   })
 
+  // Only the session's own agents are this RPC's to stop or steer. A nested
+  // child or a workflow's agent is owned by something that is *waiting on it*,
+  // and aborting or redirecting it out from under that owner turns another
+  // extension's request into a failed step here. Defence in depth rather than
+  // a live hole: no RPC hands out agent ids, so a caller has no ordinary way to
+  // name one it does not own — but the guard is cheap and the id may leak some
+  // other way. Same refuse-what-we-should-not-touch stance as `consume` below.
+  const assertOwned = (agentId: string): void => {
+    const record = manager.getRecord(agentId)
+    if (!record) throw new Error("Agent not found")
+    if (!isTopLevelAgent(record))
+      throw new Error("Agent is owned by another agent or workflow")
+  }
+
   const unsubStop = handleRpc<{ requestId: string; agentId: string }>(
     events,
     "subagents:rpc:stop",
     ({ agentId }) => {
-      const record = manager.getRecord(agentId)
-      if (!record) throw new Error("Agent not found")
-      // Only the session's own agents are this RPC's to stop. A nested child or
-      // a workflow's agent is owned by something that is *waiting on it*, and
-      // aborting it out from under that owner turns another extension's stop
-      // into a failed step here. Defence in depth rather than a live hole: no
-      // RPC hands out agent ids, so a caller has no ordinary way to name one it
-      // does not own — but the guard is cheap and the id may leak some other
-      // way. Same refuse-what-we-should-not-touch stance as `consume` below.
-      if (!isTopLevelAgent(record))
-        throw new Error("Agent is owned by another agent or workflow")
+      assertOwned(agentId)
       // Not "not found" — the lookup above already proved it exists. `abort`
       // returns false only for a record that is neither running nor queued,
       // which is an agent that has already finished.
@@ -220,5 +230,22 @@ export function registerRpcHandlers(deps: RpcDeps): RpcHandle {
     },
   )
 
-  return { unsubPing, unsubSpawn, unsubStop, unsubConsume }
+  // An extension that spawned an agent over the bus and then learns something
+  // that agent needs — a second CI failure on the head it is already fixing, a
+  // review that landed mid-run — can hand it over instead of spawning a second
+  // agent for the same work or dropping the fact. Outside the ping version
+  // handshake, like consume: additive and best-effort.
+  const unsubSteer = handleRpc<{
+    requestId: string
+    agentId: string
+    message: unknown
+  }>(events, "subagents:rpc:steer", ({ agentId, message }) => {
+    if (typeof message !== "string" || message.trim().length === 0)
+      throw new Error("Steer message must be a non-empty string")
+    assertOwned(agentId)
+    if (!manager.steer(agentId, message))
+      throw new Error("Agent is not running")
+  })
+
+  return { unsubPing, unsubSpawn, unsubStop, unsubConsume, unsubSteer }
 }

package/src/index.ts

@@ -965,12 +965,59 @@ export default function (pi: ExtensionAPI) {
         compactionCount: record.compactionCount,
       })
     },
-    (_record, usage) => {
+    (record, usage) => {
       // Every assistant message from every agent — nested included, exactly once.
       // Parked here until a tool result can carry it back to the parent session;
       // see `PendingUsagePool`. Skipped entirely when the feature is off, so no
       // pool grows in a session that will never drain it.
       if (reportUsage) pendingUsage.add(usage)
+      // The same message, live, for anyone keeping their own ledger — a footer
+      // that breaks spend down by agent type and thinking level, say. This is the
+      // one place every agent's spend passes through, which is why it is emitted
+      // here and not from the lifecycle events: those fire for top-level agents
+      // only, once, at the end, so a workflow's children and nested agents would
+      // never be counted, and a running agent would read as free until it
+      // stopped. Deliberately ungated by `reportUsage` — that decides whether the
+      // parent session's own totals include this spend, not whether it happened.
+      //
+      // `model` and `thinking` are read off the record per message, not captured
+      // at spawn: the record is authoritative only once the session exists and pi
+      // has clamped the level to the model (see `onSessionCreated`).
+      const reported = toReportedUsage(usage)
+      if (!reported) return
+      // A key whose value is unknown is omitted, never `undefined`: `model` and
+      // `thinking` until the session has reported them, `parentAgentId` and
+      // `workflowId` on a top-level agent.
+      const invocation = record.invocation
+      pi.events.emit("subagents:usage", {
+        id: record.id,
+        type: record.type,
+        description: record.description,
+        ...(invocation?.modelId !== undefined
+          ? { model: invocation.modelId }
+          : {}),
+        ...(invocation?.thinking !== undefined
+          ? { thinking: invocation.thinking }
+          : {}),
+        // Set only when the caller did not get the level it asked for (pi
+        // clamped it to the model, or an agent file outranked it), so a ledger
+        // can show `low (asked minimal)` instead of silently relabelling.
+        ...(invocation?.requestedThinking !== undefined
+          ? { requestedThinking: invocation.requestedThinking }
+          : {}),
+        depth: record.depth ?? 1,
+        ...(record.parentAgentId !== undefined
+          ? { parentAgentId: record.parentAgentId }
+          : {}),
+        ...(record.workflowId !== undefined
+          ? { workflowId: record.workflowId }
+          : {}),
+        usage: reported,
+      })
+    },
+    (record, message) => {
+      if (!isTopLevelAgent(record)) return
+      pi.events.emit("subagents:steered", { id: record.id, message })
     },
   )
 
@@ -1180,6 +1227,7 @@ export default function (pi: ExtensionAPI) {
             outbox.cancel(record.id)
             return true
           },
+          steer: (id, message) => manager.steer(id, message),
         },
       })
       // Broadcast readiness so extensions loaded alongside us can discover us.
@@ -1295,10 +1343,6 @@ export default function (pi: ExtensionAPI) {
         // this message is still relayed even if the LLM read its last answer.
         record.resultConsumed = false
         manager.steer(record.id, mention.message)
-        pi.events.emit("subagents:steered", {
-          id: record.id,
-          message: mention.message,
-        })
         ctx.ui.notify(`Sent to ${target}`, "info")
         return { action: "handled" }
       }
@@ -1308,17 +1352,15 @@ export default function (pi: ExtensionAPI) {
         // agent, so its frontmatter is what governs — `output_transcript: false`
         // must keep holding, since record.outputFile is the sole gate every
         // downstream consumer keys off and a resume must not re-open it.
-        const config = getAgentConfig(record.type)
         const resumedRecord = await startBackgroundResume(
           ctx,
           record,
           mention.message,
           {
             outputTranscript:
-              config?.outputTranscript ?? getOutputTranscriptDefault(),
-            maxTurns: normalizeMaxTurns(
-              config?.maxTurns ?? getDefaultMaxTurns(),
-            ),
+              getAgentConfig(record.type)?.outputTranscript ??
+              getOutputTranscriptDefault(),
+            maxTurns: resumeTurnLimit(record),
           },
         )
         ctx.ui.notify(
@@ -1505,6 +1547,7 @@ export default function (pi: ExtensionAPI) {
     rpcHandle?.unsubStop()
     rpcHandle?.unsubPing()
     rpcHandle?.unsubConsume()
+    rpcHandle?.unsubSteer()
     rpcHandle = undefined
     currentCtx = undefined
     // Only release the global slot if this activation claimed it — a child
@@ -1539,6 +1582,13 @@ export default function (pi: ExtensionAPI) {
     // pi awaits this handler, and the process exits right after — unawaited, those
     // handlers would never run. Internally bounded, so a hung one can't strand quit.
     await manager.dispose(pi)
+    // Every agent is stopped and every child session has shut down, so no more
+    // `subagents:usage` can arrive. A ledger flushing in its own
+    // `session_shutdown` may have run before this handler aborted the agents
+    // (handlers run in load order) and missed their last messages; this is the
+    // point after which a synchronous final flush is complete. Synchronous:
+    // `emit` does not await listeners, and pi exits once this handler returns.
+    pi.events.emit("subagents:disposed", {})
   })
 
   // Live widget: show running agents above editor.
@@ -1831,6 +1881,24 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  /**
+   * The turn budget for resuming `record`, from its OWN type — resume ignores
+   * `subagent_type`. Same precedence as a spawn, frontmatter authoritative:
+   * the agent file's `max_turns`, else the call's, else the limit the agent
+   * was spawned with, else the default (#368).
+   */
+  function resumeTurnLimit(
+    record: AgentRecord,
+    explicit?: number,
+  ): number | undefined {
+    return normalizeMaxTurns(
+      getAgentConfig(record.type)?.maxTurns ??
+        explicit ??
+        record.invocation?.maxTurns ??
+        getDefaultMaxTurns(),
+    )
+  }
+
   /**
    * Launch a detached resume of an existing agent and wire everything a
    * re-running agent needs: transcript anchoring, activity tracking, join-mode
@@ -1886,6 +1954,8 @@ export default function (pi: ExtensionAPI) {
     // run_in_background in that same turn keep going.
     const record = await manager.resume(id, prompt, undefined, {
       isBackground: true,
+      maxTurns: opts.maxTurns,
+      onTurnEnd: bgCallbacks.onTurnEnd,
       onToolActivity: bgCallbacks.onToolActivity,
       onAssistantUsage: bgCallbacks.onAssistantUsage,
       // Fires when the run actually starts — immediately, or on queue
@@ -2240,7 +2310,7 @@ Terse command-style prompts produce shallow, generic work.
       resume: Type.Optional(
         Type.String({
           description:
-            "Optional agent ID to resume from. Continues from previous context. Resumes detached like any other spawn; pass run_in_background: false to block and get the result inline. An agent can only be resumed once its current run has finished — use steer_subagent to reach one mid-run.",
+            "Optional agent ID to resume from. Continues from previous context. Resumes detached like any other spawn; pass run_in_background: false to block and get the result inline. The resumed run gets a fresh max_turns budget. An agent can only be resumed once its current run has finished — use steer_subagent to reach one mid-run.",
         }),
       ),
       isolated: Type.Optional(
@@ -2692,6 +2762,9 @@ Terse command-style prompts produce shallow, generic work.
             `Agent "${params.resume}" has no active session to resume.`,
           )
         }
+        // Not `effectiveMaxTurns`: that was resolved for `subagent_type`, which
+        // a resume ignores, so it may describe another agent.
+        const resumeMaxTurns = resumeTurnLimit(existing, params.max_turns)
 
         // Background resume: detached run that notifies on completion, mirroring
         // a background spawn. Previously run_in_background was silently ignored
@@ -2717,7 +2790,7 @@ Terse command-style prompts produce shallow, generic work.
             params.prompt,
             {
               outputTranscript,
-              maxTurns: effectiveMaxTurns,
+              maxTurns: resumeMaxTurns,
               toolCallId,
             },
           )
@@ -2747,11 +2820,29 @@ Terse command-style prompts produce shallow, generic work.
           )
         }
 
-        const record = await manager.resume(
-          params.resume,
-          params.prompt,
-          signal,
-        )
+        // Tracked like a foreground spawn, so the widget row and the result
+        // card show THIS run's `↻N≤M` and tool activity rather than the
+        // previous run's. The session predates this run, so it is seeded here.
+        const { state: resumeState, callbacks: resumeCallbacks } =
+          createActivityTracker(resumeMaxTurns)
+        resumeState.session = existing.session
+        agentActivity.set(existing.id, resumeState)
+        widget.markRunning(existing.id)
+        widget.ensureTimer()
+        fleet.ensureTimer()
+        fleet.update()
+        let record: AgentRecord | undefined
+        try {
+          record = await manager.resume(params.resume, params.prompt, signal, {
+            maxTurns: resumeMaxTurns,
+            onTurnEnd: resumeCallbacks.onTurnEnd,
+            onToolActivity: resumeCallbacks.onToolActivity,
+          })
+        } finally {
+          agentActivity.delete(existing.id)
+          widget.markFinished(existing.id)
+          fleet.onAgentFinished(existing.id)
+        }
         if (!record) {
           return textResult(`Failed to resume agent "${params.resume}".`)
         }
@@ -2760,12 +2851,12 @@ Terse command-style prompts produce shallow, generic work.
         if (record.status === "error") {
           return textResult(
             `Agent failed: ${record.error}${partialOutputSuffix(record)}`,
-            buildDetails(detailBaseFor(record), record),
+            buildDetails(detailBaseFor(record), record, resumeState),
           )
         }
         return textResult(
           record.result?.trim() || "No output.",
-          buildDetails(detailBaseFor(record), record),
+          buildDetails(detailBaseFor(record), record, resumeState),
         )
       }
 

package/src/nested-tools.ts

@@ -112,6 +112,7 @@ export interface NestedAgentManager {
     id: string,
     prompt: string,
     signal?: AbortSignal,
+    options?: { maxTurns?: number },
   ): Promise<AgentRecord | undefined>
 }
 
@@ -242,10 +243,17 @@ export function createNestedSubagentTools(
             true,
           )
         }
+        // Frontmatter authoritative, as on the spawn path; the manager falls
+        // back to the limit the child was spawned with, then the default.
         const resumed = await context.manager.resume(
           params.resume,
           params.prompt,
           signal,
+          {
+            maxTurns:
+              getAgentConfigIn(loadRegistry(), existing.type)?.maxTurns ??
+              params.max_turns,
+          },
         )
         return resumed
           ? textResult(