@herbertgao/pi-subagents 0.19.0 → 0.22.0-local.1

package/src/ui/conversation-viewer.ts

@@ -11,12 +11,19 @@ import {
 } from "@earendil-works/pi-coding-agent"
 import {
   type Component,
+  type Focusable,
   Input,
   Markdown,
   type MarkdownOptions,
   type MarkdownTheme,
   matchesKey,
+  type OverlayOptions,
+  ScrollView,
+  type ScrollViewScrollbar,
+  stripTerminalSequences,
   type TUI,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
   truncateToWidth,
   visibleWidth,
   wrapTextWithAnsi,
@@ -51,6 +58,16 @@ const CHROME_LINES_BASE = 6
 const MIN_VIEWPORT = 3
 /** Height ceiling shared by the overlay's `maxHeight` and the viewer's internal viewport cap. */
 export const VIEWPORT_HEIGHT_PCT = 70
+const SCROLLBAR_WIDTH = 1
+
+/** Follow the active renderer, not a setting that may require a restart. */
+export function getConversationOverlayOptions(
+  tui: Pick<TUI, "mode">,
+): OverlayOptions {
+  return tui.mode === "fullscreen"
+    ? { anchor: "top-left", width: "100%", maxHeight: "100%", margin: 0 }
+    : { anchor: "center", width: "90%", maxHeight: `${VIEWPORT_HEIGHT_PCT}%` }
+}
 
 /**
  * Cap on a single tool result or bash output before the viewer elides the rest.
@@ -65,6 +82,12 @@ export const VIEWPORT_HEIGHT_PCT = 70
  */
 export const RESULT_MAX_CHARS = 16_000
 
+/** The `b` affordance: whether this run can be handed to the background now, and the handoff. */
+export interface ViewerBackgroundAction {
+  available(): boolean
+  send(): void
+}
+
 /** Cycle order for the viewer's `m` key. */
 const MARKDOWN_MODES: readonly ViewerMarkdownMode[] = [
   "off",
@@ -173,9 +196,26 @@ function truncationNote(elided: number): string {
   return `... (truncated, ${humanCount(elided)} more character${elided === 1 ? "" : "s"})`
 }
 
-export class ConversationViewer implements Component {
+export class ConversationViewer implements Component, Focusable {
   private scrollOffset = 0
   private autoScroll = true
+  focused = false
+  private readonly fullscreen: boolean
+  private viewport:
+    | {
+        width: number
+        top: number
+        height: number
+        maxScroll: number
+        thumbTop: number
+        thumbHeight: number
+      }
+    | undefined
+  private scrollbarGrabOffset: number | undefined
+  private footerTargets: { start: number; end: number; key: string }[] = []
+  private latestTarget: { row: number; start: number; end: number } | undefined
+  private newMessages = 0
+  private readonly scrollView: ScrollView
   private unsubscribe: (() => void) | undefined
   private lastInnerW = 0
   private closed = false
@@ -229,16 +269,51 @@ export class ConversationViewer implements Component {
      * the same thing. Omitted → `m` still cycles, viewer-locally.
      */
     private onMarkdownMode?: (mode: ViewerMarkdownMode) => void,
+    /** Pi's fullscreen scrollbar preference, captured when the observer opens. */
+    scrollbarMode: ScrollViewScrollbar = "auto",
+    /**
+     * Hand this run to the background. `available` is read live — it turns
+     * false the instant the handoff lands or the run ends. Omitted → no `b`
+     * affordance (history views).
+     */
+    private onBackground?: ViewerBackgroundAction,
   ) {
+    this.fullscreen = tui.mode === "fullscreen"
     this.markdownTheme = resolveMarkdownTheme(theme)
     this.keys = createViewerKeys(keybindings)
-    this.unsubscribe = session.subscribe(() => {
+    this.scrollView = new ScrollView(
+      {
+        render: (width) => this.buildContentLines(width),
+        invalidate: () => {},
+      },
+      { follow: "end", scrollbar: this.fullscreen ? scrollbarMode : "hidden" },
+    )
+    this.unsubscribe = session.subscribe((event) => {
       if (this.closed) return
+      if (
+        this.fullscreen &&
+        !this.scrollView.isFollowingEnd &&
+        event.type === "message_start" &&
+        ["user", "assistant", "toolResult", "bashExecution"].includes(
+          event.message.role,
+        )
+      ) {
+        this.newMessages++
+      }
       this.tui.requestRender()
     })
   }
 
   handleInput(data: string): void {
+    if (this.closed) return
+    if (
+      this.fullscreen &&
+      (matchesKey(data, "ctrl+end") ||
+        (!this.composer && matchesKey(data, "end")))
+    ) {
+      this.jumpToLatest()
+      return
+    }
     // While composing a steer message, the input owns all keys (Enter sends,
     // Esc cancels — both wired in openComposer()). Editing keys flow through.
     if (this.composer) {
@@ -266,6 +341,16 @@ export class ConversationViewer implements Component {
       return
     }
 
+    // Hand a live foreground run to the background. Single press, unlike stop:
+    // the transition is one-way but keeps the agent working, so a stray key
+    // costs a notification rather than the run.
+    if (matchesKey(data, "b") && this.canSendToBackground()) {
+      this.stopArmed = false
+      this.onBackground?.send()
+      this.tui.requestRender()
+      return
+    }
+
     // Stop/abort the agent (only while it can still be stopped). Two-press:
     // first "x" arms, second confirms — any other key disarms.
     if (matchesKey(data, "x")) {
@@ -300,6 +385,18 @@ export class ConversationViewer implements Component {
 
     const totalLines = this.buildContentLines(this.lastInnerW).length
     const viewportHeight = this.viewportHeight()
+    if (this.fullscreen) {
+      this.scrollView.updateLayout(totalLines, viewportHeight, () => {
+        if (!this.closed) this.tui.requestRender()
+      })
+      if (this.keys.scrollUp(data)) this.scrollView.scrollBy(-1)
+      else if (this.keys.scrollDown(data)) this.scrollView.scrollBy(1)
+      else if (this.keys.pageUp(data)) this.scrollView.scrollBy(-viewportHeight)
+      else if (this.keys.pageDown(data))
+        this.scrollView.scrollBy(viewportHeight)
+      else if (matchesKey(data, "home")) this.scrollView.scrollToStart()
+      return
+    }
     const maxScroll = Math.max(0, totalLines - viewportHeight)
 
     if (this.keys.scrollUp(data)) {
@@ -326,29 +423,141 @@ export class ConversationViewer implements Component {
     }
   }
 
+  private jumpToLatest(): void {
+    this.scrollView.scrollToEnd()
+    this.newMessages = 0
+    this.stopArmed = false
+    this.tui.requestRender()
+  }
+
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult {
+    if (!this.fullscreen) return { handled: false }
+    // Every cell belongs to this observer. Even unused clicks/drags must not
+    // fall through to Pi's transcript selection, scrolling, or editor.
+    if (this.closed || !this.viewport) return { handled: true, render: false }
+    const view = this.viewport
+    const onScrollbar =
+      this.scrollView.scrollbar !== "hidden" &&
+      event.x >= view.width - SCROLLBAR_WIDTH &&
+      event.x < view.width &&
+      event.y >= view.top &&
+      event.y < view.top + view.height
+    if (event.type === "move") {
+      this.scrollView.setScrollbarActive(onScrollbar)
+      return { handled: true, render: false }
+    }
+    if (event.type === "wheel") {
+      this.stopArmed = false
+      this.scrollView.scrollBy(event.wheelDelta ?? 0)
+      return { handled: true, render: true }
+    }
+    if (event.type === "release") {
+      const wasDragging = this.scrollbarGrabOffset !== undefined
+      this.scrollbarGrabOffset = undefined
+      this.scrollView.setScrollbarActive(onScrollbar)
+      return { handled: true, render: wasDragging }
+    }
+    if (event.type === "drag" && this.scrollbarGrabOffset !== undefined) {
+      const travel = view.height - view.thumbHeight
+      const position = Math.max(
+        0,
+        Math.min(travel, event.y - view.top - this.scrollbarGrabOffset),
+      )
+      this.scrollView.scrollTo(
+        travel > 0 ? Math.round((position / travel) * view.maxScroll) : 0,
+      )
+      return { handled: true, render: true }
+    }
+    if (event.type === "press" && event.button === "left") {
+      this.scrollbarGrabOffset = undefined
+      this.scrollView.setScrollbarActive(onScrollbar)
+      if (
+        this.latestTarget &&
+        event.y === this.latestTarget.row &&
+        event.x >= this.latestTarget.start &&
+        event.x < this.latestTarget.end
+      ) {
+        this.jumpToLatest()
+        return { handled: true, render: true }
+      }
+      if (event.y === this.tui.terminal.rows - 1) {
+        const target = this.footerTargets.find(
+          (t) => event.x >= t.start && event.x < t.end,
+        )
+        if (target) {
+          this.handleInput(target.key)
+          return { handled: true, render: true }
+        }
+      }
+      this.stopArmed = false
+      if (this.composer && event.y === this.tui.terminal.rows - 2) {
+        this.composer.handleMouse({
+          ...event,
+          x: event.x - 1,
+          y: 0,
+          width: this.lastInnerW,
+          height: 1,
+        })
+        return { handled: true, render: true }
+      }
+      if (onScrollbar && view.maxScroll > 0) {
+        const y = event.y - view.top
+        if (y >= view.thumbTop && y < view.thumbTop + view.thumbHeight) {
+          this.scrollbarGrabOffset = y - view.thumbTop
+          return { handled: true, capture: true, render: true }
+        }
+        this.scrollView.scrollBy(y < view.thumbTop ? -view.height : view.height)
+        // A track click still pages, but holding it can grab the thumb too.
+        this.scrollbarGrabOffset = Math.floor(view.thumbHeight / 2)
+        return { handled: true, capture: true, render: true }
+      }
+      return { handled: true, render: true }
+    }
+    return { handled: true, render: false }
+  }
+
   render(width: number): string[] {
-    if (width < 6) return [] // too narrow for any meaningful rendering
+    this.footerTargets = []
+    this.latestTarget = undefined
+    this.viewport = undefined
+    const rows = Math.max(0, this.tui.terminal.rows)
+    if (!this.fullscreen && width < 6) return [] // too narrow for any meaningful rendering
+    if (width <= SCROLLBAR_WIDTH + 1)
+      return Array.from({ length: rows }, () => " ".repeat(Math.max(0, width)))
     const th = this.theme
-    const innerW = width - 4 // border + padding
+    const innerW = this.fullscreen
+      ? this.scrollView.getContentWidth(width - 1)
+      : width - 4
     this.lastInnerW = innerW
     const lines: string[] = []
-
+    const footerActions: { label: string; key: string }[] = []
     const pad = (s: string, len: number) => {
       const vis = visibleWidth(s)
       return s + " ".repeat(Math.max(0, len - vis))
     }
-    const row = (content: string) =>
-      th.fg("border", "│") +
-      " " +
-      truncateToWidth(pad(content, innerW), innerW, "...", true) +
-      " " +
-      th.fg("border", "│")
+    const row = (content: string, scrollbar?: string): string => {
+      if (this.fullscreen) {
+        const contentWidth = width - 1 - (scrollbar ? SCROLLBAR_WIDTH : 0)
+        return (
+          " " +
+          truncateToWidth(content, contentWidth, scrollbar ? "" : "...", true) +
+          (scrollbar ?? "")
+        )
+      }
+      return (
+        th.fg("border", "│") +
+        " " +
+        truncateToWidth(pad(content, innerW), innerW, "...", true) +
+        " " +
+        th.fg("border", "│")
+      )
+    }
     const hrTop = th.fg("border", `╭${"─".repeat(width - 2)}╮`)
     const hrBot = th.fg("border", `╰${"─".repeat(width - 2)}╯`)
     const hrMid = row(th.fg("dim", "─".repeat(innerW)))
 
     // Header
-    lines.push(hrTop)
+    if (!this.fullscreen) lines.push(hrTop)
     const modeLabel = getPromptModeLabel(this.record.type)
     const modeTag = modeLabel ? ` ${th.fg("dim", `(${modeLabel})`)}` : ""
     const statusIcon =
@@ -393,29 +602,106 @@ export class ConversationViewer implements Component {
     lines.push(hrMid)
 
     // Content area — rebuild every render (live data, no cache needed)
-    const contentLines = this.buildContentLines(innerW)
+    const contentLines = this.fullscreen
+      ? this.scrollView.render(width - 1)
+      : this.buildContentLines(innerW)
     const viewportHeight = this.viewportHeight()
     const maxScroll = Math.max(0, contentLines.length - viewportHeight)
-
-    if (this.autoScroll) {
+    if (this.fullscreen) {
+      this.scrollView.updateLayout(contentLines.length, viewportHeight, () => {
+        if (!this.closed) this.tui.requestRender()
+      })
+      if (this.scrollView.isFollowingEnd) this.newMessages = 0
+    } else if (this.autoScroll) {
       this.scrollOffset = maxScroll
     }
 
-    const visibleStart = Math.min(this.scrollOffset, maxScroll)
+    const visibleStart = this.fullscreen
+      ? this.scrollView.scrollTop
+      : Math.min(this.scrollOffset, maxScroll)
     const visible = contentLines.slice(
       visibleStart,
       visibleStart + viewportHeight,
     )
+    // Match Pi's scrollbar geometry: rounded size, at least two rows when available.
+    const thumbHeight = Math.min(
+      viewportHeight,
+      Math.max(
+        2,
+        Math.round(
+          (viewportHeight * viewportHeight) / Math.max(1, contentLines.length),
+        ),
+      ),
+    )
+    const thumbTop =
+      maxScroll > 0
+        ? Math.round(
+            (visibleStart / maxScroll) * (viewportHeight - thumbHeight),
+          )
+        : 0
+    this.viewport = {
+      width,
+      top: lines.length,
+      height: viewportHeight,
+      maxScroll,
+      thumbTop,
+      thumbHeight,
+    }
 
     for (let i = 0; i < viewportHeight; i++) {
-      lines.push(row(visible[i] ?? ""))
+      let scrollbar: string | undefined
+      if (this.scrollView.isScrollbarVisible) {
+        const onThumb = i >= thumbTop && i < thumbTop + thumbHeight
+        if (onThumb) {
+          scrollbar = th.fg(
+            "scrollbarThumb",
+            this.scrollView.isScrollbarActive ? "█" : "┃",
+          )
+        } else {
+          scrollbar = th.fg("scrollbarTrack", "│")
+        }
+      }
+      lines.push(row(visible[i] ?? "", scrollbar))
     }
 
-    // Footer
-    lines.push(hrMid)
+    // Keep the divider pinned above the footer, with the jump control centered
+    // inside it. Neither scrolling nor new messages change its position.
+    if (
+      this.fullscreen &&
+      !this.scrollView.isFollowingEnd &&
+      maxScroll > 0 &&
+      rows >= this.chromeLines()
+    ) {
+      const text =
+        this.newMessages > 0
+          ? `${this.newMessages} new message${this.newMessages === 1 ? "" : "s"}`
+          : "Jump to latest message"
+      const label = truncateToWidth(`[ ↓ ${text} · Ctrl+End ]`, innerW, "…")
+      const labelWidth = visibleWidth(label)
+      const padding = Math.floor((innerW - labelWidth) / 2)
+      this.latestTarget = {
+        row: lines.length,
+        start: padding + 1,
+        end: padding + 1 + labelWidth,
+      }
+      lines.push(
+        row(
+          th.fg("dim", "─".repeat(padding)) +
+            th.fg("accent", label) +
+            th.fg("dim", "─".repeat(innerW - padding - labelWidth)),
+        ),
+      )
+    } else {
+      lines.push(hrMid)
+    }
     if (this.composer) {
       // Composer row: the Input renders its own `> ` prompt and cursor.
+      this.composer.focused = this.focused
       lines.push(row(this.composer.render(innerW)[0] ?? ""))
+      footerActions.push(
+        { label: "Enter send", key: "\r" },
+        { label: "Esc cancel", key: "\x1b" },
+      )
       const composeHint = th.fg("dim", "Enter send · Esc cancel")
       const composeLeft = th.fg("accent", "✎ steer")
       const composeGap = Math.max(
@@ -428,21 +714,28 @@ export class ConversationViewer implements Component {
       // full key list so the less-obvious bindings stay discoverable; it leads
       // the right group so "Esc close" is the only part that truncates first.
       const sep = th.fg("dim", " · ")
-      const actions: string[] = []
-      if (this.canSteer()) actions.push(th.fg("dim", "Enter steer"))
+      if (this.canSteer())
+        footerActions.push({ label: "Enter steer", key: "\r" })
+      // Abbreviated for the same reason as the Markdown group below.
+      if (this.canSendToBackground())
+        footerActions.push({ label: "b bg", key: "b" })
       if (this.isStoppable()) {
-        actions.push(
-          this.stopArmed
-            ? th.fg("error", "x again to STOP")
-            : th.fg("dim", "x stop"),
-        )
+        footerActions.push({
+          label: this.stopArmed ? "x again to STOP" : "x stop",
+          key: "x",
+        })
       }
       // Abbreviated (`raw`/`md`/`md+`) because the idle footer is already full
       // at 80 columns with steer + stop present, and this group has no
       // degradation step below "drop the line-count readout".
-      actions.push(
-        th.fg("dim", `m ${MARKDOWN_MODE_LABELS[this.markdownMode()]}`),
+      footerActions.push({
+        label: `m ${MARKDOWN_MODE_LABELS[this.markdownMode()]}`,
+        key: "m",
+      })
+      const actions = footerActions.map((a) =>
+        th.fg(a.key === "x" && this.stopArmed ? "error" : "dim", a.label),
       )
+      footerActions.push({ label: "Esc close", key: "\x1b" })
       const footerRight = th.fg(
         "dim",
         "↑↓ scroll · PgUp/PgDn or Shift+↑↓ · Esc close",
@@ -467,9 +760,25 @@ export class ConversationViewer implements Component {
       )
       lines.push(row(footerLeft + " ".repeat(footerGap) + footerRight))
     }
-    lines.push(hrBot)
-
-    return lines
+    if (!this.fullscreen) {
+      lines.push(hrBot)
+      return lines
+    }
+    // Keep the footer on screen even in a terminal shorter than the chrome.
+    const footer = lines.pop() ?? row("")
+    const output = rows > 0 ? [...lines.slice(0, rows - 1), footer] : []
+    const footerText = stripTerminalSequences(footer)
+    for (const action of footerActions) {
+      const index = footerText.indexOf(action.label)
+      if (index < 0) continue // a clipped label is not a clickable control
+      const start = visibleWidth(footerText.slice(0, index))
+      this.footerTargets.push({
+        start,
+        end: start + visibleWidth(action.label),
+        key: action.key,
+      })
+    }
+    return output
   }
 
   /** Stoppable only when a stop handler exists and the agent is still active. */
@@ -549,6 +858,15 @@ export class ConversationViewer implements Component {
     )
   }
 
+  /**
+   * Asked of the owner rather than derived from the record: only the caller
+   * blocked on this run knows it can let go of it, and `blocking` alone also
+   * matches spawns nobody can hand off (the agent generator).
+   */
+  private canSendToBackground(): boolean {
+    return this.onBackground?.available() === true
+  }
+
   /** Open the inline steering composer and route subsequent input to it. */
   private openComposer(): void {
     const input = new Input()
@@ -573,6 +891,7 @@ export class ConversationViewer implements Component {
 
   dispose(): void {
     this.closed = true
+    this.scrollView.setScrollbar("hidden") // clears Pi's auto-hide timer
     if (this.unsubscribe) {
       this.unsubscribe()
       this.unsubscribe = undefined
@@ -582,6 +901,8 @@ export class ConversationViewer implements Component {
   // ---- Private ----
 
   private viewportHeight(): number {
+    if (this.fullscreen)
+      return Math.max(0, this.tui.terminal.rows - this.chromeLines())
     // Cap mirrors the overlay's maxHeight — otherwise the viewer would render
     // more lines than the overlay shows and clip the footer.
     const maxRows = Math.floor(
@@ -593,7 +914,8 @@ export class ConversationViewer implements Component {
   private chromeLines(): number {
     // The composer adds one row above the footer hint while it's open.
     return (
-      CHROME_LINES_BASE +
+      CHROME_LINES_BASE -
+      (this.fullscreen ? 2 : 0) +
       (this.invocationLine() ? 1 : 0) +
       (this.composer ? 1 : 0)
     )

package/src/ui/fleet-list.ts

@@ -12,10 +12,10 @@
  */
 
 import {
-  Editor,
   isKeyRelease,
   Key,
   matchesKey,
+  type ScrollViewScrollbar,
   truncateToWidth,
   visibleWidth,
 } from "@earendil-works/pi-tui"
@@ -26,7 +26,8 @@ import { getLifetimeCost, getLifetimeTotal } from "../usage.js"
 import { type AgentActivity, formatCost, type Theme } from "./agent-widget.js"
 import {
   ConversationViewer,
-  VIEWPORT_HEIGHT_PCT,
+  getConversationOverlayOptions,
+  type ViewerBackgroundAction,
 } from "./conversation-viewer.js"
 
 /** Widget key for the below-editor fleet list. */
@@ -178,6 +179,16 @@ export class FleetList {
      * point. Omitted → `m` still cycles, viewer-locally.
      */
     private onViewerMarkdown?: (mode: ViewerMarkdownMode) => void,
+    private scrollbarMode: () => ScrollViewScrollbar = () => "auto",
+    /**
+     * The viewer's `b` for this row's run, supplied by the extension: only it
+     * knows which runs have a tool call waiting to be released, and it owns the
+     * widget this list shares with. Omitted → no `b` affordance.
+     */
+    private backgroundAction?: (
+      record: AgentRecord,
+      notify: (message: string) => void,
+    ) => ViewerBackgroundAction,
   ) {}
 
   // ---- Lifecycle ----
@@ -439,17 +450,20 @@ export class FleetList {
   }
 
   /**
-   * True when pi's prompt editor owns the keyboard. pi's editor is an `Editor`
-   * subclass (CustomEditor) while every dialog/selector is not, and the loader
-   * aliases pi-tui to pi's own copy, so `instanceof` is a reliable identity
-   * check. `focusedComponent` is TUI-private (no public accessor), hence the
-   * best-effort peek: unknowable focus (no tui seen yet, nothing focused)
-   * counts as the editor so activation keeps working.
+   * True when pi's prompt editor owns the keyboard. The editor is pluggable
+   * (ui.setEditorComponent) and need not extend `Editor` (#374), so match pi-tui's
+   * `EditorComponent` contract instead: `getText` + `setText`, which pi calls on
+   * every editor and none of pi's dialogs, selectors or overlays implement.
+   * `focusedComponent` is TUI-private (no public accessor), hence the best-effort
+   * peek: unknowable focus (no tui seen yet, nothing focused) counts as the
+   * editor so activation keeps working.
    */
-  private editorHasFocus(): boolean {
+  editorHasFocus(): boolean {
     const focused = (this.tui as { focusedComponent?: unknown } | undefined)
       ?.focusedComponent
-    return focused == null || focused instanceof Editor
+    if (focused == null) return true
+    const c = focused as { getText?: unknown; setText?: unknown }
+    return typeof c.getText === "function" && typeof c.setText === "function"
   }
 
   private deactivate(): void {
@@ -488,10 +502,12 @@ export class FleetList {
     const session = record.session
     const activity = this.agentActivity.get(record.id)
     this.viewingAgentId = record.id
+    let overlayOptions = getConversationOverlayOptions({ mode: "regular" })
 
     void this.ui
       .custom<undefined>(
         (tui, theme, keybindings, done) => {
+          overlayOptions = getConversationOverlayOptions(tui)
           this.viewerClose = () => done(undefined)
           return new ConversationViewer(
             tui,
@@ -509,15 +525,15 @@ export class FleetList {
             this.showCost(),
             this.viewerMarkdown,
             this.onViewerMarkdown,
+            this.scrollbarMode(),
+            this.backgroundAction?.(record, (message) =>
+              this.ui?.notify(message, "info"),
+            ),
           )
         },
         {
           overlay: true,
-          overlayOptions: {
-            anchor: "center",
-            width: "90%",
-            maxHeight: `${VIEWPORT_HEIGHT_PCT}%`,
-          },
+          overlayOptions: () => overlayOptions,
         },
       )
       .then(
@@ -586,6 +602,8 @@ export class FleetList {
       lines.push(
         rightAlign("", theme.fg("dim", `↓ ${hiddenBelow} more`), width),
       )
+    // pi stacks below-editor widgets directly on its footer with no spacer (#351).
+    lines.push("")
 
     return lines
   }

package/src/workflow/host.ts

@@ -332,6 +332,12 @@ export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
           request.prompt,
           {
             description: request.label,
+            // Same as the Agent tool: `isolated` comes off the agent definition.
+            // Left out, a hermetic agent's script-spawned children loaded every
+            // host extension and picked up its MCP and web tools.
+            ...(config?.isolated !== undefined
+              ? { isolated: config.isolated }
+              : {}),
             // The stamp is what keeps this child out of the session's
             // `maxConcurrent` pool — see `occupiesPoolSlot`. The run already
             // bounds how many of its agents run at once, and counting them