@nklisch/pi-enhanced 0.1.8 → 0.1.9

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/docs/architecture/client-server-opportunities.md

@@ -21,7 +21,7 @@ A subagent **is** a child `AgentSession`. pi-subagents already creates one via `
 Today that child session is an in-process object visible only through machinery pi-subagents had to invent because Pi has no session-sync client:
 
 - `record-observer` re-derives live activity from raw session events.
-- the 80 ms `SubagentManager.listAgents()` widget poll.
+- the lifecycle-fed widget read model and 500 ms refresh cadence.
 - the [#277] Law-of-Demeter accessors (`Subagent.getConversation()`, `.messages`, `.subscribeToUpdates()`, `.getContextPercent()`) that re-expose session internals.
 - the bespoke `ConversationViewer`, and [ADR-0004]'s replacement, native session navigation.
 - [ADR-0004]'s dual-source-by-liveness split (tracked agent → in-memory record; evicted → file snapshot).
@@ -40,9 +40,9 @@ What changes versus today:
    The snapshot carries in-flight state, so an operator attaching to an already-running subagent immediately sees its current streaming message and pending tools — not just future events.
    Today the conversation viewer only catches future deltas plus whatever happens to be in the in-memory record.
 2. **The widget and viewer become thin renderers** of synchronized session state.
-   The 80 ms poll, `record-observer`, and the [#277] accessors disappear — they were all substitutes for `subscribeSession`.
+   The lifecycle-fed widget read model, `record-observer`, and the [#277] accessors disappear — they were all substitutes for `subscribeSession`.
 3. **A unified, reconnect-safe live session list.**
-   The global event scope (`session_created`, `session_status_changed` idle/busy) means the operator sees every subagent the instant it spawns, with a live status badge per agent — replacing both `listAgents()` polling and the hand-rolled `subagents:*` broadcast tier.
+   The global event scope (`session_created`, `session_status_changed` idle/busy) means the operator sees every subagent the instant it spawns, with a live status badge per agent — replacing the widget's lifecycle-fed read model and the hand-rolled `subagents:*` broadcast tier.
 4. **Multi-session client state** lets one operator client hold synchronized caches for N subagents at once.
    This is the clean foundation for the parallel-agent navigation gesture that [ADR-0004]'s spike (entry-criterion #3) struggled to design — tabbed or split views of multiple live subagents fall out of the model with no redesign.
 
@@ -96,7 +96,7 @@ This validates and sharpens the direction the architecture doc is already headin
 | Today (pi-subagents reinvents it)                                        | Under the server architecture                              |
 | ------------------------------------------------------------------------ | ---------------------------------------------------------- |
 | `record-observer` re-deriving live activity                              | `subscribeSession` delta stream                            |
-| 80 ms `listAgents()` widget poll                                         | `session_created` / `session_status_changed` global events |
+| Lifecycle-fed widget read model + 500 ms refresh                         | `session_created` / `session_status_changed` global events |
 | [#277] accessors (`messages`, `subscribeToUpdates`, `getContextPercent`) | `SessionSnapshot` + deltas                                 |
 | `ConversationViewer` / native session navigation                         | client renders the snapshot through Pi's own components    |
 | dual-source-by-liveness split                                            | server rehydrates; client sees one session shape           |

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/docs/comparison-with-upstream.md

@@ -21,7 +21,7 @@ The direct `gotgenes` lineage and this fork also share a focused-core architectu
 This fork retains several contracts that must survive selective upstream ports:
 
 - ordered lifecycle interception for prompt, result, and continuation decisions;
-- exact `provider/id` and elapsed or final runtime on every operator status surface;
+- exact `provider/id`, exact effective thinking level, and elapsed or final runtime on every operator status surface;
 - a typed service and deterministic child-session lifecycle;
 - only `general-purpose` and `Explore` as built-in agents;
 - model runtime inheritance for runtime-registered providers and authentication;

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

@@ -1,6 +1,6 @@
 {
   "name": "@nklisch/pi-subagents",
-  "version": "18.1.0-nklisch.0",
+  "version": "18.1.0-nklisch.1",
   "type": "module",
   "exports": {
     ".": {

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

@@ -56,9 +56,9 @@ export default function (pi: ExtensionAPI) {
   const runtime = createSubagentRuntime();
 
   // ---- Notification system ----
-  // Owns completion nudges and live-activity cleanup. The widget detects finished
-  // agents itself (AgentWidget.update self-seeds), so NotificationManager has no
-  // widget dependency — keeping the construction graph a cycle-free DAG.
+  // Owns completion nudges and live-activity cleanup. The widget owns its
+  // bounded lifecycle read model, so NotificationManager has no widget
+  // dependency — keeping the construction graph a cycle-free DAG.
   const notifications = new NotificationManager(
     (msg, opts) => pi.sendMessage(msg, opts),
   );
@@ -84,8 +84,7 @@ export default function (pi: ExtensionAPI) {
 
   // Fan-out observer: lets the widget subscribe as a second lifecycle consumer
   // while the manager keeps its single-observer contract. The widget is added
-  // after construction (it needs the manager); the manager consults the observer
-  // only at spawn time, so registering late is safe.
+  // before any spawn, so lifecycle callbacks populate its bounded read model.
   const observer = new CompositeSubagentObserver([eventsObserver]);
 
   const subagentSessionDeps: SubagentSessionDeps = {
@@ -134,10 +133,11 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_before_switch", () => lifecycle.handleSessionBeforeSwitch());
   pi.on("session_shutdown", () => lifecycle.handleSessionShutdown());
 
-  // Live widget: constructed after the manager (it polls listAgents()) and
-  // registered as a lifecycle observer so it self-drives its update timer.
-  const widget = new AgentWidget(manager, registry);
+  // Live widget: a lifecycle observer with a bounded reactive read model; it
+  // never rescans the manager's retained terminal-record history.
+  const widget = new AgentWidget(registry);
   observer.add(widget);
+  pi.on("session_shutdown", () => widget.dispose());
 
   // Grab UI context from first tool execution + clear lingering widget on new turn
   const toolStart = new ToolStartHandler(widget);

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/lifecycle/create-subagent-session.ts

@@ -164,6 +164,7 @@ export async function createSubagentSession(
       cwd: snapshot.cwd,
       parentSystemPrompt: snapshot.systemPrompt,
       parentModel: snapshot.model,
+      parentThinkingLevel: snapshot.thinkingLevel,
       modelRegistry: snapshot.modelRegistry,
     },
     {

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/lifecycle/parent-snapshot.ts

@@ -16,6 +16,8 @@ export interface ParentSnapshot {
   systemPrompt: string;
   /** Parent's current model instance (fallback when agent config has no model). */
   model: unknown;
+  /** Parent's current effective thinking level, used when the child inherits it. */
+  thinkingLevel?: SessionContext["thinkingLevel"];
   /** Model registry compatibility facade used for synchronous model lookup. */
   modelRegistry: {
     find(provider: string, modelId: string): unknown;
@@ -48,6 +50,7 @@ export function buildParentSnapshot(
     cwd: ctx.cwd,
     systemPrompt: ctx.getSystemPrompt(),
     model: ctx.model,
+    thinkingLevel: ctx.thinkingLevel,
     modelRegistry,
     modelRuntime,
     // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- || intentional: converts empty string to undefined as well as null/undefined

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/lifecycle/subagent-manager.ts

@@ -31,7 +31,11 @@ import type { AgentInvocation, CompactionInfo, ParentSessionInfo, SubagentType,
 export interface SubagentManagerObserver {
   onSubagentStarted(record: Subagent): void;
   onSubagentCompleted(record: Subagent): void;
+  /** Fires when a retained session begins a resumed turn. */
+  onSubagentResumedStarted?(record: Subagent): void;
   onSubagentResumed?(record: Subagent): void;
+  /** Fires when clearCompleted removes a terminal record from the parent session. */
+  onSubagentCleared?(record: Subagent): void;
   onSubagentCompacted(record: Subagent, info: CompactionInfo): void;
   /** Fires synchronously after a background agent record is created (before run). */
   onSubagentCreated(record: Subagent): void;
@@ -240,7 +244,13 @@ export class SubagentManager {
   ): Promise<Subagent | undefined> {
     const agent = this.agents.get(id);
     if (!agent?.isSessionReady()) return undefined;
-    await agent.resume(prompt, signal);
+    const resumed = agent.resume(prompt, signal);
+    try {
+      this.observer?.onSubagentResumedStarted?.(agent);
+    } catch (err) {
+      debugLog("onSubagentResumedStarted observer", err);
+    }
+    await resumed;
     return agent;
   }
 
@@ -301,6 +311,11 @@ export class SubagentManager {
   clearCompleted(): void {
     for (const [id, record] of this.agents) {
       if (record.status === "running" || record.status === "queued") continue;
+      try {
+        this.observer?.onSubagentCleared?.(record);
+      } catch (err) {
+        debugLog("onSubagentCleared observer", err);
+      }
       this.removeRecord(id, record);
     }
 

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/lifecycle/subagent-session.ts

@@ -15,6 +15,7 @@ import {
   type AgentSessionEvent,
   type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
 import type { ChildLifecyclePublisher } from "#src/lifecycle/child-lifecycle";
 import {
   type SubagentLifecycleOutcome,
@@ -24,7 +25,7 @@ import { normalizeMaxTurns } from "#src/lifecycle/turn-limits";
 import { getSessionContextPercent, type SessionStatsLike } from "#src/lifecycle/usage";
 import { extractText } from "#src/session/context";
 import { getAgentConversation } from "#src/session/conversation";
-import type { SessionMessage } from "#src/types";
+import type { SessionMessage, ThinkingLevel } from "#src/types";
 
 /** Outcome of one turn loop. */
 export interface TurnLoopResult {
@@ -94,6 +95,16 @@ export class SubagentSession {
     return this.meta.sessionId;
   }
 
+  /** Current model selected by the child session. */
+  get model(): Model<any> | undefined {
+    return this._session.model;
+  }
+
+  /** Effective level after the child session applied defaults and clamping. */
+  get thinkingLevel(): ThinkingLevel {
+    return this._session.thinkingLevel;
+  }
+
   /** Drive the initial run's turn loop; emits `completed` on accepted success. */
   async runTurnLoop(prompt: string, opts: TurnLoopOptions): Promise<TurnLoopResult> {
     const session = this._session;

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

@@ -26,6 +26,7 @@ import { WorkspaceBracket } from "#src/lifecycle/workspace-bracket";
 import { subscribeSubagentObserver } from "#src/observation/record-observer";
 import type { RunConfig } from "#src/runtime";
 import { formatModelLabel } from "#src/session/model-label";
+import { resolveEffectiveThinkingLevel } from "#src/session/thinking-level";
 import type { AgentInvocation, CompactionInfo, ParentSessionInfo, SessionMessage, SubagentType, ThinkingLevel } from "#src/types";
 
 /** Per-subagent lifecycle observer — created by SubagentManager for each spawn. */
@@ -126,13 +127,17 @@ export class Subagent {
 	get responseText(): string { return this.state.responseText; }
 	get maxTurns(): number | undefined { return this.execution.maxTurns; }
 	/** Exact effective model label used by every operator-facing status surface. */
-	get modelLabel(): string { return formatModelLabel(this.execution.model ?? this.execution.snapshot.model); }
+	get modelLabel(): string { return this._modelLabel; }
+	/** Exact effective thinking level used by every operator-facing status surface. */
+	get effectiveThinkingLevel(): ThinkingLevel { return this._effectiveThinkingLevel; }
 
 	abortController: AbortController;
 	private _promise?: Promise<void>;
 	get promise(): Promise<void> | undefined { return this._promise; }
 
 	private readonly execution: SubagentExecution;
+	private _modelLabel: string;
+	private _effectiveThinkingLevel: ThinkingLevel;
 	private readonly listeners = new RunListeners();
 	private readonly workspaceBracket: WorkspaceBracket;
 
@@ -235,6 +240,12 @@ export class Subagent {
 
 		// Execution machinery — a single mandatory collaborator
 		this.execution = init.execution;
+		this._modelLabel = formatModelLabel(this.execution.model ?? this.execution.snapshot.model);
+		this._effectiveThinkingLevel = resolveEffectiveThinkingLevel(
+			this.execution.model ?? this.execution.snapshot.model,
+			this.execution.thinkingLevel,
+			this.execution.snapshot.thinkingLevel,
+		);
 
 		// Per-run lifecycle collaborators
 		this.workspaceBracket = new WorkspaceBracket(
@@ -291,6 +302,12 @@ export class Subagent {
 			return;
 		}
 
+		// The SDK session is authoritative after creation: it has applied its
+		// defaults and model-capability clamp. Keep the record as the one source
+		// consumed by every operator-facing status surface.
+		this._modelLabel = formatModelLabel(this.subagentSession.model ?? this.execution.model ?? this.execution.snapshot.model);
+		this._effectiveThinkingLevel = this.subagentSession.thinkingLevel ?? this._effectiveThinkingLevel;
+
 		this.flushPendingSteers();
 		this.listeners.attachObserver(subscribeSubagentObserver(this.subagentSession, this.state, {
 			onCompact: (info) => this.execution.observer?.onCompacted?.(this, info),

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/observation/composite-subagent-observer.ts

@@ -33,10 +33,18 @@ export class CompositeSubagentObserver implements SubagentManagerObserver {
     this.dispatch((o) => o.onSubagentCompleted(record), "onSubagentCompleted");
   }
 
+  onSubagentResumedStarted(record: Subagent): void {
+    this.dispatch((o) => o.onSubagentResumedStarted?.(record), "onSubagentResumedStarted");
+  }
+
   onSubagentResumed(record: Subagent): void {
     this.dispatch((o) => o.onSubagentResumed?.(record), "onSubagentResumed");
   }
 
+  onSubagentCleared(record: Subagent): void {
+    this.dispatch((o) => o.onSubagentCleared?.(record), "onSubagentCleared");
+  }
+
   onSubagentCompacted(record: Subagent, info: CompactionInfo): void {
     this.dispatch((o) => o.onSubagentCompacted(record, info), "onSubagentCompacted");
   }

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

@@ -7,6 +7,7 @@ export interface NotificationDetails {
   id: string;
   description: string;
   modelLabel: string;
+  thinkingLevel: Subagent["effectiveThinkingLevel"];
   status: string;
   toolUses: number;
   turnCount: number;
@@ -72,6 +73,7 @@ export function formatTaskNotification(record: Subagent, resultMaxLen: number):
     outputFile ? `<output-file>${escapeXml(outputFile)}</output-file>` : null,
     `<status>${escapeXml(status)}</status>`,
     `<model>${escapeXml(record.modelLabel)}</model>`,
+    `<thinking_level>${escapeXml(record.effectiveThinkingLevel)}</thinking_level>`,
     `<summary>Subagent "${escapeXml(record.description)}" ${record.status}</summary>`,
     `<result>${escapeXml(resultPreview)}</result>`,
     `<usage><total_tokens>${totalTokens}</total_tokens><tool_uses>${record.toolUses}</tool_uses>${ctxXml}${compactXml}<duration_ms>${durationMs}</duration_ms></usage>`,
@@ -92,6 +94,7 @@ export function buildNotificationDetails(
     id: record.id,
     description: record.description,
     modelLabel: record.modelLabel,
+    thinkingLevel: record.effectiveThinkingLevel,
     status: record.status,
     toolUses: record.toolUses,
     turnCount: record.turnCount,

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

@@ -1,6 +1,6 @@
 import { Text } from "@earendil-works/pi-tui";
 import type { NotificationDetails } from "#src/observation/notification";
-import { formatMs, formatTokens, formatTurns } from "#src/ui/display";
+import { formatModelThinking, formatMs, formatTokens, formatTurns } from "#src/ui/display";
 
 /** Narrow theme interface — only the methods the renderer actually calls. */
 interface RendererTheme {
@@ -39,7 +39,7 @@ export function createNotificationRenderer() {
     let line = `${icon} ${theme.bold(d.description)} ${theme.fg("dim", statusText)}`;
 
     // Line 2: stats
-    const parts: string[] = [d.modelLabel];
+    const parts: string[] = [formatModelThinking(d.modelLabel, d.thinkingLevel)];
     if (d.turnCount > 0) parts.push(formatTurns(d.turnCount, d.maxTurns));
     if (d.toolUses > 0) parts.push(`${d.toolUses} tool use${d.toolUses === 1 ? "" : "s"}`);
     if (d.totalTokens > 0) parts.push(formatTokens(d.totalTokens));

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

@@ -58,6 +58,7 @@ export class SubagentRuntime {
   getModelInfo(): ModelInfo {
     return {
       parentModel: this.currentCtx?.model as Model<any> | undefined,
+      parentThinkingLevel: this.currentCtx?.thinkingLevel,
       modelRegistry: this.currentCtx?.modelRegistry,
     };
   }

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

@@ -16,9 +16,10 @@ import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { WorkspaceProvider } from "#src/lifecycle/workspace";
 import type { SpawnOptions, SubagentRecord, SubagentsService } from "#src/service/service";
 import { formatModelLabel } from "#src/session/model-label";
+import { resolveEffectiveThinkingLevel } from "#src/session/thinking-level";
 import type { ModelRegistry } from "#src/session/model-resolver";
 import { resolveDefaultModel } from "#src/session/session-config";
-import type { AgentInvocation, SessionContext, Subagent } from "#src/types";
+import type { AgentInvocation, SessionContext, Subagent, ThinkingLevel } from "#src/types";
 
 /** Narrow interface for the SubagentManager — avoids coupling to the concrete class. */
 export interface SubagentManagerLike {
@@ -71,6 +72,14 @@ export class SubagentsServiceAdapter implements SubagentsService {
       : this.resolveTypeDefaultModel(resolvedType);
     const description = options?.description ?? prompt.slice(0, 80);
     const isBackground = !(options?.foreground ?? false);
+    const snapshot = this.runtime.buildSnapshot(options?.inheritContext ?? false);
+    const requestedThinking = (options?.thinkingLevel
+      ?? this.agentRegistry?.resolveAgentConfig(resolvedType).thinking) as ThinkingLevel | undefined;
+    const effectiveThinkingLevel = resolveEffectiveThinkingLevel(
+      model,
+      requestedThinking,
+      snapshot.thinkingLevel,
+    );
     const invocation: AgentInvocation = {
       modelName: formatModelLabel(model),
       maxTurns: options?.maxTurns,
@@ -78,13 +87,12 @@ export class SubagentsServiceAdapter implements SubagentsService {
       runInBackground: isBackground,
     };
 
-    const snapshot = this.runtime.buildSnapshot(options?.inheritContext ?? false);
     const parent = this.runtime.getSessionInfo();
     return this.manager.spawn(snapshot, resolvedType, prompt, {
       description,
       model,
       maxTurns: options?.maxTurns,
-      thinkingLevel: options?.thinkingLevel,
+      thinkingLevel: effectiveThinkingLevel,
       inheritContext: options?.inheritContext,
       bypassQueue: options?.bypassQueue,
       isBackground,

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

@@ -50,6 +50,8 @@ export interface AssemblerContext {
   parentSystemPrompt: string;
   /** Parent's current model instance (fallback when agent config has no model). */
   parentModel?: unknown;
+  /** Parent's current effective level for inherited child thinking. */
+  parentThinkingLevel?: ThinkingLevel;
   /** Model registry for resolving config.model strings. */
   modelRegistry: {
     find(provider: string, modelId: string): unknown;
@@ -88,7 +90,7 @@ export interface SessionConfig {
    * Caller casts to the SDK’s Model<any> at the session-creation boundary.
    */
   model: unknown;
-  /** Resolved thinking level (undefined → inherit from session). */
+  /** Resolved thinking level; undefined only when no parent level is available. */
   thinkingLevel: ThinkingLevel | undefined;
   /** Per-agent configured max turns (from agentConfig.maxTurns). */
   agentMaxTurns: number | undefined;
@@ -175,8 +177,10 @@ export function assembleSessionConfig(
     options.model ??
     resolveDefaultModel(ctx.parentModel, ctx.modelRegistry, agentConfig.model);
 
-  // Thinking level: explicit option > agent config > undefined (inherit)
-  const thinkingLevel = options.thinkingLevel ?? agentConfig.thinking;
+  // Thinking level: explicit option > agent config > parent level (inherit).
+  // Passing the inherited value explicitly lets queued status use the same
+  // value that the child session will receive once it is admitted.
+  const thinkingLevel = options.thinkingLevel ?? agentConfig.thinking ?? ctx.parentThinkingLevel;
 
   // Per-agent max turns (combined with per-call maxTurns and defaultMaxTurns by SubagentSession.runTurnLoop)
   const agentMaxTurns = agentConfig.maxTurns;

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/session/thinking-level.ts

@@ -0,0 +1,42 @@
+import { clampThinkingLevel, getSupportedThinkingLevels } from "@earendil-works/pi-ai/compat";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ThinkingLevel } from "#src/types";
+
+/** Pi's default when no session setting is available. */
+export const DEFAULT_THINKING_LEVEL: ThinkingLevel = "medium";
+
+/**
+ * Resolve the level Pi will use for a model before its AgentSession exists.
+ *
+ * The session factory passes this resolved value to Pi, while the Subagent
+ * record replaces it with AgentSession.thinkingLevel after construction. That
+ * two-step flow keeps queued/launch status useful without allowing a local
+ * approximation to outrank the SDK's authoritative value.
+ */
+export function resolveEffectiveThinkingLevel(
+  model: unknown,
+  requested?: ThinkingLevel,
+  inherited?: ThinkingLevel,
+): ThinkingLevel {
+  const level = requested ?? inherited ?? DEFAULT_THINKING_LEVEL;
+  // With no model yet, preserve the level Pi would receive rather than forcing
+  // `off`: createAgentSession may still resolve a configured default model.
+  // The created child session remains authoritative and supplies the clamp.
+  if (model == null) return level;
+  if (!isThinkingModel(model)) return "off";
+
+  const supported = getSupportedThinkingLevels(model);
+  return supported.includes(level)
+    ? level
+    : clampThinkingLevel(model, level);
+}
+
+function isThinkingModel(value: unknown): value is Model<any> {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value as { provider?: unknown; id?: unknown; reasoning?: unknown };
+  return typeof candidate.provider === "string"
+    && candidate.provider.length > 0
+    && typeof candidate.id === "string"
+    && candidate.id.length > 0
+    && typeof candidate.reasoning === "boolean";
+}

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

@@ -13,7 +13,7 @@ import { buildAgentGuidelines, buildDetails, buildTypeListText, textResult } fro
 import { renderAgentResult } from "#src/tools/result-renderer";
 import { type ModelInfo, resolveSpawnConfig } from "#src/tools/spawn-config";
 import type { ParentSessionInfo, Subagent } from "#src/types";
-import { type AgentDetails, formatDuration, getDisplayName } from "#src/ui/display";
+import { type AgentDetails, formatDuration, formatModelThinking, getDisplayName } from "#src/ui/display";
 
 // ---- Deps interfaces ----
 
@@ -113,9 +113,9 @@ export class AgentTool {
 					: `Error: ${record.error}`
 				: partial ?? "No output.";
 			return textResult(
-				`Model: ${record.modelLabel}\nRuntime: ${formatDuration(record.startedAt, record.completedAt)}\n\n${resultText}`,
+				`Model: ${formatModelThinking(record.modelLabel, record.effectiveThinkingLevel)}\nRuntime: ${formatDuration(record.startedAt, record.completedAt)}\n\n${resultText}`,
 				buildDetails(
-					{ ...config.presentation.detailBase, modelName: record.modelLabel },
+					{ ...config.presentation.detailBase, modelName: record.modelLabel, thinkingLevel: record.effectiveThinkingLevel },
 					record,
 				),
 			);

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/tools/background-spawner.ts

@@ -1,6 +1,7 @@
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { AgentSpawnConfig } from "#src/lifecycle/subagent-manager";
 import { textResult } from "#src/tools/helpers";
+import { formatModelThinking } from "#src/ui/display";
 import type { ResolvedSpawnConfig } from "#src/tools/spawn-config";
 import type { ParentSessionInfo, Subagent } from "#src/types";
 
@@ -36,7 +37,7 @@ export function spawnBackground(
       model: execution.model,
       maxTurns: execution.effectiveMaxTurns,
       inheritContext: execution.inheritContext,
-      thinkingLevel: execution.thinking,
+      thinkingLevel: execution.effectiveThinkingLevel,
       isBackground: true,
       origin: "tool",
       invocation: execution.agentInvocation,
@@ -52,7 +53,10 @@ export function spawnBackground(
     `Agent ${isQueued ? "queued" : "started"} in background.\n` +
       `Agent ID: ${id}\n` +
       `Type: ${identity.displayName}\n` +
-      `Model: ${presentation.modelName}\n` +
+      `Model: ${formatModelThinking(
+        record?.modelLabel ?? presentation.modelName,
+        record?.effectiveThinkingLevel ?? execution.effectiveThinkingLevel,
+      )}\n` +
       `Runtime: 0.0s\n` +
       `Description: ${execution.description}\n` +
       (identity.fellBack ? `Fallback: requested ${identity.rawType}; using ${identity.subagentType}\n` : "") +
@@ -66,6 +70,7 @@ export function spawnBackground(
       `Do not duplicate this agent's work.`,
     {
       ...presentation.detailBase,
+      thinkingLevel: record?.effectiveThinkingLevel ?? execution.effectiveThinkingLevel,
       toolUses: 0,
       tokens: "",
       durationMs: 0,

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/tools/foreground-runner.ts

@@ -12,6 +12,7 @@ import type { ParentSessionInfo, Subagent } from "#src/types";
 import {
   type AgentDetails,
   describeActivity,
+  formatModelThinking,
   formatMs,
   SPINNER,
 } from "#src/ui/display";
@@ -73,11 +74,12 @@ export async function runForeground(
     });
   };
 
-  // Animate spinner at ~80ms (smooth rotation through 10 braille frames)
+  // Each update traverses the parent TUI tree; avoid doing that at animation
+  // speed while the foreground tool already owns the progress surface.
   const spinnerInterval = setInterval(() => {
     spinnerFrame++;
     streamUpdate();
-  }, 80);
+  }, 500);
 
   streamUpdate();
 
@@ -92,7 +94,7 @@ export async function runForeground(
         model: execution.model,
         maxTurns: execution.effectiveMaxTurns,
         inheritContext: execution.inheritContext,
-        thinkingLevel: execution.thinking,
+        thinkingLevel: execution.effectiveThinkingLevel,
         origin: "tool",
         invocation: execution.agentInvocation,
         signal,
@@ -125,7 +127,7 @@ export async function runForeground(
   if (record.status === "error") {
     const partial = record.result?.trim();
     return textResult(
-      `${fallbackNote}Model: ${record.modelLabel}\nRuntime: ${formatMs(details.durationMs)}\nAgent failed: ${record.error}` +
+      `${fallbackNote}Model: ${formatModelThinking(record.modelLabel, record.effectiveThinkingLevel)}\nRuntime: ${formatMs(details.durationMs)}\nAgent failed: ${record.error}` +
         (partial ? `\n\nPartial output before the failure:\n${partial}` : ""),
       details,
     );
@@ -135,7 +137,7 @@ export async function runForeground(
   const statsParts = [`${record.toolUses} tool uses`];
   if (tokenText) statsParts.push(tokenText);
   return textResult(
-    `${fallbackNote}Model: ${record.modelLabel}\nRuntime: ${formatMs(durationMs)}\nAgent completed (${statsParts.join(", ")})${getStatusNote(record.status)}.\n\n` +
+    `${fallbackNote}Model: ${formatModelThinking(record.modelLabel, record.effectiveThinkingLevel)}\nRuntime: ${formatMs(durationMs)}\nAgent completed (${statsParts.join(", ")})${getStatusNote(record.status)}.\n\n` +
       (record.result?.trim() ?? "No output."),
     details,
   );

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/tools/get-result-report.ts

@@ -8,12 +8,15 @@
  */
 
 import type { SubagentStatus } from "#src/lifecycle/subagent";
+import type { ThinkingLevel } from "#src/types";
+import { formatModelThinking } from "#src/ui/display";
 
 /** The data a get_subagent_result report renders from — only what the formatter reads. */
 export interface AgentReport {
 	id: string;
 	displayName: string;
 	modelLabel: string;
+	thinkingLevel: ThinkingLevel;
 	status: SubagentStatus;
 	toolUses: number;
 	/** Pre-formatted lifetime token total; "" when zero. */
@@ -63,7 +66,7 @@ export function renderReportBody(report: AgentReport): string {
 export function formatAgentReport(report: AgentReport): string {
 	let output =
 		`Agent: ${report.id}\n` +
-		`Type: ${report.displayName} | Model: ${report.modelLabel} | Status: ${report.status} | ${renderStatsParts(report).join(" | ")}\n` +
+		`Type: ${report.displayName} | Model: ${formatModelThinking(report.modelLabel, report.thinkingLevel)} | Status: ${report.status} | ${renderStatsParts(report).join(" | ")}\n` +
 		`Description: ${report.description}\n\n`;
 	output += renderReportBody(report);
 	if (report.conversation) {

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

@@ -47,6 +47,7 @@ export class GetResultTool {
 			id: record.id,
 			displayName: getDisplayName(record.type, this.registry),
 			modelLabel: record.modelLabel,
+			thinkingLevel: record.effectiveThinkingLevel,
 			status: record.status,
 			toolUses: record.toolUses,
 			tokens: formatLifetimeTokens(record),

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

@@ -18,7 +18,7 @@ export function getStatusNote(status: string): string {
 
 /** Build AgentDetails from a base + record-specific fields. */
 export function buildDetails(
-  base: Pick<AgentDetails, "displayName" | "description" | "subagentType" | "modelName" | "tags">,
+  base: Pick<AgentDetails, "displayName" | "description" | "subagentType" | "modelName" | "thinkingLevel" | "tags">,
   record: {
     toolUses: number;
     startedAt: number;

package/node_modules/@nklisch/pi-plugins/node_modules/@nklisch/pi-subagents/src/tools/result-renderer.ts

@@ -7,7 +7,7 @@
  */
 
 import type { AgentDetails, Theme } from "#src/ui/display";
-import { formatMs, formatTurns, SPINNER } from "#src/ui/display";
+import { formatModelThinking, formatMs, formatTurns, SPINNER } from "#src/ui/display";
 
 // ---- Dispatcher ----
 
@@ -42,7 +42,10 @@ export function renderRunning(details: AgentDetails, theme: Theme): string {
 
 /** Render background launch status. */
 export function renderBackground(details: AgentDetails, theme: Theme): string {
-	const identity = [details.modelName, formatMs(details.durationMs)].filter(Boolean).join(" · ");
+	const identity = [
+		formatModelThinking(details.modelName ?? "unknown model", details.thinkingLevel),
+		formatMs(details.durationMs),
+	].join(" · ");
 	return theme.fg("dim", `  \u23BF  Running in background (ID: ${details.agentId}) · ${identity}`);
 }
 
@@ -113,8 +116,8 @@ export function renderFailed(details: AgentDetails, theme: Theme): string {
  */
 export function renderStats(details: AgentDetails, theme: Theme): string {
 	const parts: string[] = [];
-	if (details.modelName) parts.push(details.modelName);
-	if (details.tags) parts.push(...details.tags);
+	parts.push(formatModelThinking(details.modelName ?? "unknown model", details.thinkingLevel));
+	if (details.tags) parts.push(...details.tags.filter((tag) => !tag.startsWith("thinking: ")));
 	if (details.turnCount != null && details.turnCount > 0) {
 		parts.push(formatTurns(details.turnCount, details.maxTurns));
 	}