@clanker-code/pi-subagents 0.10.7 → 0.11.0

package/dist/ui/agent-tool-rendering.js

@@ -23,7 +23,7 @@ export function snipMiddleLines(text, edgeLines = 20) {
     const omitted = lines.length - maxLines;
     return [
         ...lines.slice(0, edgeLines),
-        `... ${omitted} lines omitted; expand for full output ...`,
+        `─────── ⋐ ${omitted} lines hidden from preview ⋑ ───────`,
         ...lines.slice(-edgeLines),
     ];
 }

package/dist/ui/agent-widget-tree.js

@@ -1,5 +1,6 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { getConfig } from "../agent-types.js";
+import { getSessionTokens } from "../usage.js";
 function statusRank(status) {
     if (status === "running")
         return 0;
@@ -55,6 +56,14 @@ function formatElapsed(startedAt, now) {
     const rest = seconds % 60;
     return rest > 0 ? `${minutes}m ${rest}s` : `${minutes}m`;
 }
+/** Compact token count for widget rows: "12.3k tok", "1.2M tok". */
+function formatCompactTokens(count) {
+    if (count >= 1_000_000)
+        return `${(count / 1_000_000).toFixed(1)}M tok`;
+    if (count >= 1_000)
+        return `${(count / 1_000).toFixed(1)}k tok`;
+    return `${count} tok`;
+}
 function statusIcon(snapshot, frame, theme) {
     if (snapshot.status === "running")
         return theme.fg("accent", frame);
@@ -62,6 +71,8 @@ function statusIcon(snapshot, frame, theme) {
         return theme.fg("muted", "◦");
     if (snapshot.status === "completed")
         return theme.fg("success", "✓");
+    if (snapshot.status === "steered")
+        return theme.fg("warning", "✓");
     if (snapshot.status === "stopped")
         return theme.fg("dim", "■");
     return theme.fg("error", "✗");
@@ -77,13 +88,19 @@ function collectRows(nodes, options, mode, prefix = "") {
         const childPrefix = prefix + (isLast ? "   " : "│  ");
         const s = node.snapshot;
         const name = displayName(s.type);
-        const elapsed = formatElapsed(s.startedAt, options.now ?? Date.now());
+        const elapsedUntil = s.status === "running" || s.status === "queued" ? (options.now ?? Date.now()) : (s.completedAt ?? options.now ?? Date.now());
+        const elapsed = formatElapsed(s.startedAt, elapsedUntil);
         const stats = [];
         if (s.activity?.turnCount)
             stats.push(`↻${s.activity.turnCount}`);
         if (s.toolUses > 0)
             stats.push(`${s.toolUses} tool${s.toolUses === 1 ? "" : "s"}`);
         stats.push(elapsed);
+        if (s.activity?.session) {
+            const tokens = getSessionTokens(s.activity.session);
+            if (tokens > 0)
+                stats.push(formatCompactTokens(tokens));
+        }
         const orphan = node.orphaned ? " ⚠ orphan" : "";
         const error = s.error ? ` error: ${s.error}` : "";
         rows.push(`${prefix}${connector} ${statusIcon(s, options.frame, options.theme)} ${options.theme.bold(name)}  ${options.theme.fg("muted", s.description)} ${options.theme.fg("dim", `· ${stats.join(" · ")}${orphan}${error}`)}`);
@@ -126,5 +143,5 @@ export function renderAgentTree(records, options) {
         ? options.theme.fg("dim", ` ${active} running · ${queued} queued · depth ${maxDepth}/4`)
         : "";
     const heading = `${active > 0 ? options.theme.fg("accent", "●") : options.theme.fg("dim", "○")} ${options.theme.fg(active > 0 ? "accent" : "dim", "Agents")}${suffix}`;
-    return applyOverflow([heading, ...rows], options.maxLines, options.width);
+    return applyOverflow([heading, ...rows], options.maxLines, options.width, mode === "rich" ? "lines" : "agents");
 }

package/dist/ui/agent-widget.d.ts

@@ -113,8 +113,14 @@ export declare class AgentWidget {
     private widgetInterval;
     /** Tracks how many turns each finished agent has survived. Key: agent ID, Value: turns since finished. */
     private finishedTurnAge;
+    /** Tracks wall-clock finish time so long-running turns cannot keep completed rows forever. */
+    private finishedAt;
     /** How many extra turns errors/aborted agents linger (completed agents clear after 1 turn). */
     private static readonly ERROR_LINGER_TURNS;
+    /** Max wall-clock linger for successful completions when no new parent turn starts. */
+    private static readonly COMPLETED_LINGER_MS;
+    /** Max wall-clock linger for non-success outcomes when no new parent turn starts. */
+    private static readonly ERROR_LINGER_MS;
     /** Whether the widget callback is currently registered with the TUI. */
     private widgetRegistered;
     /** Cached TUI reference from widget factory callback, used for requestRender(). */
@@ -142,7 +148,7 @@ export declare class AgentWidget {
     /** Check if a finished agent should still be shown in the widget. */
     private shouldShowFinished;
     /** Record an agent as finished (call when agent completes). */
-    markFinished(agentId: string): void;
+    markFinished(agentId: string, completedAt?: number): void;
     private recordToSnapshot;
     private visibleSnapshots;
     /**

package/dist/ui/agent-widget.js

@@ -14,7 +14,7 @@ const DEFAULT_STATUS_TEXT_WIDTH = 20;
 /** Braille spinner frames for animated running indicator. */
 export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 /** Statuses that indicate an error/non-success outcome (used for linger behavior and icon rendering). */
-export const ERROR_STATUSES = new Set(["error", "aborted", "steered", "stopped"]);
+export const ERROR_STATUSES = new Set(["error", "aborted", "stopped"]);
 /** Tool name → human-readable action for activity descriptions. */
 const TOOL_DISPLAY = {
     read: "reading",
@@ -193,8 +193,14 @@ export class AgentWidget {
     widgetInterval;
     /** Tracks how many turns each finished agent has survived. Key: agent ID, Value: turns since finished. */
     finishedTurnAge = new Map();
+    /** Tracks wall-clock finish time so long-running turns cannot keep completed rows forever. */
+    finishedAt = new Map();
     /** How many extra turns errors/aborted agents linger (completed agents clear after 1 turn). */
     static ERROR_LINGER_TURNS = 2;
+    /** Max wall-clock linger for successful completions when no new parent turn starts. */
+    static COMPLETED_LINGER_MS = 30_000;
+    /** Max wall-clock linger for non-success outcomes when no new parent turn starts. */
+    static ERROR_LINGER_MS = 120_000;
     /** Whether the widget callback is currently registered with the TUI. */
     widgetRegistered = false;
     /** Cached TUI reference from widget factory callback, used for requestRender(). */
@@ -215,17 +221,25 @@ export class AgentWidget {
     }
     upsertSnapshot(snapshot) {
         this.descendantSnapshots.set(snapshot.id, snapshot);
-        if (snapshot.status !== "running" && snapshot.status !== "queued") {
-            this.markFinished(snapshot.id);
+        if (snapshot.status === "running" || snapshot.status === "queued") {
+            this.finishedTurnAge.delete(snapshot.id);
+            this.finishedAt.delete(snapshot.id);
+        }
+        else {
+            this.markFinished(snapshot.id, snapshot.completedAt);
         }
         this.update();
     }
     removeSnapshot(id) {
         this.descendantSnapshots.delete(id);
+        this.finishedTurnAge.delete(id);
+        this.finishedAt.delete(id);
         this.update();
     }
     clearSnapshots() {
         this.descendantSnapshots.clear();
+        this.finishedTurnAge.clear();
+        this.finishedAt.clear();
         this.update();
     }
     /** Set the UI context (grabbed from first tool execution). */
@@ -258,16 +272,25 @@ export class AgentWidget {
         }
     }
     /** Check if a finished agent should still be shown in the widget. */
-    shouldShowFinished(agentId, status) {
+    shouldShowFinished(agentId, status, completedAt) {
         const age = this.finishedTurnAge.get(agentId) ?? 0;
         const maxAge = ERROR_STATUSES.has(status) ? AgentWidget.ERROR_LINGER_TURNS : 1;
-        return age < maxAge;
+        if (age >= maxAge)
+            return false;
+        const finishedAt = this.finishedAt.get(agentId) ?? completedAt;
+        if (finishedAt == null)
+            return true;
+        const maxMs = ERROR_STATUSES.has(status) ? AgentWidget.ERROR_LINGER_MS : AgentWidget.COMPLETED_LINGER_MS;
+        return Date.now() - finishedAt < maxMs;
     }
     /** Record an agent as finished (call when agent completes). */
-    markFinished(agentId) {
+    markFinished(agentId, completedAt = Date.now()) {
         if (!this.finishedTurnAge.has(agentId)) {
             this.finishedTurnAge.set(agentId, 0);
         }
+        if (!this.finishedAt.has(agentId)) {
+            this.finishedAt.set(agentId, completedAt);
+        }
     }
     recordToSnapshot(a) {
         const activity = this.agentActivity.get(a.id);
@@ -290,13 +313,25 @@ export class AgentWidget {
         const merged = new Map(this.descendantSnapshots);
         const allAgents = this.manager.listAgents();
         for (const a of allAgents) {
-            if (a.status === "running" || a.status === "queued" || (a.completedAt && this.shouldShowFinished(a.id, a.status))) {
+            if (a.status === "running" || a.status === "queued") {
+                this.finishedTurnAge.delete(a.id);
+                this.finishedAt.delete(a.id);
+                merged.set(a.id, this.recordToSnapshot(a));
+            }
+            else if (a.completedAt && this.shouldShowFinished(a.id, a.status, a.completedAt)) {
                 merged.set(a.id, this.recordToSnapshot(a));
             }
         }
+        const liveRecordIds = new Set(allAgents.map(a => a.id));
         for (const [id, snapshot] of merged) {
-            if (snapshot.status !== "running" && snapshot.status !== "queued" && snapshot.completedAt && !this.shouldShowFinished(id, snapshot.status)) {
+            if (snapshot.status !== "running" && snapshot.status !== "queued" && !this.shouldShowFinished(id, snapshot.status, snapshot.completedAt)) {
                 merged.delete(id);
+                if (this.descendantSnapshots.has(id))
+                    this.descendantSnapshots.delete(id);
+                if (!liveRecordIds.has(id)) {
+                    this.finishedTurnAge.delete(id);
+                    this.finishedAt.delete(id);
+                }
             }
         }
         return [...merged.values()];
@@ -334,7 +369,7 @@ export class AgentWidget {
             else if (a.status === "queued") {
                 queuedCount++;
             }
-            else if (a.completedAt && this.shouldShowFinished(a.id, a.status)) {
+            else if (this.shouldShowFinished(a.id, a.status, a.completedAt)) {
                 hasFinished = true;
             }
         }
@@ -356,11 +391,14 @@ export class AgentWidget {
             }
             // Clean up stale entries
             for (const [id] of this.finishedTurnAge) {
-                if (!allAgents.some(a => a.id === id))
+                if (!allAgents.some(a => a.id === id) && !this.descendantSnapshots.has(id)) {
                     this.finishedTurnAge.delete(id);
+                    this.finishedAt.delete(id);
+                }
             }
             return;
         }
+        this.ensureTimer();
         // Status bar — only call setStatus when the text actually changes
         const statusWidth = this.tui?.terminal.columns ?? DEFAULT_STATUS_TEXT_WIDTH;
         const newStatusText = hasActive
@@ -403,6 +441,10 @@ export class AgentWidget {
         }
         this.widgetRegistered = false;
         this.tui = undefined;
+        this.uiCtx = undefined;
         this.lastStatusText = undefined;
+        this.descendantSnapshots.clear();
+        this.finishedTurnAge.clear();
+        this.finishedAt.clear();
     }
 }

package/dist/wait.d.ts

@@ -1,10 +1,24 @@
-export type WaitOutcome = "completed" | "timeout" | "aborted";
+export type WaitOutcome = "completed" | "timeout" | "aborted" | "pending_message";
 /** Human-readable "Xm Ys" for a duration in seconds. */
 export declare function formatWaitTimeout(seconds: number): string;
 /**
- * Race an agent completion promise against the configured wait timeout and the
- * parent abort signal. The subagent is never aborted here.
+ * Race an agent completion promise against the configured wait timeout, the
+ * parent abort signal, and an optional pending-message check. The subagent is
+ * never aborted here.
+ *
+ * @param pendingCheck - Optional promise that resolves when the parent session
+ *   has queued user messages waiting to be delivered. When it resolves, the
+ *   wait ends early so the parent turn can process the incoming message.
  */
-export declare function raceWait(promise: Promise<string>, signal: AbortSignal | undefined, timeoutSeconds: number): Promise<WaitOutcome>;
+export declare function raceWait(promise: Promise<string>, signal: AbortSignal | undefined, timeoutSeconds: number, pendingCheck?: Promise<void>): Promise<WaitOutcome>;
 /** Message returned when a wait ends with the agent still running. */
 export declare function waitTimeoutMessage(outcome: WaitOutcome, timeoutSeconds: number): string;
+/**
+ * Create a promise that resolves when the parent session has queued user
+ * messages. Polls at the given interval until `hasPendingMessages()` returns
+ * true. The caller should race this against the agent completion / timeout.
+ */
+export declare function pollPendingMessages(hasPendingMessages: () => boolean, intervalMs?: number): {
+    promise: Promise<void>;
+    cancel: () => void;
+};

package/dist/wait.js

@@ -5,10 +5,15 @@ export function formatWaitTimeout(seconds) {
     return m > 0 ? `${m}m${s > 0 ? ` ${s}s` : ""}` : `${s}s`;
 }
 /**
- * Race an agent completion promise against the configured wait timeout and the
- * parent abort signal. The subagent is never aborted here.
+ * Race an agent completion promise against the configured wait timeout, the
+ * parent abort signal, and an optional pending-message check. The subagent is
+ * never aborted here.
+ *
+ * @param pendingCheck - Optional promise that resolves when the parent session
+ *   has queued user messages waiting to be delivered. When it resolves, the
+ *   wait ends early so the parent turn can process the incoming message.
  */
-export function raceWait(promise, signal, timeoutSeconds) {
+export function raceWait(promise, signal, timeoutSeconds, pendingCheck) {
     return new Promise((resolve) => {
         let settled = false;
         const finish = (outcome) => {
@@ -23,6 +28,7 @@ export function raceWait(promise, signal, timeoutSeconds) {
         const onAbort = () => finish("aborted");
         signal?.addEventListener("abort", onAbort, { once: true });
         promise.then(() => finish("completed"));
+        pendingCheck?.then(() => finish("pending_message"));
     });
 }
 /** Message returned when a wait ends with the agent still running. */
@@ -33,5 +39,44 @@ export function waitTimeoutMessage(outcome, timeoutSeconds) {
     if (outcome === "aborted") {
         return `Agent is still running. The wait was cancelled by the user (parent turn aborted). The subagent was NOT stopped — it continues in the background.\nCall get_subagent_result with wait: true again to keep waiting, use peek to check progress, or omit wait to check status.`;
     }
+    if (outcome === "pending_message") {
+        return `Agent is still running. The wait was interrupted by an incoming user message. The subagent was NOT stopped — it continues in the background.\nThe queued message will be delivered after this tool returns.\nCall get_subagent_result with wait: true again to keep waiting, use peek to check progress, or omit wait to check status.`;
+    }
     return "Agent is still running. Use peek to check recent progress, wait: true to block until it finishes, or check back later.";
 }
+/**
+ * Create a promise that resolves when the parent session has queued user
+ * messages. Polls at the given interval until `hasPendingMessages()` returns
+ * true. The caller should race this against the agent completion / timeout.
+ */
+export function pollPendingMessages(hasPendingMessages, intervalMs = 1000) {
+    let settled = false;
+    let resolve;
+    const promise = new Promise((r) => { resolve = r; });
+    // Check immediately in case a message arrived between the tool call
+    // start and this poll setup.
+    if (hasPendingMessages()) {
+        settled = true;
+        resolve();
+        return { promise, cancel: () => { } };
+    }
+    const timer = setInterval(() => {
+        if (settled)
+            return;
+        if (hasPendingMessages()) {
+            settled = true;
+            clearInterval(timer);
+            resolve();
+        }
+    }, intervalMs);
+    return {
+        promise,
+        cancel: () => {
+            if (!settled) {
+                settled = true;
+                clearInterval(timer);
+                resolve();
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clanker-code/pi-subagents",
-  "version": "0.10.7",
+  "version": "0.11.0",
   "description": "A pi extension extension that brings smart Claude Code-style autonomous sub-agents to pi.",
   "author": "clankercode",
   "license": "MIT",

package/src/agent-manager.ts

@@ -126,6 +126,10 @@ export class AgentManager {
   private queue: { id: string; args: SpawnArgs }[] = [];
   /** Number of currently running background agents. */
   private runningBackground = 0;
+  /** Background agents by id; foreground agents must not emit background completion callbacks. */
+  private backgroundAgentIds = new Set<string>();
+  /** Background terminal callbacks already emitted; prevents abort/settle double delivery. */
+  private completedBackgroundCallbacks = new Set<string>();
 
   constructor(
     onComplete?: OnAgentComplete,
@@ -194,6 +198,7 @@ export class AgentManager {
       options.onOutputFileCreated?.(record.outputFile, id);
     }
     this.agents.set(id, record);
+    if (options.isBackground) this.backgroundAgentIds.add(id);
 
     const args: SpawnArgs = { pi, ctx, type, prompt, options };
 
@@ -208,12 +213,22 @@ export class AgentManager {
     try {
       this.startAgent(id, record, args);
     } catch (err) {
+      this.backgroundAgentIds.delete(id);
       this.agents.delete(id);
       throw err;
     }
     return id;
   }
 
+  /** Emit background completion once, optionally releasing a running concurrency slot. */
+  private completeBackground(record: AgentRecord, releaseRunningSlot: boolean, drain = true): void {
+    if (this.completedBackgroundCallbacks.has(record.id)) return;
+    this.completedBackgroundCallbacks.add(record.id);
+    if (releaseRunningSlot) this.runningBackground = Math.max(0, this.runningBackground - 1);
+    try { this.onComplete?.(record); } catch { /* ignore completion side-effect errors */ }
+    if (drain) this.drainQueue();
+  }
+
   /** Actually start an agent (called immediately or from queue drain). */
   private startAgent(id: string, record: AgentRecord, { pi, ctx, type, prompt, options }: SpawnArgs) {
     // Re-validate a caller-supplied cwd: queued spawns can start minutes after
@@ -338,9 +353,7 @@ export class AgentManager {
         }
 
         if (options.isBackground) {
-          this.runningBackground--;
-          try { this.onComplete?.(record); } catch { /* ignore completion side-effect errors */ }
-          this.drainQueue();
+          this.completeBackground(record, true);
         }
         return responseText;
       })
@@ -369,9 +382,7 @@ export class AgentManager {
         }
 
         if (options.isBackground) {
-          this.runningBackground--;
-          this.onComplete?.(record);
-          this.drainQueue();
+          this.completeBackground(record, true);
         }
         return "";
       });
@@ -393,7 +404,7 @@ export class AgentManager {
         record.status = "error";
         record.error = err instanceof Error ? err.message : String(err);
         record.completedAt = Date.now();
-        this.onComplete?.(record);
+        this.completeBackground(record, false, false);
       }
     }
   }
@@ -434,6 +445,8 @@ export class AgentManager {
     record.error = undefined;
     record.resultConsumed = false;
     record.abortController = new AbortController();
+    this.backgroundAgentIds.add(id);
+    this.completedBackgroundCallbacks.delete(id);
     this.runningBackground++;
     this.onStart?.(record);
 
@@ -463,18 +476,14 @@ export class AgentManager {
       record.result = responseText;
       record.completedAt = Date.now();
       detach();
-      this.runningBackground--;
-      try { this.onComplete?.(record); } catch { /* ignore completion side-effect errors */ }
-      this.drainQueue();
+      this.completeBackground(record, true);
       return responseText;
     }).catch((err) => {
       if (record.status !== "stopped") record.status = "error";
       record.error = err instanceof Error ? err.message : String(err);
       record.completedAt = Date.now();
       detach();
-      this.runningBackground--;
-      try { this.onComplete?.(record); } catch { /* ignore completion side-effect errors */ }
-      this.drainQueue();
+      this.completeBackground(record, true);
       return "";
     });
 
@@ -501,6 +510,7 @@ export class AgentManager {
       this.queue = this.queue.filter(q => q.id !== id);
       record.status = "stopped";
       record.completedAt = Date.now();
+      this.completeBackground(record, false);
       return true;
     }
 
@@ -508,6 +518,7 @@ export class AgentManager {
     record.abortController?.abort();
     record.status = "stopped";
     record.completedAt = Date.now();
+    if (this.backgroundAgentIds.has(id)) this.completeBackground(record, true);
     return true;
   }
 
@@ -515,9 +526,24 @@ export class AgentManager {
   private removeRecord(id: string, record: AgentRecord): void {
     record.session?.dispose?.();
     record.session = undefined;
+    this.backgroundAgentIds.delete(id);
+    this.completedBackgroundCallbacks.delete(id);
     this.agents.delete(id);
   }
 
+  /** Remove selected terminal records. Running and queued records are never removed. */
+  clearRecords(ids: string[]): string[] {
+    const removed: string[] = [];
+    for (const id of ids) {
+      const record = this.agents.get(id);
+      if (!record) continue;
+      if (record.status === "running" || record.status === "queued") continue;
+      this.removeRecord(id, record);
+      removed.push(id);
+    }
+    return removed;
+  }
+
   private cleanup() {
     const cutoff = Date.now() - 10 * 60_000;
     for (const [id, record] of this.agents) {
@@ -554,6 +580,7 @@ export class AgentManager {
       if (record) {
         record.status = "stopped";
         record.completedAt = Date.now();
+        if (this.backgroundAgentIds.has(record.id)) this.completedBackgroundCallbacks.add(record.id);
         count++;
       }
     }
@@ -564,9 +591,11 @@ export class AgentManager {
         record.abortController?.abort();
         record.status = "stopped";
         record.completedAt = Date.now();
+        if (this.backgroundAgentIds.has(record.id)) this.completedBackgroundCallbacks.add(record.id);
         count++;
       }
     }
+    this.runningBackground = 0;
     return count;
   }
 
@@ -593,6 +622,8 @@ export class AgentManager {
       record.session?.dispose();
     }
     this.agents.clear();
+    this.backgroundAgentIds.clear();
+    this.completedBackgroundCallbacks.clear();
     // Prune any orphaned git worktrees (crash recovery)
     try { pruneWorktrees(process.cwd()); } catch { /* ignore */ }
     // Also prune repos that caller-supplied cwds created worktrees in — a clean

package/src/agent-runner.ts

@@ -36,6 +36,8 @@ export const SUBAGENT_TOOL_NAMES = {
   AGENT: "Agent",
   GET_RESULT: "get_subagent_result",
   STEER: "steer_subagent",
+  LIST_SUBAGENTS: "list_subagents",
+  CLEAR_SUBAGENTS: "clear_subagents",
   LIST_MODELS: "list_models",
 } as const;
 
@@ -69,7 +71,12 @@ function getLoadingExtensionAgentId(): string | undefined {
   return value && typeof value.agentId === "string" ? value.agentId : undefined;
 }
 
-async function withLoadingExtensionDepth<T>(depth: number, agentId: string | undefined, fn: () => Promise<T>): Promise<T> {
+function getLoadingExtensionParentAgentId(): string | undefined {
+  const value = (globalThis as any)[EXTENSION_DEPTH_KEY];
+  return value && typeof value.parentAgentId === "string" ? value.parentAgentId : undefined;
+}
+
+async function withLoadingExtensionDepth<T>(depth: number, agentId: string | undefined, parentAgentId: string | undefined, fn: () => Promise<T>): Promise<T> {
   const previous = extensionDepthLoadChain;
   let release!: () => void;
   extensionDepthLoadChain = new Promise<void>((resolve) => {
@@ -80,7 +87,7 @@ async function withLoadingExtensionDepth<T>(depth: number, agentId: string | und
   try {
     const g = globalThis as any;
     const prev = g[EXTENSION_DEPTH_KEY];
-    g[EXTENSION_DEPTH_KEY] = { depth, agentId };
+    g[EXTENSION_DEPTH_KEY] = { depth, agentId, parentAgentId };
     try {
       return await fn();
     } finally {
@@ -100,6 +107,10 @@ export function getCurrentExtensionAgentId(): string | undefined {
   return getLoadingExtensionAgentId();
 }
 
+export function getCurrentExtensionParentAgentId(): string | undefined {
+  return getLoadingExtensionParentAgentId();
+}
+
 /**
  * Canonical name of an extension for `extensions: [...]` allowlist matching.
  * Lowercased — extension names match case-insensitively so `extensions: [Mcp]`
@@ -557,7 +568,7 @@ export async function runAgent(
     systemPromptOverride: () => systemPrompt,
     appendSystemPromptOverride: () => [],
   });
-  await withLoadingExtensionDepth(depth, options.agentId, () => loader.reload());
+  await withLoadingExtensionDepth(depth, options.agentId, options.parentAgentId, () => loader.reload());
 
   // Plain entries in `tools:` are expected to be built-in names (extension tools
   // go through `ext:`), so an unknown name there is unambiguously a typo. Previously