@nklisch/pi-enhanced 0.1.2 → 0.1.4

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

@@ -4,6 +4,7 @@ import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { AgentTypeRegistry } from "#src/config/agent-types";
+import { THINKING_LEVELS_DESCRIPTION } from "#src/config/thinking-levels";
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { AgentSpawnConfig } from "#src/lifecycle/subagent-manager";
 import { spawnBackground } from "#src/tools/background-spawner";
@@ -12,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, getDisplayName } from "#src/ui/display";
+import { type AgentDetails, formatDuration, getDisplayName } from "#src/ui/display";
 
 // ---- Deps interfaces ----
 
@@ -35,6 +36,7 @@ export interface AgentToolRuntime {
 export type AgentToolSettings = {
 	readonly defaultMaxTurns: number | undefined;
 	readonly maxConcurrent: number;
+	readonly fallbackSubagent?: string | false;
 };
 
 // ---- Class ----
@@ -90,7 +92,9 @@ export class AgentTool {
 			}
 			if (!existing.isSessionReady()) {
 				return textResult(
-					`Agent "${params.resume}" has no active session to resume.`,
+					existing.sessionReleased
+						? `Agent "${params.resume}" retained its result and transcript, but its live session was released after the retention window. Start a new subagent for fresh context.`
+						: `Agent "${params.resume}" has no active session to resume.`,
 				);
 			}
 			const record = await this.manager.resume(
@@ -101,9 +105,19 @@ export class AgentTool {
 			if (!record) {
 				return textResult(`Failed to resume agent "${params.resume}".`);
 			}
+			record.markConsumed();
+			const partial = record.result?.trim();
+			const resultText = record.status === "error"
+				? partial
+					? `Error: ${record.error}\n\nPartial output before the failure:\n${partial}`
+					: `Error: ${record.error}`
+				: partial ?? "No output.";
 			return textResult(
-				record.result?.trim() ?? record.error?.trim() ?? "No output.",
-				buildDetails(config.presentation.detailBase, record),
+				`Model: ${record.modelLabel}\nRuntime: ${formatDuration(record.startedAt, record.completedAt)}\n\n${resultText}`,
+				buildDetails(
+					{ ...config.presentation.detailBase, modelName: record.modelLabel },
+					record,
+				),
 			);
 		}
 
@@ -135,9 +149,11 @@ export class AgentTool {
 			...this.agentGuidelines,
 			"- Provide clear, detailed prompts so the agent can work autonomously.",
 			"- Subagent results are returned as text — summarize them for the user.",
-			"- Use run_in_background for work you don't need immediately. You will be notified when it completes.",
-			"- Use resume with an agent ID to continue a previous agent's work.",
-			"- Use steer_subagent to send mid-run messages to a running background agent.",
+			"- Background completion automatically wakes you with a result preview. Continue other work instead of polling.",
+			"- Use get_subagent_result only for full output, verbose conversation, an explicit status check or synchronization point, or recovery after a missed notification.",
+			"- Use steer_subagent to redirect an agent that is still running.",
+			"- Use resume only after an agent finishes when it should continue with the same retained conversation history.",
+			"- Launch a new subagent without resume when prior conversation history is unnecessary.",
 			'- Use model to specify a different model (as "provider/modelId", or fuzzy e.g. "haiku", "sonnet").',
 			"- Use thinking to control extended thinking level.",
 			"- Use inherit_context if the agent needs the parent conversation history.",
@@ -176,7 +192,7 @@ ${guidelines}
 				thinking: Type.Optional(
 					Type.String({
 						description:
-							"Thinking level: off, minimal, low, medium, high, xhigh. Overrides agent default.",
+							`Thinking level: ${THINKING_LEVELS_DESCRIPTION}. Overrides agent default. Availability depends on the selected model and host Pi version.`,
 					}),
 				),
 				max_turns: Type.Optional(
@@ -189,12 +205,13 @@ ${guidelines}
 				run_in_background: Type.Optional(
 					Type.Boolean({
 						description:
-							"Set to true to run in background. Returns agent ID immediately. You will be notified when it completes.",
+							"Set to true to run in background. Returns an agent ID immediately; completion automatically wakes you with a result preview.",
 					}),
 				),
 				resume: Type.Optional(
 					Type.String({
-						description: "Optional agent ID to resume from. Continues from previous context.",
+						description:
+							"Agent ID of a retained, finished session to continue with the same conversation history. Omit to start a new context.",
 					}),
 				),
 				inherit_context: Type.Optional(

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

@@ -52,13 +52,17 @@ export function spawnBackground(
     `Agent ${isQueued ? "queued" : "started"} in background.\n` +
       `Agent ID: ${id}\n` +
       `Type: ${identity.displayName}\n` +
+      `Model: ${presentation.modelName}\n` +
+      `Runtime: 0.0s\n` +
       `Description: ${execution.description}\n` +
+      (identity.fellBack ? `Fallback: requested ${identity.rawType}; using ${identity.subagentType}\n` : "") +
       (record?.outputFile ? `Output file: ${record.outputFile}\n` : "") +
       (isQueued
         ? `Position: queued (max ${params.settings.maxConcurrent} concurrent)\n`
         : "") +
-      `\nYou will be notified when this agent completes.\n` +
-      `Use get_subagent_result to retrieve full results, or steer_subagent to send it messages.\n` +
+      `\nCompletion will automatically notify and wake you with a result preview. Continue other work; do not poll.\n` +
+      `Use steer_subagent to redirect this agent while it runs.\n` +
+      `Use get_subagent_result only for full output, verbose conversation, an explicit status check or synchronization point, or recovery after a missed notification.\n` +
       `Do not duplicate this agent's work.`,
     {
       ...presentation.detailBase,

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

@@ -111,22 +111,31 @@ export async function runForeground(
 
   clearInterval(spinnerInterval);
 
+  // Foreground delivery returns the complete outcome inline, so retention can
+  // use the shorter consumed-session window.
+  record.markConsumed();
+
   const tokenText = formatLifetimeTokens(record);
   const details = buildDetails(presentation.detailBase, record, { tokens: tokenText });
 
   const fallbackNote = identity.fellBack
-    ? `Note: Unknown agent type "${identity.rawType}" — using general-purpose.\n\n`
+    ? `Note: Unknown agent type "${identity.rawType}" — using ${identity.subagentType}.\n\n`
     : "";
 
   if (record.status === "error") {
-    return textResult(`${fallbackNote}Agent failed: ${record.error}`, details);
+    const partial = record.result?.trim();
+    return textResult(
+      `${fallbackNote}Model: ${record.modelLabel}\nRuntime: ${formatMs(details.durationMs)}\nAgent failed: ${record.error}` +
+        (partial ? `\n\nPartial output before the failure:\n${partial}` : ""),
+      details,
+    );
   }
 
   const durationMs = (record.completedAt ?? Date.now()) - record.startedAt;
   const statsParts = [`${record.toolUses} tool uses`];
   if (tokenText) statsParts.push(tokenText);
   return textResult(
-    `${fallbackNote}Agent completed in ${formatMs(durationMs)} (${statsParts.join(", ")})${getStatusNote(record.status)}.\n\n` +
+    `${fallbackNote}Model: ${record.modelLabel}\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

@@ -13,6 +13,7 @@ import type { SubagentStatus } from "#src/lifecycle/subagent";
 export interface AgentReport {
 	id: string;
 	displayName: string;
+	modelLabel: string;
 	status: SubagentStatus;
 	toolUses: number;
 	/** Pre-formatted lifetime token total; "" when zero. */
@@ -24,8 +25,11 @@ export interface AgentReport {
 	description: string;
 	result: string | undefined;
 	error: string | undefined;
+	stoppedWhileQueued: boolean;
 	/** Present only when verbose was requested and a conversation is available. */
 	conversation?: string;
+	/** Persisted transcript remains readable after the live session is released. */
+	transcriptPath?: string;
 }
 
 /** Assemble the stats parts: Tool uses / tokens? / Context? / Compactions? / Duration. */
@@ -40,9 +44,18 @@ export function renderStatsParts(report: AgentReport): string[] {
 
 /** Select the per-status body: running note, error line, or trimmed result. */
 export function renderReportBody(report: AgentReport): string {
+	if (report.status === "queued")
+		return "Agent is queued and has not started. Use wait: true to synchronize, or rely on the automatic completion notification.";
 	if (report.status === "running")
-		return "Agent is still running. Use wait: true or check back later.";
-	if (report.status === "error") return `Error: ${report.error}`;
+		return "Agent is still running. Use wait: true to synchronize, or rely on the automatic completion notification.";
+	if (report.stoppedWhileQueued)
+		return "Agent was stopped while queued and never started. No work was performed.";
+	if (report.status === "error") {
+		const partial = report.result?.trim();
+		return partial
+			? `Error: ${report.error}\n\nPartial output before the failure:\n${partial}`
+			: `Error: ${report.error}`;
+	}
 	return report.result?.trim() ?? "No output.";
 }
 
@@ -50,11 +63,12 @@ export function renderReportBody(report: AgentReport): string {
 export function formatAgentReport(report: AgentReport): string {
 	let output =
 		`Agent: ${report.id}\n` +
-		`Type: ${report.displayName} | Status: ${report.status} | ${renderStatsParts(report).join(" | ")}\n` +
+		`Type: ${report.displayName} | Model: ${report.modelLabel} | Status: ${report.status} | ${renderStatsParts(report).join(" | ")}\n` +
 		`Description: ${report.description}\n\n`;
 	output += renderReportBody(report);
 	if (report.conversation) {
 		output += `\n\n--- Agent Conversation ---\n${report.conversation}`;
 	}
+	if (report.transcriptPath) output += `\n\nFull transcript: ${report.transcriptPath}`;
 	return output;
 }

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

@@ -12,23 +12,18 @@ export interface GetResultToolManager {
 	getRecord(id: string): Subagent | undefined;
 }
 
-export interface GetResultToolNotifications {
-	consume(id: string): void;
-}
-
 // ---- Class ----
 
 export class GetResultTool {
 	constructor(
 		private readonly manager: GetResultToolManager,
-		private readonly notifications: GetResultToolNotifications,
 		private readonly registry: AgentConfigLookup,
 	) {}
 
 	async execute(
 		_toolCallId: string,
 		params: { agent_id: string; wait?: boolean; verbose?: boolean },
-		_signal: AbortSignal,
+		signal: AbortSignal,
 		_onUpdate: unknown,
 		_ctx: unknown,
 	) {
@@ -37,19 +32,12 @@ export class GetResultTool {
 			return textResult(`Agent not found: "${params.agent_id}". It may have been cleaned up.`);
 		}
 
-		// Wait for completion if requested.
-		// Consume BEFORE awaiting: onComplete fires inside .then() (attached
-		// earlier at spawn time) and always runs before this await resumes.
-		// Consuming here prevents a redundant follow-up notification.
-		if (params.wait && record.status === "running" && record.promise) {
-			this.notifications.consume(params.agent_id);
-			await record.promise;
-		}
+		// A queued record is awaitable from spawn, and a resumed record republishes
+		// its live promise. Interrupting this tool stops only the wait.
+		if (params.wait) await record.waitUntilSettled(signal);
 
-		// Consume the settled result — suppresses the completion notification.
-		if (record.status !== "running" && record.status !== "queued") {
-			this.notifications.consume(params.agent_id);
-		}
+		// Pull delivery: only a terminal result was actually collected.
+		if (!record.isActive()) record.markConsumed();
 
 		return textResult(formatAgentReport(this.buildReport(record, params.verbose)));
 	}
@@ -58,6 +46,7 @@ export class GetResultTool {
 		return {
 			id: record.id,
 			displayName: getDisplayName(record.type, this.registry),
+			modelLabel: record.modelLabel,
 			status: record.status,
 			toolUses: record.toolUses,
 			tokens: formatLifetimeTokens(record),
@@ -67,7 +56,9 @@ export class GetResultTool {
 			description: record.description,
 			result: record.result,
 			error: record.error,
+			stoppedWhileQueued: record.stoppedWhileQueued,
 			conversation: verbose ? record.getConversation() : undefined,
+			transcriptPath: record.outputFile,
 		};
 	}
 
@@ -76,9 +67,11 @@ export class GetResultTool {
 			name: "get_subagent_result" as const,
 			label: "Get Agent Result",
 			promptSnippet:
-				"get_subagent_result: Check status and retrieve results from a background agent.",
+				"get_subagent_result: Inspect status or retrieve full results from a background agent.",
 			description:
-				"Check status and retrieve results from a background agent. Use the agent ID returned by Agent with run_in_background.",
+				"Background completion automatically wakes you with a result preview, so do not poll. " +
+				"Use this tool only for full output, verbose conversation, an explicit status check or synchronization point, " +
+				"or recovery after a missed notification.",
 			parameters: Type.Object({
 				agent_id: Type.String({
 					description: "The agent ID to check.",

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

@@ -33,14 +33,17 @@ export function renderAgentResult(
 export function renderRunning(details: AgentDetails, theme: Theme): string {
 	const frame = SPINNER[details.spinnerFrame ?? 0];
 	const s = renderStats(details, theme);
+	const duration = theme.fg("dim", formatMs(details.durationMs));
 	let line = theme.fg("accent", frame) + (s ? " " + s : "");
+	line += `${s ? " " + theme.fg("dim", "·") + " " : " "}${duration}`;
 	line += "\n" + theme.fg("dim", `  ⎿  ${details.activity ?? "thinking\u2026"}`);
 	return line;
 }
 
 /** Render background launch status. */
 export function renderBackground(details: AgentDetails, theme: Theme): string {
-	return theme.fg("dim", `  \u23BF  Running in background (ID: ${details.agentId})`);
+	const identity = [details.modelName, formatMs(details.durationMs)].filter(Boolean).join(" · ");
+	return theme.fg("dim", `  \u23BF  Running in background (ID: ${details.agentId}) · ${identity}`);
 }
 
 /** Render completed or steered status with optional expanded result text. */
@@ -83,6 +86,7 @@ export function renderCompleted(
 export function renderStopped(details: AgentDetails, theme: Theme): string {
 	const s = renderStats(details, theme);
 	let line = theme.fg("dim", "\u25A0") + (s ? " " + s : "");
+	line += ` ${theme.fg("dim", "·")} ${theme.fg("dim", formatMs(details.durationMs))}`;
 	line += "\n" + theme.fg("dim", "  \u23BF  Stopped");
 	return line;
 }
@@ -91,6 +95,7 @@ export function renderStopped(details: AgentDetails, theme: Theme): string {
 export function renderFailed(details: AgentDetails, theme: Theme): string {
 	const s = renderStats(details, theme);
 	let line = theme.fg("error", "\u2717") + (s ? " " + s : "");
+	line += ` ${theme.fg("dim", "·")} ${theme.fg("dim", formatMs(details.durationMs))}`;
 
 	if (details.status === "error") {
 		line += "\n" + theme.fg("error", `  \u23BF  Error: ${details.error ?? "unknown"}`);

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

@@ -7,10 +7,12 @@
  */
 
 import type { Model } from "@earendil-works/pi-ai";
+import { resolveDispatchAgentType } from "#src/config/agent-type-resolution";
 import type { AgentTypeRegistry } from "#src/config/agent-types";
 import { resolveAgentInvocationConfig } from "#src/config/invocation-config";
 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 type { AgentInvocation, SubagentType, ThinkingLevel } from "#src/types";
 import {
@@ -75,18 +77,21 @@ export function resolveSpawnConfig(
   params: Record<string, unknown>,
   registry: AgentTypeRegistry,
   modelInfo: ModelInfo,
-  settings: { readonly defaultMaxTurns: number | undefined },
+  settings: {
+    readonly defaultMaxTurns: number | undefined;
+    readonly fallbackSubagent?: string | false;
+  },
 ): ResolvedSpawnConfig | SpawnConfigError {
   const rawType = params.subagent_type as SubagentType;
-  const resolved = registry.resolveType(rawType);
-
-  // A known-but-disabled type is an explicit error, not a silent unknown-type fallback.
-  if (resolved !== undefined && !registry.isValidType(resolved)) {
-    return { error: `Agent type "${resolved}" is disabled` };
-  }
+  const typeResolution = resolveDispatchAgentType(
+    rawType,
+    registry,
+    settings.fallbackSubagent,
+  );
+  if ("error" in typeResolution) return typeResolution;
 
-  const subagentType = resolved ?? "general-purpose";
-  const fellBack = resolved === undefined;
+  const subagentType = typeResolution.type;
+  const fellBack = typeResolution.fellBack;
 
   const displayName = getDisplayName(subagentType, registry);
 
@@ -108,13 +113,8 @@ export function resolveSpawnConfig(
   const inheritContext = resolvedConfig.inheritContext;
   const runInBackground = resolvedConfig.runInBackground;
 
-  // Compute display model name (only shown when different from parent)
-  const parentModelId = modelInfo.parentModel?.id;
-  const effectiveModelId = model?.id;
-  const modelName =
-    effectiveModelId && effectiveModelId !== parentModelId
-      ? model.name.replace(/^Claude\s+/i, "").toLowerCase()
-      : undefined;
+  // Every status surface shows the exact effective model, including inheritance.
+  const modelName = formatModelLabel(model);
 
   const effectiveMaxTurns = normalizeMaxTurns(
     resolvedConfig.maxTurns ?? settings.defaultMaxTurns,

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

@@ -2,6 +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";
 
 // ---- Deps interfaces ----
 
@@ -40,19 +41,22 @@ export class SteerTool {
 			outcome = await record.steer(params.message);
 		} catch (err) {
 			return textResult(
-				`Failed to steer agent: ${err instanceof Error ? err.message : String(err)}`,
+				`Failed to steer agent: ${err instanceof Error ? err.message : String(err)}\n`
+					+ this.renderRunIdentity(record),
 			);
 		}
 
 		switch (outcome.kind) {
 			case "rejected":
 				return textResult(
-					`Agent "${params.agent_id}" is not running (status: ${outcome.status}). Cannot steer a non-running agent.`,
+					`Agent "${params.agent_id}" is not running (status: ${outcome.status}). Cannot steer a non-running agent.\n`
+						+ this.renderRunIdentity(record),
 				);
 			case "buffered":
 				this.events.emit("subagents:steered", { id: record.id, message: params.message });
 				return textResult(
-					`Steering message queued for agent ${record.id}. It will be delivered once the session initializes.`,
+					`Steering message queued for agent ${record.id}. It will be delivered once the session initializes.\n`
+						+ this.renderRunIdentity(record),
 				);
 			case "delivered":
 				this.events.emit("subagents:steered", { id: record.id, message: params.message });
@@ -64,7 +68,7 @@ export class SteerTool {
 	private renderDelivered(record: Subagent) {
 		const tokens = formatLifetimeTokens(record);
 		const contextPercent = record.getContextPercent();
-		const stateParts: string[] = [];
+		const stateParts: string[] = [record.modelLabel, formatDuration(record.startedAt, record.completedAt)];
 		if (tokens) stateParts.push(tokens);
 		stateParts.push(`${record.toolUses} tool ${record.toolUses === 1 ? "use" : "uses"}`);
 		if (contextPercent !== null)
@@ -79,6 +83,10 @@ export class SteerTool {
 		);
 	}
 
+	private renderRunIdentity(record: Subagent): string {
+		return `Model: ${record.modelLabel}\nRuntime: ${formatDuration(record.startedAt, record.completedAt)}`;
+	}
+
 	toToolDefinition() {
 		return defineTool({
 			name: "steer_subagent" as const,

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

@@ -63,11 +63,11 @@ export interface AgentConfig extends AgentIdentity, AgentPromptConfig {
   /** false = agent is hidden from the registry */
   enabled?: boolean;
   /** Where this agent was loaded from */
-  source?: "default" | "project" | "global";
+  source?: "default" | "project" | "shared-project" | "global";
 }
 
 export interface AgentInvocation {
-  /** Short display name, e.g. "haiku" — only set when different from parent. */
+  /** Exact effective model label in `provider/id` form. */
   modelName?: string;
   thinking?: ThinkingLevel;
   maxTurns?: number;

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

@@ -10,7 +10,7 @@ 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 { CompactionInfo } from "#src/types";
-import { ERROR_STATUSES, type Theme } from "#src/ui/display";
+import { ERROR_STATUSES, formatMs, type Theme } from "#src/ui/display";
 import { renderWidgetLines, type WidgetAgent } from "#src/ui/widget-renderer";
 
 // ---- Types ----
@@ -51,6 +51,25 @@ export function assembleWidgetState(
   return { runningCount, queuedCount, hasFinished, hasActive };
 }
 
+/** Render the aggregate status bar without hiding per-agent model/runtime details. */
+export function formatStatusBar(
+  state: WidgetState,
+  agents: readonly Pick<Subagent, "status" | "modelLabel" | "startedAt">[],
+  now = Date.now(),
+): string | undefined {
+  if (!state.hasActive) return undefined;
+  const statusParts: string[] = [];
+  if (state.runningCount > 0) statusParts.push(`${state.runningCount} running`);
+  if (state.queuedCount > 0) statusParts.push(`${state.queuedCount} queued`);
+  const total = state.runningCount + state.queuedCount;
+  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`);
+  return `${statusParts.join(", ")} agent${total === 1 ? "" : "s"} · ${activeDetails.join(", ")}`;
+}
+
 export type UICtx = {
   setStatus(key: string, text: string | undefined): void;
   setWidget(
@@ -165,6 +184,7 @@ export class AgentWidget implements SubagentManagerObserver {
       type: record.type,
       status: record.status,
       description: record.description,
+      modelLabel: record.modelLabel,
       toolUses: record.toolUses,
       startedAt: record.startedAt,
       completedAt: record.completedAt,
@@ -216,15 +236,8 @@ export class AgentWidget implements SubagentManagerObserver {
    * Compute the status bar text from the current widget state and call
    * `setStatus` only when it differs from the last cached value.
    */
-  private updateStatusBar(state: WidgetState): void {
-    let newStatusText: string | undefined;
-    if (state.hasActive) {
-      const statusParts: string[] = [];
-      if (state.runningCount > 0) statusParts.push(`${state.runningCount} running`);
-      if (state.queuedCount > 0) statusParts.push(`${state.queuedCount} queued`);
-      const total = state.runningCount + state.queuedCount;
-      newStatusText = `${statusParts.join(", ")} agent${total === 1 ? "" : "s"}`;
-    }
+  private updateStatusBar(state: WidgetState, agents: readonly Subagent[]): void {
+    const newStatusText = formatStatusBar(state, agents);
     if (newStatusText !== this.lastStatusText) {
       this.uiCtx!.setStatus("subagents", newStatusText);
       this.lastStatusText = newStatusText;
@@ -259,7 +272,7 @@ export class AgentWidget implements SubagentManagerObserver {
       return;
     }
 
-    this.updateStatusBar(state);
+    this.updateStatusBar(state, backgroundAgents);
     this.widgetFrame++;
 
     // Register widget callback once; subsequent updates use requestRender()

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

@@ -6,6 +6,7 @@
  */
 
 import type { AgentConfigLookup } from "#src/config/agent-types";
+import { GLYPHS } from "#src/ui/glyphs";
 import type { AgentInvocation, SubagentType } from "#src/types";
 
 // ---- Types ----
@@ -28,7 +29,7 @@ export interface AgentDetails {
   activity?: string;
   /** Current spinner frame index (for animated running indicator). */
   spinnerFrame?: number;
-  /** Short model name if different from parent (e.g. "haiku", "sonnet"). */
+  /** Exact effective model label in `provider/id` form. */
   modelName?: string;
   /** Notable config tags (e.g. ["thinking: high", "inherit context"]). */
   tags?: string[];
@@ -71,12 +72,12 @@ export function formatTokens(count: number): string {
 /**
  * Token count with optional context-fill % and compaction-count annotations.
  * Thresholds for percent: <70% dim, 70–85% warning, ≥85% error.
- * Compaction count rendered as `↻N` in dim.
+ * Compaction count rendered as `⇊N` in dim.
  *
  *   "12.3k token"               — no annotations
  *   "12.3k token (45%)"         — percent only
- *   "12.3k token (↻2)"          — compactions only (e.g. right after compact)
- *   "12.3k token (45% · ↻2)"    — both
+ *   "12.3k token (⇊2)"          — compactions only (e.g. right after compact)
+ *   "12.3k token (45% · ⇊2)"    — both
  */
 export function formatSessionTokens(
   tokens: number,
@@ -91,16 +92,18 @@ export function formatSessionTokens(
     annot.push(theme.fg(color, `${Math.round(percent)}%`));
   }
   if (compactions > 0) {
-    annot.push(theme.fg("dim", `↻${compactions}`));
+    annot.push(theme.fg("dim", `${GLYPHS.compactions}${compactions}`));
   }
   if (annot.length === 0) return tokenStr;
   const sep = theme.fg("dim", " · ");
   return `${tokenStr} ${theme.fg("dim", "(")}${annot.join(sep)}${theme.fg("dim", ")")}`;
 }
 
-/** Format turn count with optional max limit: "⟳5≤30" or "⟳5". */
+/** Format turn count with optional max limit: "↻5≤30" or "↻5". */
 export function formatTurns(turnCount: number, maxTurns?: number | null): string {
-  return maxTurns != null ? `⟳${turnCount}≤${maxTurns}` : `⟳${turnCount}`;
+  return maxTurns != null
+    ? `${GLYPHS.turns}${turnCount}≤${maxTurns}`
+    : `${GLYPHS.turns}${turnCount}`;
 }
 
 /** Format milliseconds as human-readable duration. */

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

@@ -0,0 +1,7 @@
+/** Terminal-safe semantic glyphs shared by status renderers. */
+export const GLYPHS = {
+  /** Turn count, as `↻5≤30`. */
+  turns: "↻",
+  /** Session compaction count. */
+  compactions: "⇊",
+} as const;