@nklisch/pi-enhanced 0.1.8 → 0.1.9

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/tools/spawn-config.ts

@@ -14,6 +14,7 @@ import { normalizeMaxTurns } from "#src/lifecycle/turn-limits";
 import type { ModelRegistry } from "#src/session/model-resolver";
 import { formatModelLabel } from "#src/session/model-label";
 import { resolveInvocationModel } from "#src/session/model-resolver";
+import { resolveEffectiveThinkingLevel } from "#src/session/thinking-level";
 import type { AgentInvocation, SubagentType, ThinkingLevel } from "#src/types";
 import {
   type AgentDetails,
@@ -25,6 +26,8 @@ import {
 /** Model info extracted from the parent session context. */
 export interface ModelInfo {
   parentModel: Model<any> | undefined;
+  /** Parent's current level for children that inherit thinking settings. */
+  parentThinkingLevel?: ThinkingLevel;
   modelRegistry: ModelRegistry | undefined;
 }
 
@@ -42,7 +45,10 @@ export interface SpawnExecution {
   description: string;
   model: Model<any> | undefined;
   effectiveMaxTurns: number | undefined;
+  /** Requested/configured level before model-capability clamping. */
   thinking: ThinkingLevel | undefined;
+  /** Exact level passed to the child session after model-capability clamping. */
+  effectiveThinkingLevel: ThinkingLevel;
   inheritContext: boolean;
   runInBackground: boolean;
   agentInvocation: AgentInvocation;
@@ -50,9 +56,9 @@ export interface SpawnExecution {
 
 /** Presentation: display/UI values derived from identity and execution. */
 export interface SpawnPresentation {
-  modelName: string | undefined;
+  modelName: string;
   agentTags: string[];
-  detailBase: Pick<AgentDetails, "displayName" | "description" | "subagentType" | "modelName" | "tags">;
+  detailBase: Pick<AgentDetails, "displayName" | "description" | "subagentType" | "modelName" | "thinkingLevel" | "tags">;
 }
 
 /** Fully resolved config for spawning an agent — composed of domain-aligned sub-interfaces. */
@@ -110,6 +116,11 @@ export function resolveSpawnConfig(
   const model = resolution.model;
 
   const thinking = resolvedConfig.thinking;
+  const effectiveThinkingLevel = resolveEffectiveThinkingLevel(
+    model,
+    thinking,
+    modelInfo.parentThinkingLevel,
+  );
   const inheritContext = resolvedConfig.inheritContext;
   const runInBackground = resolvedConfig.runInBackground;
 
@@ -137,6 +148,7 @@ export function resolveSpawnConfig(
     description: params.description as string,
     subagentType,
     modelName,
+    thinkingLevel: effectiveThinkingLevel,
     tags: agentTags.length > 0 ? agentTags : undefined,
   };
 
@@ -148,6 +160,7 @@ export function resolveSpawnConfig(
       model,
       effectiveMaxTurns,
       thinking,
+      effectiveThinkingLevel,
       inheritContext,
       runInBackground,
       agentInvocation,

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/tools/steer-tool.ts

@@ -2,7 +2,7 @@ import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { formatLifetimeTokens, textResult } from "#src/tools/helpers";
 import type { SteerOutcome, Subagent } from "#src/types";
-import { formatDuration } from "#src/ui/display";
+import { formatDuration, formatModelThinking } from "#src/ui/display";
 
 // ---- Deps interfaces ----
 
@@ -68,7 +68,7 @@ export class SteerTool {
 	private renderDelivered(record: Subagent) {
 		const tokens = formatLifetimeTokens(record);
 		const contextPercent = record.getContextPercent();
-		const stateParts: string[] = [record.modelLabel, formatDuration(record.startedAt, record.completedAt)];
+		const stateParts: string[] = [formatModelThinking(record.modelLabel, record.effectiveThinkingLevel), formatDuration(record.startedAt, record.completedAt)];
 		if (tokens) stateParts.push(tokens);
 		stateParts.push(`${record.toolUses} tool ${record.toolUses === 1 ? "use" : "uses"}`);
 		if (contextPercent !== null)
@@ -84,7 +84,7 @@ export class SteerTool {
 	}
 
 	private renderRunIdentity(record: Subagent): string {
-		return `Model: ${record.modelLabel}\nRuntime: ${formatDuration(record.startedAt, record.completedAt)}`;
+		return `Model: ${formatModelThinking(record.modelLabel, record.effectiveThinkingLevel)}\nRuntime: ${formatDuration(record.startedAt, record.completedAt)}`;
 	}
 
 	toToolDefinition() {

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/types.ts

@@ -2,14 +2,16 @@
  * types.ts — Type definitions for the subagent system.
  */
 
-import type { ThinkingLevel } from "@earendil-works/pi-ai";
+import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
 import type { AgentSessionEvent, SessionContext as SdkSessionContext } from "@earendil-works/pi-coding-agent";
 import type { ModelRegistry } from "#src/session/model-resolver";
 
 
 export type { SteerOutcome } from "#src/lifecycle/subagent";
 export { Subagent } from "#src/lifecycle/subagent";
-export type { AgentSessionEvent, ThinkingLevel };
+export type { AgentSessionEvent };
+/** Pi's model-capability thinking levels, including the explicit `off` value. */
+export type ThinkingLevel = ModelThinkingLevel;
 
 /**
  * One message in a child session's history, typed from Pi's `SessionContext`.
@@ -86,6 +88,8 @@ export interface AgentInvocation {
 export interface SessionContext {
   readonly cwd: string;
   readonly model: unknown;
+  /** Parent session's current effective thinking level for inherited children. */
+  readonly thinkingLevel?: ThinkingLevel;
   readonly modelRegistry: ModelRegistry | undefined;
   getSystemPrompt(): string;
   readonly sessionManager: {

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/agent-widget.ts

@@ -8,9 +8,9 @@
 
 import { AgentTypeRegistry } from "#src/config/agent-types";
 import type { Subagent } from "#src/lifecycle/subagent";
-import type { SubagentManager, SubagentManagerObserver } from "#src/lifecycle/subagent-manager";
+import type { SubagentManagerObserver } from "#src/lifecycle/subagent-manager";
 import type { CompactionInfo } from "#src/types";
-import { ERROR_STATUSES, formatMs, type Theme } from "#src/ui/display";
+import { ERROR_STATUSES, formatModelThinking, formatMs, type Theme } from "#src/ui/display";
 import { renderWidgetLines, type WidgetAgent } from "#src/ui/widget-renderer";
 
 // ---- Types ----
@@ -54,7 +54,7 @@ export function assembleWidgetState(
 /** Render the aggregate status bar without hiding per-agent model/runtime details. */
 export function formatStatusBar(
   state: WidgetState,
-  agents: readonly Pick<Subagent, "status" | "modelLabel" | "startedAt">[],
+  agents: readonly Pick<Subagent, "status" | "modelLabel" | "effectiveThinkingLevel" | "startedAt">[],
   now = Date.now(),
 ): string | undefined {
   if (!state.hasActive) return undefined;
@@ -65,8 +65,8 @@ export function formatStatusBar(
   const activeDetails = agents
     .filter((agent) => agent.status === "running" || agent.status === "queued")
     .map((agent) => agent.status === "running"
-      ? `${agent.modelLabel} ${formatMs(now - agent.startedAt)}`
-      : `${agent.modelLabel} queued`);
+      ? `${formatModelThinking(agent.modelLabel, agent.effectiveThinkingLevel)} ${formatMs(now - agent.startedAt)}`
+      : `${formatModelThinking(agent.modelLabel, agent.effectiveThinkingLevel)} queued`);
   return `${statusParts.join(", ")} agent${total === 1 ? "" : "s"} · ${activeDetails.join(", ")}`;
 }
 
@@ -85,10 +85,18 @@ export class AgentWidget implements SubagentManagerObserver {
   private uiCtx: UICtx | undefined;
   private widgetFrame = 0;
   private widgetInterval: ReturnType<typeof setInterval> | undefined;
-  /** Tracks how many turns each finished agent has survived. Key: agent ID, Value: turns since finished. */
+  /**
+   * Bounded reactive read model: lifecycle callbacks add active background
+   * records and the small terminal linger set; render ticks never ask the
+   * manager to clone or sort its retained history.
+   */
+  private readonly backgroundAgents = new Map<string, Subagent>();
+  /** Tracks how many turns each finished agent has survived. */
   private finishedTurnAge = new Map<string, number>();
   /** How many extra turns errors/aborted agents linger (completed agents clear after 1 turn). */
   private static readonly ERROR_LINGER_TURNS = 2;
+  /** Pi renders the whole component tree for each requestRender call. */
+  private static readonly STATUS_REFRESH_INTERVAL_MS = 500;
 
   /** Whether the widget callback is currently registered with the TUI. */
   private widgetRegistered = false;
@@ -97,14 +105,12 @@ export class AgentWidget implements SubagentManagerObserver {
   /** Last status bar text, used to avoid redundant setStatus calls. */
   private lastStatusText: string | undefined;
 
-  constructor(
-    private manager: SubagentManager,
-    private registry: AgentTypeRegistry,
-  ) {}
+  constructor(private registry: AgentTypeRegistry) {}
 
   /** Set the UI context (grabbed from first tool execution). */
   setUICtx(ctx: UICtx) {
-    if (ctx !== this.uiCtx) {
+    const contextChanged = ctx !== this.uiCtx;
+    if (contextChanged) {
       // UICtx changed — the widget registered on the old context is gone.
       // Force re-registration on next update().
       this.uiCtx = ctx;
@@ -112,6 +118,10 @@ export class AgentWidget implements SubagentManagerObserver {
       this.tui = undefined;
       this.lastStatusText = undefined;
     }
+    // Lifecycle events can arrive before the first tool gives us a UI context.
+    // Refresh when that context becomes available, but let update() decide
+    // whether any active record actually needs an animation timer.
+    if (contextChanged && this.uiCtx && this.backgroundAgents.size > 0) this.update();
   }
 
   /**
@@ -119,62 +129,118 @@ export class AgentWidget implements SubagentManagerObserver {
    * Ages finished agents and clears those that have lingered long enough.
    */
   onTurnStart() {
-    // Age all finished agents
+    // Age terminal records and remove them before the next render. Completed
+    // records linger for one turn; errors and aborted records linger for two.
     for (const [id, age] of this.finishedTurnAge) {
-      this.finishedTurnAge.set(id, age + 1);
+      const record = this.backgroundAgents.get(id);
+      const nextAge = age + 1;
+      if (!record || nextAge >= this.maxFinishedAge(record.status)) {
+        this.finishedTurnAge.delete(id);
+        this.backgroundAgents.delete(id);
+      } else {
+        this.finishedTurnAge.set(id, nextAge);
+      }
     }
-    // Trigger a widget refresh (will filter out expired agents)
     this.update();
   }
 
   // ---- SubagentManagerObserver: react to lifecycle, self-drive the timer ----
 
   /** A subagent started running — ensure the update loop is live and render. */
-  onSubagentStarted(_record: Subagent) {
+  onSubagentStarted(record: Subagent) {
+    if (!this.trackBackground(record)) return;
+    this.finishedTurnAge.delete(record.id);
     this.startLoop();
   }
 
   /** A background subagent was created (queued) — ensure the loop is live and render. */
-  onSubagentCreated(_record: Subagent) {
+  onSubagentCreated(record: Subagent) {
+    if (!this.trackBackground(record)) return;
+    this.finishedTurnAge.delete(record.id);
+    this.startLoop();
+  }
+
+  /** A subagent completed — seed its bounded linger entry and render. */
+  onSubagentCompleted(record: Subagent) {
+    if (!this.trackBackground(record)) return;
+    this.finishedTurnAge.set(record.id, 0);
+    this.update();
+  }
+
+  /** A resumed subagent started — ensure the update loop is live and render. */
+  onSubagentResumedStarted(record: Subagent) {
+    if (!this.trackBackground(record)) return;
+    this.finishedTurnAge.delete(record.id);
     this.startLoop();
   }
 
-  /** A subagent completed — render so the finished state is seeded and shown. */
-  onSubagentCompleted(_record: Subagent) {
+  /** A resumed subagent settled — seed its terminal linger entry. */
+  onSubagentResumed(record: Subagent) {
+    if (!this.trackBackground(record)) return;
+    this.finishedTurnAge.set(record.id, 0);
     this.update();
   }
 
   /** A subagent's session compacted — render to refresh the compaction count. */
-  onSubagentCompacted(_record: Subagent, _info: CompactionInfo) {
+  onSubagentCompacted(record: Subagent, _info: CompactionInfo) {
+    if (this.trackBackground(record)) this.update();
+  }
+
+  /** Remove terminal state when the manager clears a parent session. */
+  onSubagentCleared(record: Subagent) {
+    if (!this.backgroundAgents.delete(record.id)) return;
+    this.finishedTurnAge.delete(record.id);
     this.update();
   }
 
-  /** Start the update timer (if not already running) and render immediately. */
+  /** Refresh immediately; update() owns the timer lifecycle. */
   private startLoop() {
-    this.ensureTimer();
+    if (!this.uiCtx) return;
     this.update();
   }
 
-  /** Ensure the widget update timer is running. */
+  /** Ensure the widget update timer is running while active records animate. */
   private ensureTimer() {
-    this.widgetInterval ??= setInterval(() => this.update(), 80);
+    this.widgetInterval ??= setInterval(
+      () => this.update(),
+      AgentWidget.STATUS_REFRESH_INTERVAL_MS,
+    );
+  }
+
+  /** Stop animated refreshes while leaving any static finished widget intact. */
+  private stopTimer() {
+    if (this.widgetInterval) {
+      clearInterval(this.widgetInterval);
+      this.widgetInterval = undefined;
+    }
   }
 
   /** Check if a finished agent should still be shown in the widget. */
   private shouldShowFinished(agentId: string, status: string): boolean {
     const age = this.finishedTurnAge.get(agentId) ?? 0;
-    const maxAge = ERROR_STATUSES.has(status) ? AgentWidget.ERROR_LINGER_TURNS : 1;
-    return age < maxAge;
+    return age < this.maxFinishedAge(status);
   }
 
-  /**
-   * Background agents only — the widget's sole audience (ADR-0004 Decision A).
-   * Foreground runs are rendered by the `subagent` tool's inline `onUpdate` stream,
-   * so funneling both `listAgents()` call sites through this accessor applies the
-   * background predicate exactly once at the source.
-   */
-  private listBackgroundAgents(): Subagent[] {
-    return this.manager.listAgents().filter(record => record.invocation?.runInBackground === true);
+  private maxFinishedAge(status: string): number {
+    return ERROR_STATUSES.has(status) ? AgentWidget.ERROR_LINGER_TURNS : 1;
+  }
+
+  /** Add a record only when its immutable invocation snapshot marks it background. */
+  private trackBackground(record: Subagent): boolean {
+    if (record.invocation?.runInBackground !== true) return false;
+    this.backgroundAgents.set(record.id, record);
+    return true;
+  }
+
+  /** Drop terminal entries whose turn-based linger window has already elapsed. */
+  private pruneExpiredFinished(): void {
+    for (const [id, record] of this.backgroundAgents) {
+      if (record.isActive()) continue;
+      if (record.completedAt == null || !this.shouldShowFinished(id, record.status)) {
+        this.backgroundAgents.delete(id);
+        this.finishedTurnAge.delete(id);
+      }
+    }
   }
 
   /** Project a live Subagent record onto a pure-data WidgetAgent snapshot. */
@@ -185,6 +251,7 @@ export class AgentWidget implements SubagentManagerObserver {
       status: record.status,
       description: record.description,
       modelLabel: record.modelLabel,
+      thinkingLevel: record.effectiveThinkingLevel,
       toolUses: record.toolUses,
       startedAt: record.startedAt,
       completedAt: record.completedAt,
@@ -202,7 +269,7 @@ export class AgentWidget implements SubagentManagerObserver {
   /** Delegate rendering to the pure widget-renderer module. */
   private renderWidget(tui: any, theme: Theme): string[] {
     return renderWidgetLines({
-      agents: this.listBackgroundAgents().map(r => this.toWidgetAgent(r)),
+      agents: [...this.backgroundAgents.values()].map(r => this.toWidgetAgent(r)),
       registry: this.registry,
       spinnerFrame: this.widgetFrame,
       terminalWidth: tui.terminal.columns,
@@ -213,10 +280,10 @@ export class AgentWidget implements SubagentManagerObserver {
 
   /**
    * Unregister the widget, clear the status bar, stop the interval timer, and
-   * purge stale `finishedTurnAge` entries for agents no longer in `backgroundAgents`.
+   * release the bounded read model once no visible agents remain.
    * Called only from `update`'s idle path — not from `dispose`.
    */
-  private clearWidget(backgroundAgents: readonly AgentSummary[]): void {
+  private clearWidget(): void {
     if (this.widgetRegistered) {
       this.uiCtx!.setWidget("agents", undefined);
       this.widgetRegistered = false;
@@ -226,10 +293,9 @@ export class AgentWidget implements SubagentManagerObserver {
       this.uiCtx!.setStatus("subagents", undefined);
       this.lastStatusText = undefined;
     }
-    if (this.widgetInterval) { clearInterval(this.widgetInterval); this.widgetInterval = undefined; }
-    for (const [id] of this.finishedTurnAge) {
-      if (!backgroundAgents.some(a => a.id === id)) this.finishedTurnAge.delete(id);
-    }
+    this.stopTimer();
+    this.backgroundAgents.clear();
+    this.finishedTurnAge.clear();
   }
 
   /**
@@ -244,34 +310,24 @@ export class AgentWidget implements SubagentManagerObserver {
     }
   }
 
-  /**
-   * Seed linger tracking for any newly-observed finished agent.
-   * The widget owns detection of completions it observes via `listAgents()`,
-   * so no external bookkeeping call is needed.
-   * Idempotent — only seeds when an entry is absent, so repeated updates within
-   * a turn neither reset nor advance the age.
-   */
-  private seedFinishedAgents(agents: readonly AgentSummary[]): void {
-    for (const a of agents) {
-      if (a.completedAt && !this.finishedTurnAge.has(a.id)) {
-        this.finishedTurnAge.set(a.id, 0);
-      }
-    }
-  }
-
   /** Force an immediate widget update. */
   update() {
     if (!this.uiCtx) return;
 
-    const backgroundAgents = this.listBackgroundAgents();
-    this.seedFinishedAgents(backgroundAgents);
+    this.pruneExpiredFinished();
+    const backgroundAgents = [...this.backgroundAgents.values()];
     const state = assembleWidgetState(backgroundAgents, (id, status) => this.shouldShowFinished(id, status));
 
     if (!state.hasActive && !state.hasFinished) {
-      this.clearWidget(backgroundAgents);
+      this.clearWidget();
       return;
     }
 
+    // Finished records remain renderable for their turn-based linger window,
+    // but they have no changing state to animate. Stop the interval while the
+    // static completion widget remains registered.
+    if (state.hasActive) this.ensureTimer();
+    else this.stopTimer();
     this.updateStatusBar(state, backgroundAgents);
     this.widgetFrame++;
 
@@ -298,10 +354,7 @@ export class AgentWidget implements SubagentManagerObserver {
 
   // fallow-ignore-next-line unused-class-member
   dispose() {
-    if (this.widgetInterval) {
-      clearInterval(this.widgetInterval);
-      this.widgetInterval = undefined;
-    }
+    this.stopTimer();
     if (this.uiCtx) {
       this.uiCtx.setWidget("agents", undefined);
       this.uiCtx.setStatus("subagents", undefined);
@@ -309,5 +362,7 @@ export class AgentWidget implements SubagentManagerObserver {
     this.widgetRegistered = false;
     this.tui = undefined;
     this.lastStatusText = undefined;
+    this.backgroundAgents.clear();
+    this.finishedTurnAge.clear();
   }
 }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/display.ts

@@ -7,7 +7,7 @@
 
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import { GLYPHS } from "#src/ui/glyphs";
-import type { AgentInvocation, SubagentType } from "#src/types";
+import type { AgentInvocation, SubagentType, ThinkingLevel } from "#src/types";
 
 // ---- Types ----
 
@@ -31,6 +31,8 @@ export interface AgentDetails {
   spinnerFrame?: number;
   /** Exact effective model label in `provider/id` form. */
   modelName?: string;
+  /** Exact effective thinking level used by the child session. */
+  thinkingLevel: ThinkingLevel;
   /** Notable config tags (e.g. ["thinking: high", "inherit context"]). */
   tags?: string[];
   /** Current turn count. */
@@ -106,6 +108,11 @@ export function formatTurns(turnCount: number, maxTurns?: number | null): string
     : `${GLYPHS.turns}${turnCount}`;
 }
 
+/** Format an exact model identity and its effective thinking level together. */
+export function formatModelThinking(modelLabel: string, thinkingLevel: ThinkingLevel): string {
+  return `${modelLabel} · thinking: ${thinkingLevel}`;
+}
+
 /** Format milliseconds as human-readable duration. */
 export function formatMs(ms: number): string {
   return `${(ms / 1000).toFixed(1)}s`;

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/session-navigation.ts

@@ -15,8 +15,8 @@
 import { buildSessionContext, parseSessionEntries, type SessionEntry, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import type { SubagentStatus } from "#src/lifecycle/subagent-state";
-import type { AgentSessionEvent, SessionMessage, SubagentType } from "#src/types";
-import { formatDuration, getDisplayName } from "#src/ui/display";
+import type { AgentSessionEvent, SessionMessage, SubagentType, ThinkingLevel } from "#src/types";
+import { formatDuration, formatModelThinking, getDisplayName } from "#src/ui/display";
 
 // ─────────────────────────────────────────────────────────────────────────────
 
@@ -26,6 +26,7 @@ export interface NavigableSubagent {
   readonly type: SubagentType;
   readonly description: string;
   readonly modelLabel: string;
+  readonly effectiveThinkingLevel: ThinkingLevel;
   readonly status: SubagentStatus;
   readonly startedAt: number;
   readonly completedAt: number | undefined;
@@ -47,6 +48,7 @@ export interface NavigableSubagent {
  */
 export interface RunDisplayMetadata {
   readonly modelLabel: string;
+  readonly thinkingLevel: ThinkingLevel;
   readonly startedAt: number;
   readonly completedAt: () => number | undefined;
 }
@@ -60,6 +62,7 @@ interface LabelFields {
   readonly type: SubagentType;
   readonly description: string;
   readonly modelLabel: string;
+  readonly effectiveThinkingLevel: ThinkingLevel;
   readonly status: SubagentStatus;
   readonly startedAt: number;
   readonly completedAt: number | undefined;
@@ -95,6 +98,7 @@ export function listNavigableAgents(
   const live = agents.flatMap((record): NavigationEntry[] => {
     const run = {
       modelLabel: record.modelLabel,
+      thinkingLevel: record.effectiveThinkingLevel,
       startedAt: record.startedAt,
       completedAt: () => record.completedAt,
     };
@@ -150,5 +154,5 @@ function buildLabel(fields: LabelFields, registry: AgentConfigLookup, evicted =
   const name = getDisplayName(fields.type, registry);
   const duration = formatDuration(fields.startedAt, fields.completedAt);
   const marker = evicted ? " · released (snapshot)" : "";
-  return `${name} (${fields.description}) · ${fields.modelLabel} · ${fields.toolUses} tools · ${fields.status} · ${duration}${marker}`;
+  return `${name} (${fields.description}) · ${formatModelThinking(fields.modelLabel, fields.effectiveThinkingLevel)} · ${fields.toolUses} tools · ${fields.status} · ${duration}${marker}`;
 }

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/session-navigator.ts

@@ -39,7 +39,7 @@ import {
 } from "@earendil-works/pi-tui";
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import type { SessionMessage } from "#src/types";
-import { describeActivity, formatDuration, type Theme } from "#src/ui/display";
+import { describeActivity, formatDuration, formatModelThinking, type Theme } from "#src/ui/display";
 import { fileSnapshotSource, listNavigableAgents, liveSource, type NavigableSubagent, type RunDisplayMetadata, type TranscriptSource } from "#src/ui/session-navigation";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -225,7 +225,7 @@ export class TranscriptOverlay implements Component {
 
     lines.push(hrTop);
     const runtime = formatDuration(this.run.startedAt, this.run.completedAt());
-    lines.push(row(th.bold(`Subagent session · ${this.run.modelLabel} · ${runtime}`)));
+    lines.push(row(th.bold(`Subagent session · ${formatModelThinking(this.run.modelLabel, this.run.thinkingLevel)} · ${runtime}`)));
     lines.push(hrMid);
 
     const contentLines = this.buildContentLines(innerW);

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/ui/widget-renderer.ts

@@ -9,9 +9,10 @@ import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import type { LifetimeUsage } from "#src/lifecycle/usage";
 import { getLifetimeTotal } from "#src/lifecycle/usage";
-import type { SubagentType } from "#src/types";
+import type { SubagentType, ThinkingLevel } from "#src/types";
 import {
 	describeActivity,
+	formatModelThinking,
 	formatMs,
 	formatSessionTokens,
 	formatTurns,
@@ -30,6 +31,7 @@ export interface WidgetAgent {
 	readonly status: string;
 	readonly description: string;
 	readonly modelLabel: string;
+	readonly thinkingLevel: ThinkingLevel;
 	readonly toolUses: number;
 	readonly startedAt: number;
 	readonly completedAt?: number;
@@ -78,7 +80,7 @@ export function renderFinishedLine(
 		statusText = theme.fg("warning", " aborted");
 	}
 
-	const parts: string[] = [agent.modelLabel];
+	const parts: string[] = [formatModelThinking(agent.modelLabel, agent.thinkingLevel)];
 	parts.push(formatTurns(agent.turnCount, agent.maxTurns));
 	if (agent.toolUses > 0) parts.push(`${agent.toolUses} tool use${agent.toolUses === 1 ? "" : "s"}`);
 	parts.push(duration);
@@ -102,7 +104,7 @@ export function renderRunningLines(
 	const tokens = getLifetimeTotal(agent.lifetimeUsage);
 	const tokenText = tokens > 0 ? formatSessionTokens(tokens, agent.contextPercent, theme, agent.compactionCount) : "";
 
-	const parts: string[] = [agent.modelLabel];
+	const parts: string[] = [formatModelThinking(agent.modelLabel, agent.thinkingLevel)];
 	parts.push(formatTurns(agent.turnCount, agent.maxTurns));
 	if (agent.toolUses > 0) parts.push(`${agent.toolUses} tool use${agent.toolUses === 1 ? "" : "s"}`);
 	if (tokenText) parts.push(tokenText);
@@ -176,7 +178,7 @@ function buildSections(
 		truncate(
 			theme.fg("dim", "\u251C\u2500")
 			+ ` ${theme.fg("muted", "\u25E6")} ${theme.fg("dim", getDisplayName(agent.type, registry))}`
-			+ ` ${theme.fg("dim", "·")} ${theme.fg("dim", agent.modelLabel)}`
+			+ ` ${theme.fg("dim", "·")} ${theme.fg("dim", formatModelThinking(agent.modelLabel, agent.thinkingLevel))}`
 			+ ` ${theme.fg("dim", "·")} ${theme.fg("dim", agent.description)}`
 			+ ` ${theme.fg("dim", "· queued")}`,
 		),

package/node_modules/@nklisch/pi-plugins/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-plugins",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "private": false,
   "description": "Native marketplace and plugin lifecycle management for Pi, with Claude Code and Codex compatibility.",
   "license": "MIT",
@@ -67,8 +67,8 @@
     "@nklisch/pi-subagents"
   ],
   "dependencies": {
-    "@nklisch/pi-mcp-adapter": "2.20.1-nklisch.0",
-    "@nklisch/pi-subagents": "18.1.0-nklisch.0",
+    "@nklisch/pi-mcp-adapter": "2.20.1-nklisch.1",
+    "@nklisch/pi-subagents": "18.1.0-nklisch.1",
     "jiti": "2.7.0",
     "semver": "7.8.1",
     "smol-toml": "^1.7.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-enhanced",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Pi, enhanced — one install for nklisch's full harness: policy-gated command review, plugin marketplace, subagents, background tasks, research tools, search, model modes, and a curated UX set.",
   "author": {
     "name": "nklisch"
@@ -67,7 +67,7 @@
     "@nklisch/pi-clearance": "^0",
     "@nklisch/pi-conveniences": "^0",
     "@nklisch/pi-fff-compat": "^0",
-    "@nklisch/pi-mcp-adapter": "2.20.1-nklisch.0",
+    "@nklisch/pi-mcp-adapter": "2.20.1-nklisch.1",
     "@nklisch/pi-model-modes": "^0",
     "@nklisch/pi-plugins": "^0",
     "@sinclair/typebox": "^0.34.49",