@herbertgao/pi-subagents 0.16.1 → 0.17.0

package/src/index.ts

@@ -77,7 +77,11 @@ import {
   resolveAgentInvocationConfig,
   resolveJoinMode,
 } from "./invocation-config.js"
-import { type ModelRegistry, resolveModel } from "./model-resolver.js"
+import {
+  describeModel,
+  type ModelRegistry,
+  resolveModel,
+} from "./model-resolver.js"
 import {
   checkModelScope,
   isScopeModelsEnabled,
@@ -113,6 +117,7 @@ import {
   type JoinMode,
   type NotificationDetails,
   type SubagentType,
+  type ViewerMarkdownMode,
   type WidgetMode,
 } from "./types.js"
 import {
@@ -541,6 +546,21 @@ export default function (pi: ExtensionAPI) {
     widget.update()
     fleet.update()
   }
+  let showModel = false
+  function isShowModelEnabled(): boolean {
+    return showModel
+  }
+  function setShowModel(enabled: boolean): void {
+    showModel = enabled
+    widget.update()
+  }
+  let viewerMarkdown: ViewerMarkdownMode = "assistant"
+  function getViewerMarkdown(): ViewerMarkdownMode {
+    return viewerMarkdown
+  }
+  function setViewerMarkdown(mode: ViewerMarkdownMode): void {
+    viewerMarkdown = mode
+  }
 
   // ---- Cancellable pending notifications ----
   // Holds notifications briefly so get_subagent_result can cancel them
@@ -800,6 +820,8 @@ export default function (pi: ExtensionAPI) {
     // Also internal: it names a transcript directory, so a forged value would
     // be a path-traversal primitive.
     delete safeOptions.rootSessionId
+    // Every call through this registry is detached, never a blocking tool call.
+    delete safeOptions.blocking
     // Cross-extension callers get the same dispatch contract as the LLM (#183).
     // The RPC layer already throws for an unresolvable model rather than falling
     // back silently; a bad agent type should not be quieter. Throws become error
@@ -958,6 +980,7 @@ export default function (pi: ExtensionAPI) {
     agentActivity,
     getWidgetMode,
     isShowCostEnabled,
+    isShowModelEnabled,
   )
   function setWidgetMode(m: WidgetMode): void {
     widgetMode = m
@@ -1133,6 +1156,7 @@ export default function (pi: ExtensionAPI) {
   applyAndEmitLoaded(
     {
       setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
+      setMaxConcurrentForeground: (n) => manager.setMaxConcurrentForeground(n),
       setDefaultMaxTurns,
       setGraceTurns,
       setDefaultJoinMode,
@@ -1152,6 +1176,8 @@ export default function (pi: ExtensionAPI) {
       setFallbackSubagent: setFallbackSubagent,
       setReportUsage,
       setShowCost,
+      setShowModel,
+      setViewerMarkdown,
     },
     (event, payload) => pi.events.emit(event, payload),
   )
@@ -1637,20 +1663,27 @@ Terse command-style prompts produce shallow, generic work.
           writeInitialEntry(rec.outputFile, agentId, params.prompt, ctx.cwd)
         }
 
-        const parentModelId = ctx.model?.id
-        const effectiveModelId = model?.id
-        const modelName =
-          effectiveModelId && effectiveModelId !== parentModelId
-            ? (model?.name ?? effectiveModelId)
-                .replace(/^Claude\s+/i, "")
-                .toLowerCase()
-            : undefined
+        const { modelName, modelId } = model
+          ? describeModel(model)
+          : { modelName: undefined, modelId: undefined }
+        const askedModel = ((asked: string | undefined) => {
+          if (!asked) return undefined
+          const resolvedAsked = resolveModel(asked, ctx.modelRegistry)
+          if (typeof resolvedAsked === "string") return asked
+          return resolvedAsked.provider === model?.provider &&
+            resolvedAsked.id === model?.id
+            ? undefined
+            : asked
+        })(resolvedConfig.overridden?.model)
         const effectiveMaxTurns = normalizeMaxTurns(
           resolvedConfig.maxTurns ?? getDefaultMaxTurns(),
         )
         const agentInvocation: AgentInvocation = {
           modelName,
+          modelId,
           thinking,
+          requestedThinking: resolvedConfig.overridden?.thinking,
+          requestedModel: askedModel,
           // Explicit value only — the default fallback would just add noise.
           // Normalize so `0` (unlimited) doesn't surface as a misleading "max turns: 0".
           maxTurns: normalizeMaxTurns(resolvedConfig.maxTurns),
@@ -1672,6 +1705,23 @@ Terse command-style prompts produce shallow, generic work.
           modelName,
           tags: agentTags.length > 0 ? agentTags : undefined,
         }
+        const detailBaseFor = (
+          rec: AgentRecord | undefined,
+        ): typeof detailBase => {
+          if (!rec?.invocation) return detailBase
+          const { modelName: recModelName, tags } = buildInvocationTags(
+            rec.invocation,
+          )
+          const recModeLabel = getPromptModeLabel(rec.type)
+          const recTags = recModeLabel ? [recModeLabel, ...tags] : tags
+          return {
+            displayName: getDisplayName(rec.type),
+            description: rec.description,
+            subagentType: rec.type,
+            modelName: recModelName,
+            tags: recTags.length > 0 ? recTags : undefined,
+          }
+        }
 
         // ---- Schedule: register a job, don't spawn now ----
         if (params.schedule) {
@@ -1865,9 +1915,7 @@ Terse command-style prompts produce shallow, generic work.
                 `\nYou will be notified when this agent completes.\n` +
                 `Use get_subagent_result to retrieve full results, or steer_subagent to send it messages.`,
               {
-                ...detailBase,
-                subagentType: existing.type,
-                displayName: existing.type,
+                ...detailBaseFor(record),
                 toolUses: record.toolUses,
                 tokens: "",
                 durationMs: 0,
@@ -1890,12 +1938,12 @@ Terse command-style prompts produce shallow, generic work.
           if (record.status === "error") {
             return textResult(
               `Agent failed: ${record.error}${partialOutputSuffix(record)}`,
-              buildDetails(detailBase, record),
+              buildDetails(detailBaseFor(record), record),
             )
           }
           return textResult(
             record.result?.trim() || "No output.",
-            buildDetails(detailBase, record),
+            buildDetails(detailBaseFor(record), record),
           )
         }
 
@@ -1990,7 +2038,7 @@ Terse command-style prompts produce shallow, generic work.
               `Use get_subagent_result to retrieve full results, or steer_subagent to send it messages.\n` +
               `Do not duplicate this agent's work.`,
             {
-              ...detailBase,
+              ...detailBaseFor(record),
               toolUses: 0,
               tokens: "",
               durationMs: 0,
@@ -2004,10 +2052,11 @@ Terse command-style prompts produce shallow, generic work.
         let spinnerFrame = 0
         const startedAt = Date.now()
         let fgId: string | undefined
+        let queuedAhead: number | undefined
 
         const streamUpdate = () => {
           const details: AgentDetails = {
-            ...detailBase,
+            ...detailBaseFor(fgId ? manager.getRecord(fgId) : undefined),
             toolUses: fgState.toolUses,
             tokens: fgId ? formatLifetimeTokens(manager.getRecord(fgId)!) : "",
             cost: fgId
@@ -2017,10 +2066,10 @@ Terse command-style prompts produce shallow, generic work.
             maxTurns: fgState.maxTurns,
             durationMs: Date.now() - startedAt,
             status: "running",
-            activity: describeActivity(
-              fgState.activeTools,
-              fgState.responseText,
-            ),
+            activity:
+              queuedAhead === undefined
+                ? describeActivity(fgState.activeTools, fgState.responseText)
+                : `queued — waiting for a foreground slot${queuedAhead > 0 ? ` (${queuedAhead} ahead)` : ""}`,
             spinnerFrame: spinnerFrame % SPINNER.length,
           }
           onUpdate?.({
@@ -2040,6 +2089,10 @@ Terse command-style prompts produce shallow, generic work.
         const origOnSession = fgCallbacks.onSessionCreated
         fgCallbacks.onSessionCreated = (session: any) => {
           origOnSession(session)
+          if (queuedAhead !== undefined) {
+            queuedAhead = undefined
+            streamUpdate()
+          }
           for (const a of manager.listAgents()) {
             if (a.session === session) {
               fgId = a.id
@@ -2090,6 +2143,10 @@ Terse command-style prompts produce shallow, generic work.
               invocation: agentInvocation,
               signal,
               rootSessionId: ctx.sessionManager.getSessionId(),
+              onQueued: (_id, ahead) => {
+                queuedAhead = ahead
+                streamUpdate()
+              },
               ...fgCallbacks,
             },
             (fgAgentId) => {
@@ -2114,7 +2171,7 @@ Terse command-style prompts produce shallow, generic work.
         // Get final token count
         const tokenText = formatLifetimeTokens(record)
 
-        const details = buildDetails(detailBase, record, fgState, {
+        const details = buildDetails(detailBaseFor(record), record, fgState, {
           tokens: tokenText,
         })
 
@@ -2553,6 +2610,11 @@ Terse command-style prompts produce shallow, generic work.
           keybindings,
           (message: string) => manager.steer(record.id, message),
           showCost,
+          getViewerMarkdown,
+          (mode) => {
+            setViewerMarkdown(mode)
+            persistSettings(ctx, `Viewer markdown set to ${mode}`)
+          },
         )
       },
       {
@@ -2844,6 +2906,7 @@ Write the file using the write tool. Only write the file, nothing else.`
       {
         description: `Generate ${name} agent`,
         maxTurns: 5,
+        bypassQueue: true,
       },
     )
 
@@ -2968,6 +3031,7 @@ Write the file using the write tool. Only write the file, nothing else.`
   function snapshotSettings() {
     return {
       maxConcurrent: manager.getMaxConcurrent(),
+      maxConcurrentForeground: manager.getMaxConcurrentForeground(),
       // 0 = unlimited — per SubagentsSettings.defaultMaxTurns docstring and
       // normalizeMaxTurns() in agent-runner.ts (which maps 0 → undefined).
       defaultMaxTurns: getDefaultMaxTurns() ?? 0,
@@ -2991,6 +3055,8 @@ Write the file using the write tool. Only write the file, nothing else.`
       fallbackSubagent: getFallbackSubagent(),
       reportUsage: isReportUsageEnabled(),
       showCost: isShowCostEnabled(),
+      showModel: isShowModelEnabled(),
+      viewerMarkdown: getViewerMarkdown(),
     } satisfies SubagentsSettings
   }
 
@@ -3010,6 +3076,7 @@ Write the file using the write tool. Only write the file, nothing else.`
 
   const NUMERIC_IDS = new Set([
     "maxConcurrent",
+    "maxConcurrentForeground",
     "defaultMaxTurns",
     "graceTurns",
     "maxSubagentDepth",
@@ -3018,6 +3085,7 @@ Write the file using the write tool. Only write the file, nothing else.`
   async function showSettings(ctx: ExtensionCommandContext) {
     function buildItems(): SettingItem[] {
       const mc = manager.getMaxConcurrent()
+      const mcf = manager.getMaxConcurrentForeground()
       const dmt = getDefaultMaxTurns() ?? 0
       const gt = getGraceTurns()
       const msd = getMaxSubagentDepth()
@@ -3037,6 +3105,14 @@ Write the file using the write tool. Only write the file, nothing else.`
           currentValue: String(mc),
           values: [String(mc)],
         },
+        {
+          id: "maxConcurrentForeground",
+          label: "Max foreground concurrency",
+          description:
+            "Max concurrent blocking agents (0 = unlimited, Enter to type)",
+          currentValue: String(mcf),
+          values: [String(mcf)],
+        },
         {
           id: "defaultMaxTurns",
           label: "Default max turns",
@@ -3144,6 +3220,21 @@ Write the file using the write tool. Only write the file, nothing else.`
           currentValue: isShowCostEnabled() ? "on" : "off",
           values: ["on", "off"],
         },
+        {
+          id: "showModel",
+          label: "Show model",
+          description: "Show model and thinking level in running widget rows",
+          currentValue: isShowModelEnabled() ? "on" : "off",
+          values: ["on", "off"],
+        },
+        {
+          id: "viewerMarkdown",
+          label: "Viewer markdown",
+          description:
+            "Conversation Markdown: assistant (default), all tool results, or off; press m in the viewer to cycle",
+          currentValue: getViewerMarkdown(),
+          values: ["off", "assistant", "all"],
+        },
         {
           id: "fleetView",
           label: "Fleet view",
@@ -3178,6 +3269,17 @@ Write the file using the write tool. Only write the file, nothing else.`
           manager.setMaxConcurrent(n)
           notifyApplied(ctx, `Max concurrency set to ${n}`)
         }
+      } else if (id === "maxConcurrentForeground") {
+        const n = parseInt(value, 10)
+        if (n >= 0) {
+          manager.setMaxConcurrentForeground(n)
+          notifyApplied(
+            ctx,
+            n === 0
+              ? "Max foreground concurrency set to unlimited"
+              : `Max foreground concurrency set to ${n}`,
+          )
+        }
       } else if (id === "defaultMaxTurns") {
         const n = parseInt(value, 10)
         if (n === 0) {
@@ -3282,6 +3384,13 @@ Write the file using the write tool. Only write the file, nothing else.`
         const enabled = value === "on"
         setShowCost(enabled)
         notifyApplied(ctx, `Cost display ${enabled ? "enabled" : "disabled"}`)
+      } else if (id === "showModel") {
+        const enabled = value === "on"
+        setShowModel(enabled)
+        notifyApplied(ctx, `Model display ${enabled ? "enabled" : "disabled"}`)
+      } else if (id === "viewerMarkdown") {
+        setViewerMarkdown(value as ViewerMarkdownMode)
+        notifyApplied(ctx, `Viewer markdown set to ${value}`)
       } else if (id === "toolDescriptionMode") {
         setToolDescriptionMode(value as ToolDescriptionMode)
         notifyApplied(
@@ -3352,20 +3461,24 @@ Write the file using the write tool. Only write the file, nothing else.`
       const current =
         result === "maxConcurrent"
           ? String(manager.getMaxConcurrent())
-          : result === "defaultMaxTurns"
-            ? String(getDefaultMaxTurns() ?? 0)
-            : result === "maxSubagentDepth"
-              ? String(getMaxSubagentDepth())
-              : String(getGraceTurns())
+          : result === "maxConcurrentForeground"
+            ? String(manager.getMaxConcurrentForeground())
+            : result === "defaultMaxTurns"
+              ? String(getDefaultMaxTurns() ?? 0)
+              : result === "maxSubagentDepth"
+                ? String(getMaxSubagentDepth())
+                : String(getGraceTurns())
 
       const label =
         result === "maxConcurrent"
           ? "Max concurrency (1+)"
-          : result === "defaultMaxTurns"
-            ? "Default max turns (0 = unlimited)"
-            : result === "maxSubagentDepth"
-              ? "Nested depth (0/1 = nesting off)"
-              : "Grace turns (1+)"
+          : result === "maxConcurrentForeground"
+            ? "Max foreground concurrency (0 = unlimited)"
+            : result === "defaultMaxTurns"
+              ? "Default max turns (0 = unlimited)"
+              : result === "maxSubagentDepth"
+                ? "Nested depth (0/1 = nesting off)"
+                : "Grace turns (1+)"
 
       // Loop until user enters a valid integer or cancels (Esc / null).
       // Silently trims whitespace; rejects non-numeric input by re-prompting.
@@ -3388,6 +3501,18 @@ Write the file using the write tool. Only write the file, nothing else.`
   // the right toast. Successful saves show info; persistence failures downgrade
   // to warning so users aren't silently reverted on restart. Event fires regardless
   // of outcome so listeners see the in-memory change.
+  function persistSettings(
+    ctx: ExtensionCommandContext,
+    successMsg: string,
+  ): void {
+    const { message, level } = saveAndEmitChanged(
+      snapshotSettings(),
+      successMsg,
+      (event, payload) => pi.events.emit(event, payload),
+    )
+    if (level === "warning") ctx.ui.notify(message, level)
+  }
+
   function notifyApplied(ctx: ExtensionCommandContext, successMsg: string) {
     const { message, level } = saveAndEmitChanged(
       snapshotSettings(),

package/src/invocation-config.ts

@@ -113,6 +113,7 @@ export function resolveAgentInvocationConfig(
   runInBackground: boolean
   isolated: boolean
   isolation?: IsolationMode
+  overridden?: { thinking?: ThinkingLevel; model?: string }
 } {
   // Precedence first, collapse second — reversing these loses the veto, since
   // an agent file's "off" only outranks a caller's "worktree" while it is still
@@ -122,6 +123,18 @@ export function resolveAgentInvocationConfig(
     requested === "worktree" && opts?.worktreeAllowed !== false
       ? "worktree"
       : undefined
+  const overriddenThinking =
+    agentConfig?.thinking != null &&
+    params.thinking != null &&
+    agentConfig.thinking !== params.thinking
+      ? (params.thinking as ThinkingLevel)
+      : undefined
+  const overriddenModel =
+    agentConfig?.model != null &&
+    params.model != null &&
+    agentConfig.model !== params.model
+      ? params.model
+      : undefined
 
   return {
     modelInput: agentConfig?.model ?? params.model,
@@ -139,6 +152,10 @@ export function resolveAgentInvocationConfig(
       false,
     isolated: agentConfig?.isolated ?? params.isolated ?? false,
     isolation,
+    overridden:
+      overriddenThinking || overriddenModel
+        ? { thinking: overriddenThinking, model: overriddenModel }
+        : undefined,
   }
 }
 

package/src/model-resolver.ts

@@ -14,6 +14,20 @@ export interface ModelRegistry {
   getAvailable?(): any[]
 }
 
+/** Both display forms of a resolved model. */
+export function describeModel(model: {
+  provider: string
+  id: string
+  name?: string
+}): { modelName: string; modelId: string } {
+  return {
+    modelName: (model.name ?? model.id)
+      .replace(/^Claude\s+/i, "")
+      .toLowerCase(),
+    modelId: `${model.provider}/${model.id}`,
+  }
+}
+
 /**
  * Resolve a model string to a Model instance.
  * Tries exact match first ("provider/modelId"), then fuzzy match against all available models.

package/src/schedule.ts

@@ -22,6 +22,7 @@ import type {
 import { Cron } from "croner"
 import { nanoid } from "nanoid"
 import type { AgentManager } from "./agent-manager.js"
+import { normalizeMaxTurns } from "./agent-runner.js"
 import { resolveSpawnType } from "./agent-types.js"
 import { resolveModel } from "./model-resolver.js"
 import type { ScheduleStore } from "./schedule-store.js"
@@ -280,6 +281,13 @@ export class SubagentScheduler {
         isolated: job.isolated,
         thinkingLevel: job.thinking,
         isolation: job.isolation,
+        invocation: {
+          thinking: job.thinking,
+          maxTurns: normalizeMaxTurns(job.max_turns),
+          isolated: job.isolated,
+          runInBackground: true,
+          isolation: job.isolation,
+        },
       })
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err)

package/src/settings.ts

@@ -6,10 +6,12 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { dirname, join } from "node:path"
 import { getAgentDir } from "@earendil-works/pi-coding-agent"
 import { NO_FALLBACK } from "./agent-types.js"
-import type { JoinMode, WidgetMode } from "./types.js"
+import type { JoinMode, ViewerMarkdownMode, WidgetMode } from "./types.js"
 
 export interface SubagentsSettings {
   maxConcurrent?: number
+  /** Max concurrent blocking agents. 0 = unlimited (default). */
+  maxConcurrentForeground?: number
   /**
    * 0 = unlimited — the extension's single source of truth for that convention:
    * `normalizeMaxTurns()` in agent-runner.ts treats 0 → `undefined`, and the
@@ -200,6 +202,10 @@ export interface SubagentsSettings {
    * what the parent session counts.
    */
   showCost?: boolean
+  /** Show effective model and thinking level in running widget rows. */
+  showModel?: boolean
+  /** Markdown scope in the conversation viewer. Defaults to assistant. */
+  viewerMarkdown?: ViewerMarkdownMode
 }
 
 export type ToolDescriptionMode = "full" | "compact" | "custom"
@@ -207,6 +213,7 @@ export type ToolDescriptionMode = "full" | "compact" | "custom"
 /** Setter hooks used by applySettings to wire persisted values into in-memory state. */
 export interface SettingsAppliers {
   setMaxConcurrent: (n: number) => void
+  setMaxConcurrentForeground: (n: number) => void
   setDefaultMaxTurns: (n: number) => void
   setGraceTurns: (n: number) => void
   setDefaultJoinMode: (mode: JoinMode) => void
@@ -224,6 +231,8 @@ export interface SettingsAppliers {
   setFallbackSubagent: (v: string | undefined) => void
   setReportUsage: (b: boolean) => void
   setShowCost: (b: boolean) => void
+  setShowModel: (b: boolean) => void
+  setViewerMarkdown: (mode: ViewerMarkdownMode) => void
 }
 
 /** Emit callback — a subset of `pi.events.emit` to keep helpers testable. */
@@ -241,6 +250,8 @@ const VALID_WIDGET_MODES: ReadonlySet<string> = new Set<WidgetMode>([
   "background",
   "off",
 ])
+const VALID_VIEWER_MARKDOWN_MODES: ReadonlySet<string> =
+  new Set<ViewerMarkdownMode>(["off", "assistant", "all"])
 
 // Sanity ceilings — prevent hand-edited configs from asking for values that
 // make no operational sense (e.g. 1e6 concurrent subagents). Permissive enough
@@ -262,6 +273,13 @@ function sanitize(raw: unknown): SubagentsSettings {
   ) {
     out.maxConcurrent = r.maxConcurrent as number
   }
+  if (
+    Number.isInteger(r.maxConcurrentForeground) &&
+    (r.maxConcurrentForeground as number) >= 0 &&
+    (r.maxConcurrentForeground as number) <= MAX_CONCURRENT_CEILING
+  ) {
+    out.maxConcurrentForeground = r.maxConcurrentForeground as number
+  }
   if (
     Number.isInteger(r.defaultMaxTurns) &&
     (r.defaultMaxTurns as number) >= 0 &&
@@ -331,6 +349,15 @@ function sanitize(raw: unknown): SubagentsSettings {
   if (typeof r.showCost === "boolean") {
     out.showCost = r.showCost
   }
+  if (typeof r.showModel === "boolean") {
+    out.showModel = r.showModel
+  }
+  if (
+    typeof r.viewerMarkdown === "string" &&
+    VALID_VIEWER_MARKDOWN_MODES.has(r.viewerMarkdown)
+  ) {
+    out.viewerMarkdown = r.viewerMarkdown as ViewerMarkdownMode
+  }
   if (r.fallbackSubagent === false) {
     // The only non-string spelling worth accepting: a boolean would otherwise be
     // dropped, silently leaving the PERMISSIVE default in place. Every string is
@@ -407,6 +434,8 @@ export function applySettings(
 ): void {
   if (typeof s.maxConcurrent === "number")
     appliers.setMaxConcurrent(s.maxConcurrent)
+  if (typeof s.maxConcurrentForeground === "number")
+    appliers.setMaxConcurrentForeground(s.maxConcurrentForeground)
   if (typeof s.defaultMaxTurns === "number")
     appliers.setDefaultMaxTurns(s.defaultMaxTurns)
   if (typeof s.graceTurns === "number") appliers.setGraceTurns(s.graceTurns)
@@ -434,6 +463,8 @@ export function applySettings(
     appliers.setWorktreeIsolation(s.worktreeIsolation)
   if (typeof s.reportUsage === "boolean") appliers.setReportUsage(s.reportUsage)
   if (typeof s.showCost === "boolean") appliers.setShowCost(s.showCost)
+  if (typeof s.showModel === "boolean") appliers.setShowModel(s.showModel)
+  if (s.viewerMarkdown) appliers.setViewerMarkdown(s.viewerMarkdown)
 }
 
 /**

package/src/types.ts

@@ -105,6 +105,9 @@ export type JoinMode = "async" | "group" | "smart"
  */
 export type WidgetMode = "all" | "background" | "off"
 
+/** How much of the conversation viewer renders as Markdown. */
+export type ViewerMarkdownMode = "off" | "assistant" | "all"
+
 export interface AgentRecord {
   id: string
   type: SubagentType
@@ -125,6 +128,10 @@ export interface AgentRecord {
   session?: AgentSession
   abortController?: AbortController
   promise?: Promise<string>
+  /** Whether a caller is awaiting this agent inline. */
+  blocking?: boolean
+  /** Resolves when a queued blocking agent starts or is removed from the queue. */
+  startGate?: Promise<void>
   groupId?: string
   joinMode?: JoinMode
   /** Set when result was already consumed via get_subagent_result — suppresses completion notification. */
@@ -176,10 +183,18 @@ export interface AgentRecord {
   rootSessionId?: string
 }
 
+/** Effective session level, including pi's display-only `off` value. */
+export type EffectiveThinkingLevel = ThinkingLevel | "off"
+
 export interface AgentInvocation {
-  /** Short display name, e.g. "haiku" — only set when different from parent. */
+  /** Short model label for tight UI rows. */
   modelName?: string
-  thinking?: ThinkingLevel
+  /** Canonical provider/model id. */
+  modelId?: string
+  thinking?: EffectiveThinkingLevel
+  /** Requested values retained only when the run used something else. */
+  requestedThinking?: EffectiveThinkingLevel
+  requestedModel?: string
   maxTurns?: number
   isolated?: boolean
   inheritContext?: boolean

package/src/ui/agent-widget.ts

@@ -226,18 +226,31 @@ export function getPromptModeLabel(type: SubagentType): string | undefined {
 /** Mode label is not included — callers add it where they want it. */
 export function buildInvocationTags(invocation: AgentInvocation | undefined): {
   modelName?: string
+  modelId?: string
   tags: string[]
 } {
   const tags: string[] = []
   if (!invocation) return { tags }
-  if (invocation.thinking) tags.push(`thinking: ${invocation.thinking}`)
+  const asked = (
+    value: string | undefined,
+    requested: string | undefined,
+  ): string | undefined =>
+    value && requested && requested !== value
+      ? `${value} (asked ${requested})`
+      : value
+  const thinking = asked(invocation.thinking, invocation.requestedThinking)
+  if (thinking) tags.push(`thinking: ${thinking}`)
   if (invocation.isolated) tags.push("isolated")
   if (invocation.isolation === "worktree") tags.push("worktree")
   if (invocation.inheritContext) tags.push("inherit context")
   if (invocation.runInBackground) tags.push("background")
   if (invocation.maxTurns != null)
     tags.push(`max turns: ${invocation.maxTurns}`)
-  return { modelName: invocation.modelName, tags }
+  return {
+    modelName: asked(invocation.modelName, invocation.requestedModel),
+    modelId: asked(invocation.modelId, invocation.requestedModel),
+    tags,
+  }
 }
 
 /** Truncate text to a single line, max `len` chars. */
@@ -317,6 +330,8 @@ export class AgentWidget {
      * supplies the user's `showCost` setting.
      */
     private showCost: () => boolean = () => false,
+    /** Whether running rows show the model and thinking level. */
+    private showModel: () => boolean = () => false,
   ) {}
 
   /**
@@ -526,6 +541,12 @@ export class AgentWidget {
         : ""
 
       const parts: string[] = []
+      if (this.showModel()) {
+        const { modelName, tags } = buildInvocationTags(a.invocation)
+        if (modelName) parts.push(modelName)
+        const thinkingTag = tags.find((tag) => tag.startsWith("thinking: "))
+        if (thinkingTag) parts.push(thinkingTag)
+      }
       if (bg) parts.push(formatTurns(bg.turnCount, bg.maxTurns))
       if (toolUses > 0)
         parts.push(`${toolUses} tool use${toolUses === 1 ? "" : "s"}`)