@gotgenes/pi-subagents 16.4.0 → 16.6.0

package/src/index.ts

@@ -62,7 +62,6 @@ export default function (pi: ExtensionAPI) {
   // widget dependency — keeping the construction graph a cycle-free DAG.
   const notifications = new NotificationManager(
     (msg, opts) => pi.sendMessage(msg, opts),
-    runtime.agentActivity,
   );
 
   // Settings: owns all three in-memory values and handles load/save/emit.
@@ -130,7 +129,7 @@ export default function (pi: ExtensionAPI) {
 
   // Live widget: constructed after the manager (it polls listAgents()) and
   // injected directly into its consumers — no post-construction field write.
-  const widget = new AgentWidget(manager, runtime.agentActivity, registry);
+  const widget = new AgentWidget(manager, registry);
 
   // Grab UI context from first tool execution + clear lingering widget on new turn
   const toolStart = new ToolStartHandler(widget);
@@ -157,7 +156,6 @@ export default function (pi: ExtensionAPI) {
   const agentsMenu = new AgentsMenuHandler(
     manager,
     registry,
-    runtime.agentActivity,
     settings,
     new FsAgentFileOps(),
     join(getAgentDir(), "agents"),

package/src/lifecycle/subagent-state.ts

@@ -1,10 +1,13 @@
 /**
- * subagent-state.ts — SubagentState value object: lifecycle status and metrics.
+ * subagent-state.ts — SubagentState value object: lifecycle status, metrics, and live activity.
  *
  * Owns the passive, readable state of a subagent — status, result, error,
- * timestamps, and stats (toolUses, lifetimeUsage, compactionCount) — together
- * with the transition methods (markRunning, markCompleted, …) and accumulation
- * methods (incrementToolUses, addUsage, incrementCompactions) that mutate it.
+ * timestamps, stats (toolUses, lifetimeUsage, compactionCount), and live-activity
+ * fields (turnCount, activeTools, responseText) — together with the transition
+ * methods (markRunning, markCompleted, …), accumulation methods
+ * (incrementToolUses, addUsage, incrementCompactions), and live-activity
+ * transition methods (incrementTurnCount, addActiveTool, removeActiveTool,
+ * resetResponseText, appendResponseText) that mutate them.
  *
  * State is encapsulated behind getters; external code reads through them but
  * mutates only via the transition/accumulation methods. The value object owns
@@ -62,6 +65,18 @@ export class SubagentState {
 	private _compactionCount = 0;
 	get compactionCount(): number { return this._compactionCount; }
 
+	// Live activity — accumulated via transition methods, readable via getters
+	private _turnCount = 1;
+	get turnCount(): number { return this._turnCount; }
+
+	private _activeTools = new Map<string, string>();
+	get activeTools(): ReadonlyMap<string, string> { return this._activeTools; }
+
+	private _toolKeySeq = 0;
+
+	private _responseText = "";
+	get responseText(): string { return this._responseText; }
+
 	constructor(init: SubagentStateInit = {}) {
 		this._status = init.status ?? "queued";
 		this._result = init.result;
@@ -85,6 +100,36 @@ export class SubagentState {
 		this._compactionCount++;
 	}
 
+	/** Record a turn boundary. Called by record-observer on turn_end. */
+	incrementTurnCount(): void {
+		this._turnCount++;
+	}
+
+	/** Record a tool starting. Called by record-observer on tool_execution_start. */
+	addActiveTool(toolName: string): void {
+		this._activeTools.set(toolName + "_" + (++this._toolKeySeq), toolName);
+	}
+
+	/** Remove one active tool by name (first match). Called by record-observer on tool_execution_end. */
+	removeActiveTool(toolName: string): void {
+		for (const [key, name] of this._activeTools) {
+			if (name === toolName) {
+				this._activeTools.delete(key);
+				break;
+			}
+		}
+	}
+
+	/** Reset the current response text. Called by record-observer on message_start. */
+	resetResponseText(): void {
+		this._responseText = "";
+	}
+
+	/** Append a text delta to the current response text. Called by record-observer on message_update. */
+	appendResponseText(delta: string): void {
+		this._responseText += delta;
+	}
+
 	/** Transition to running state. Sets status and startedAt. */
 	markRunning(startedAt: number): void {
 		this._status = "running";

package/src/lifecycle/subagent.ts

@@ -94,6 +94,10 @@ export class Subagent {
 	get toolUses(): number { return this.state.toolUses; }
 	get lifetimeUsage(): Readonly<LifetimeUsage> { return this.state.lifetimeUsage; }
 	get compactionCount(): number { return this.state.compactionCount; }
+	get turnCount(): number { return this.state.turnCount; }
+	get activeTools(): ReadonlyMap<string, string> { return this.state.activeTools; }
+	get responseText(): string { return this.state.responseText; }
+	get maxTurns(): number | undefined { return this.execution.maxTurns; }
 
 	readonly abortController: AbortController;
 	private _promise?: Promise<void>;

package/src/observation/notification.ts

@@ -1,7 +1,6 @@
 import { debugLog } from "#src/debug";
 import { getLifetimeTotal } from "#src/lifecycle/usage";
 import type { Subagent } from "#src/types";
-import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 
 /** Details attached to custom notification messages for visual rendering. */
 export interface NotificationDetails {
@@ -77,7 +76,6 @@ export function formatTaskNotification(record: Subagent, resultMaxLen: number):
 export function buildNotificationDetails(
   record: Subagent,
   resultMaxLen: number,
-  activity?: AgentActivityTracker,
 ): NotificationDetails {
   const totalTokens = getLifetimeTotal(record.lifetimeUsage);
 
@@ -86,8 +84,8 @@ export function buildNotificationDetails(
     description: record.description,
     status: record.status,
     toolUses: record.toolUses,
-    turnCount: activity?.turnCount ?? 0,
-    maxTurns: activity?.maxTurns,
+    turnCount: record.turnCount,
+    maxTurns: record.maxTurns,
     totalTokens,
     durationMs: record.completedAt ? record.completedAt - record.startedAt : 0,
     outputFile: record.outputFile,
@@ -127,7 +125,6 @@ export function buildEventData(record: Subagent) {
 export interface NotificationSystem {
   cancelNudge: (key: string) => void;
   sendCompletion: (record: Subagent) => void;
-  cleanupCompleted: (id: string) => void;
   dispose: () => void;
 }
 
@@ -141,7 +138,6 @@ export class NotificationManager implements NotificationSystem {
       msg: { customType: string; content: string; display: boolean; details?: unknown },
       opts?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" | "nextTurn" },
     ) => void,
-    private agentActivity: Map<string, AgentActivityTracker>,
   ) {}
 
   cancelNudge(key: string): void {
@@ -153,14 +149,9 @@ export class NotificationManager implements NotificationSystem {
   }
 
   sendCompletion(record: Subagent): void {
-    this.agentActivity.delete(record.id);
     this.scheduleNudge(record.id, () => this.emitIndividualNudge(record));
   }
 
-  cleanupCompleted(id: string): void {
-    this.agentActivity.delete(id);
-  }
-
   dispose(): void {
     for (const timer of this.pendingNudges.values()) clearTimeout(timer);
     this.pendingNudges.clear();
@@ -193,7 +184,7 @@ export class NotificationManager implements NotificationSystem {
         customType: "subagent-notification",
         content: notification + footer,
         display: true,
-        details: buildNotificationDetails(record, 500, this.agentActivity.get(record.id)),
+        details: buildNotificationDetails(record, 500),
       },
       { deliverAs: "followUp", triggerTurn: true },
     );

package/src/observation/record-observer.ts

@@ -18,8 +18,12 @@ export interface SubagentObserverOptions {
  * Subscribe to session events and accumulate stats on the subagent state.
  *
  * Handles:
- * - `tool_execution_end` → `state.incrementToolUses()`
+ * - `tool_execution_start` → `state.addActiveTool(name)`
+ * - `tool_execution_end` → `state.removeActiveTool(name)`, `state.incrementToolUses()`
+ * - `message_start` → `state.resetResponseText()`
+ * - `message_update` (text_delta) → `state.appendResponseText(delta)`
  * - `message_end` (assistant, with usage) → `state.addUsage(…)`
+ * - `turn_end` → `state.incrementTurnCount()`
  * - `compaction_end` (not aborted) → `state.incrementCompactions()`, call `onCompact`
  *
  * @returns An unsubscribe function.
@@ -30,10 +34,30 @@ export function subscribeSubagentObserver(
   options?: SubagentObserverOptions,
 ): () => void {
   return session.subscribe((event) => {
+    if (event.type === "tool_execution_start") {
+      state.addActiveTool(event.toolName);
+    }
+
     if (event.type === "tool_execution_end") {
+      state.removeActiveTool(event.toolName);
       state.incrementToolUses();
     }
 
+    if (event.type === "message_start") {
+      state.resetResponseText();
+    }
+
+    if (
+      event.type === "message_update" &&
+      event.assistantMessageEvent.type === "text_delta"
+    ) {
+      state.appendResponseText(event.assistantMessageEvent.delta);
+    }
+
+    if (event.type === "turn_end") {
+      state.incrementTurnCount();
+    }
+
     if (event.type === "message_end" && event.message.role === "assistant") {
       const u = event.message.usage;
       state.addUsage({

package/src/observation/subagent-events-observer.ts

@@ -65,10 +65,7 @@ export class SubagentEventsObserver implements SubagentManagerObserver {
 		});
 
 		// Skip notification if result was already consumed via get_subagent_result.
-		if (record.notification?.resultConsumed) {
-			this.notifications.cleanupCompleted(record.id);
-			return;
-		}
+		if (record.notification?.resultConsumed) return;
 
 		this.notifications.sendCompletion(record);
 	}

package/src/tools/foreground-runner.ts

@@ -70,11 +70,15 @@ export async function runForeground(
       ...presentation.detailBase,
       toolUses,
       tokens: recordRef ? formatLifetimeTokens(recordRef) : "",
-      turnCount: fgState.turnCount,
-      maxTurns: fgState.maxTurns,
+      // Read activity off the record; fall back to safe defaults before onSessionCreated fires
+      turnCount: recordRef?.turnCount ?? 1,
+      maxTurns: recordRef?.maxTurns ?? execution.effectiveMaxTurns,
       durationMs: Date.now() - startedAt,
       status: "running",
-      activity: describeActivity(fgState.activeTools, fgState.responseText),
+      activity: describeActivity(
+        recordRef?.activeTools ?? new Map(),
+        recordRef?.responseText ?? "",
+      ),
       spinnerFrame: spinnerFrame % SPINNER.length,
     };
     onUpdate?.({
@@ -136,7 +140,7 @@ export async function runForeground(
   }
 
   const tokenText = formatLifetimeTokens(record);
-  const details = buildDetails(presentation.detailBase, record, fgState, { tokens: tokenText });
+  const details = buildDetails(presentation.detailBase, record, { tokens: tokenText });
 
   const fallbackNote = identity.fellBack
     ? `Note: Unknown agent type "${identity.rawType}" — using general-purpose.\n\n`

package/src/tools/helpers.ts

@@ -1,6 +1,5 @@
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import { getLifetimeTotal, type LifetimeUsage } from "#src/lifecycle/usage";
-import { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import { type AgentDetails, formatTokens } from "#src/ui/display";
 
 /** Parenthetical status note for completed agent result text. */
@@ -28,16 +27,18 @@ export function buildDetails(
     error?: string;
     id?: string;
     lifetimeUsage: LifetimeUsage;
+    /** Live-activity counters — exposed as getters on Subagent (Phase 18 Step 2). */
+    turnCount?: number;
+    maxTurns?: number;
   },
-  activity?: AgentActivityTracker,
   overrides?: Partial<AgentDetails>,
 ): AgentDetails {
   return {
     ...base,
     toolUses: record.toolUses,
     tokens: formatLifetimeTokens(record),
-    turnCount: activity?.turnCount,
-    maxTurns: activity?.maxTurns,
+    turnCount: record.turnCount,
+    maxTurns: record.maxTurns,
     durationMs: (record.completedAt ?? Date.now()) - record.startedAt,
     status: record.status as AgentDetails["status"],
     agentId: record.id,

package/src/ui/agent-menu.ts

@@ -5,7 +5,6 @@ import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import { type ModelRegistry, resolveModel } from "#src/session/model-resolver";
 import { getModelLabelFromConfig } from "#src/tools/helpers";
 import type { AgentConfig, Subagent } from "#src/types";
-import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import { AgentConfigEditor } from "#src/ui/agent-config-editor";
 import { AgentCreationWizard } from "#src/ui/agent-creation-wizard";
 import type { AgentFileOps } from "#src/ui/agent-file-ops";
@@ -36,14 +35,6 @@ export interface AgentMenuSettings {
   applyGraceTurns(n: number): { message: string; level: "info" | "warning" };
 }
 
-/**
- * Read-only interface for the agent-menu's agentActivity access.
- * Only the conversation viewer needs to read a tracker by agent ID.
- */
-export interface AgentActivityReader {
-  get(id: string): AgentActivityTracker | undefined;
-}
-
 // ---- Narrow UI context types ----
 
 /** Narrow UI interface — only the ctx.ui methods menu handlers actually call. */
@@ -70,7 +61,6 @@ export class AgentsMenuHandler {
   constructor(
     private readonly manager: AgentMenuManager,
     private readonly registry: AgentTypeRegistry,
-    private readonly agentActivity: AgentActivityReader,
     private readonly settings: AgentMenuSettings,
     fileOps: AgentFileOps,
     personalAgentsDir: string,
@@ -263,14 +253,12 @@ export class AgentsMenuHandler {
     const { ConversationViewer, VIEWPORT_HEIGHT_PCT } = await import(
       "./conversation-viewer"
     );
-    const activity = this.agentActivity.get(record.id);
 
     await ui.custom<undefined>(
       (tui: any, theme: any, _keybindings: any, done: any) => {
         return new ConversationViewer({
           tui,
           record,
-          activity,
           theme,
           done,
           registry: this.registry,

package/src/ui/agent-widget.ts

@@ -7,10 +7,10 @@
  */
 
 import { AgentTypeRegistry } from "#src/config/agent-types";
+import type { Subagent } from "#src/lifecycle/subagent";
 import type { SubagentManager } from "#src/lifecycle/subagent-manager";
-import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import { ERROR_STATUSES, type Theme } from "#src/ui/display";
-import { renderWidgetLines } from "#src/ui/widget-renderer";
+import { renderWidgetLines, type WidgetAgent } from "#src/ui/widget-renderer";
 
 // ---- Types ----
 
@@ -79,7 +79,6 @@ export class AgentWidget {
 
   constructor(
     private manager: SubagentManager,
-    private agentActivity: Map<string, AgentActivityTracker>,
     private registry: AgentTypeRegistry,
   ) {}
 
@@ -129,11 +128,31 @@ export class AgentWidget {
     }
   }
 
+  /** Project a live Subagent record onto a pure-data WidgetAgent snapshot. */
+  private toWidgetAgent(record: Subagent): WidgetAgent {
+    return {
+      id: record.id,
+      type: record.type,
+      status: record.status,
+      description: record.description,
+      toolUses: record.toolUses,
+      startedAt: record.startedAt,
+      completedAt: record.completedAt,
+      error: record.error,
+      lifetimeUsage: record.lifetimeUsage,
+      compactionCount: record.compactionCount,
+      turnCount: record.turnCount,
+      maxTurns: record.maxTurns,
+      activeTools: record.activeTools,
+      responseText: record.responseText,
+      contextPercent: record.getContextPercent(),
+    };
+  }
+
   /** Delegate rendering to the pure widget-renderer module. */
   private renderWidget(tui: any, theme: Theme): string[] {
     return renderWidgetLines({
-      agents: this.manager.listAgents(),
-      activityMap: this.agentActivity,
+      agents: this.manager.listAgents().map(r => this.toWidgetAgent(r)),
       registry: this.registry,
       spinnerFrame: this.widgetFrame,
       terminalWidth: tui.terminal.columns,

package/src/ui/conversation-viewer.ts

@@ -9,7 +9,6 @@ import { type Component, matchesKey, type TUI, truncateToWidth, visibleWidth } f
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import { getLifetimeTotal } from "#src/lifecycle/usage";
 import type { Subagent } from "#src/types";
-import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import { buildInvocationTags, formatDuration, formatSessionTokens, getDisplayName, getPromptModeLabel, type Theme } from "#src/ui/display";
 import { formatMessage, formatStreamingIndicator } from "#src/ui/message-formatters";
 
@@ -24,7 +23,6 @@ export const VIEWPORT_HEIGHT_PCT = 70;
 export interface ConversationViewerOptions {
   tui: TUI;
   record: Subagent;
-  activity: AgentActivityTracker | undefined;
   theme: Theme;
   done: (result: undefined) => void;
   registry: AgentConfigLookup;
@@ -40,7 +38,6 @@ export class ConversationViewer implements Component {
 
   private tui: TUI;
   private record: Subagent;
-  private activity: AgentActivityTracker | undefined;
   private theme: Theme;
   private done: (result: undefined) => void;
   private registry: AgentConfigLookup;
@@ -49,7 +46,6 @@ export class ConversationViewer implements Component {
   constructor({
     tui,
     record,
-    activity,
     theme,
     done,
     registry,
@@ -57,7 +53,6 @@ export class ConversationViewer implements Component {
   }: ConversationViewerOptions) {
     this.tui = tui;
     this.record = record;
-    this.activity = activity;
     this.theme = theme;
     this.done = done;
     this.registry = registry;
@@ -231,11 +226,11 @@ export class ConversationViewer implements Component {
       needsSeparator = true;
     }
 
-    // Streaming indicator for running agents
-    if (this.record.status === "running" && this.activity) {
+    // Streaming indicator for running agents — read activity off the record
+    if (this.record.status === "running") {
       lines.push(...formatStreamingIndicator(
-        this.activity.activeTools,
-        this.activity.responseText,
+        this.record.activeTools,
+        this.record.responseText,
         width,
         th,
       ));

package/src/ui/widget-renderer.ts

@@ -7,8 +7,8 @@
 
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { AgentConfigLookup } from "#src/config/agent-types";
-import type { LifetimeUsage, SessionLike } from "#src/lifecycle/usage";
-import { getLifetimeTotal, getSessionContextPercent } from "#src/lifecycle/usage";
+import type { LifetimeUsage } from "#src/lifecycle/usage";
+import { getLifetimeTotal } from "#src/lifecycle/usage";
 import type { SubagentType } from "#src/types";
 import {
 	describeActivity,
@@ -35,15 +35,13 @@ export interface WidgetAgent {
 	readonly error?: string;
 	readonly lifetimeUsage?: Readonly<LifetimeUsage>;
 	readonly compactionCount: number;
-}
-
-/** Read-only activity snapshot for widget rendering. */
-export interface WidgetActivity {
-	readonly activeTools: ReadonlyMap<string, string>;
-	readonly responseText: string;
+	// Live activity (folded from the former WidgetActivity — precomputed by AgentWidget)
 	readonly turnCount: number;
 	readonly maxTurns?: number;
-	readonly session?: SessionLike;
+	readonly activeTools: ReadonlyMap<string, string>;
+	readonly responseText: string;
+	/** Context-window utilisation (0–100), or null when unavailable. */
+	readonly contextPercent: number | null;
 }
 
 // ── Per-agent rendering ──────────────────────────────────────────────────────
@@ -51,7 +49,6 @@ export interface WidgetActivity {
 /** Render a single finished agent line (no tree connector prefix). */
 export function renderFinishedLine(
 	agent: WidgetAgent,
-	activity: WidgetActivity | undefined,
 	registry: AgentConfigLookup,
 	theme: Theme,
 ): string {
@@ -81,7 +78,7 @@ export function renderFinishedLine(
 	}
 
 	const parts: string[] = [];
-	if (activity) parts.push(formatTurns(activity.turnCount, activity.maxTurns));
+	parts.push(formatTurns(agent.turnCount, agent.maxTurns));
 	if (agent.toolUses > 0) parts.push(`${agent.toolUses} tool use${agent.toolUses === 1 ? "" : "s"}`);
 	parts.push(duration);
 
@@ -92,7 +89,6 @@ export function renderFinishedLine(
 /** Render a single running agent as header + activity line pair (no tree connector prefix). */
 export function renderRunningLines(
 	agent: WidgetAgent,
-	activity: WidgetActivity | undefined,
 	registry: AgentConfigLookup,
 	spinnerFrame: number,
 	theme: Theme,
@@ -103,18 +99,17 @@ export function renderRunningLines(
 	const elapsed = formatMs(Date.now() - agent.startedAt);
 
 	const tokens = getLifetimeTotal(agent.lifetimeUsage);
-	const contextPercent = activity?.session ? getSessionContextPercent(activity.session) : null;
-	const tokenText = tokens > 0 ? formatSessionTokens(tokens, contextPercent, theme, agent.compactionCount) : "";
+	const tokenText = tokens > 0 ? formatSessionTokens(tokens, agent.contextPercent, theme, agent.compactionCount) : "";
 
 	const parts: string[] = [];
-	if (activity) parts.push(formatTurns(activity.turnCount, activity.maxTurns));
+	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);
 	parts.push(elapsed);
 	const statsText = parts.join(" · ");
 
 	const frame = SPINNER[spinnerFrame % SPINNER.length];
-	const activityText = activity ? describeActivity(activity.activeTools, activity.responseText) : "thinking\u2026";
+	const activityText = describeActivity(agent.activeTools, agent.responseText);
 
 	const header = `${theme.fg("accent", frame)} ${theme.bold(name)}${modeTag}  ${theme.fg("muted", agent.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", statsText)}`;
 	const activityLine = theme.fg("dim", `  \u23BF  ${activityText}`);
@@ -157,7 +152,6 @@ interface WidgetSections {
 /** Render each agent bucket into pre-formatted lines with ├─ tree connectors. */
 function buildSections(
 	categories: AgentCategories,
-	activityMap: ReadonlyMap<string, WidgetActivity>,
 	registry: AgentConfigLookup,
 	spinnerFrame: number,
 	theme: Theme,
@@ -165,12 +159,12 @@ function buildSections(
 ): WidgetSections {
 	const finishedLines: string[] = [];
 	for (const a of categories.finished) {
-		finishedLines.push(truncate(theme.fg("dim", "\u251C\u2500") + " " + renderFinishedLine(a, activityMap.get(a.id), registry, theme)));
+		finishedLines.push(truncate(theme.fg("dim", "\u251C\u2500") + " " + renderFinishedLine(a, registry, theme)));
 	}
 
 	const runningLines: [string, string][] = [];
 	for (const a of categories.running) {
-		const [header, act] = renderRunningLines(a, activityMap.get(a.id), registry, spinnerFrame, theme);
+		const [header, act] = renderRunningLines(a, registry, spinnerFrame, theme);
 		runningLines.push([
 			truncate(theme.fg("dim", "\u251C\u2500") + ` ${header}`),
 			truncate(theme.fg("dim", "\u2502  ") + act),
@@ -259,14 +253,13 @@ function assembleOverflow(
 /** Pure rendering of the widget body. Returns lines to display. */
 export function renderWidgetLines(params: {
 	agents: readonly WidgetAgent[];
-	activityMap: ReadonlyMap<string, WidgetActivity>;
 	registry: AgentConfigLookup;
 	spinnerFrame: number;
 	terminalWidth: number;
 	theme: Theme;
 	shouldShowFinished: (agentId: string, status: string) => boolean;
 }): string[] {
-	const { agents, activityMap, registry, spinnerFrame, terminalWidth, theme, shouldShowFinished } = params;
+	const { agents, registry, spinnerFrame, terminalWidth, theme, shouldShowFinished } = params;
 
 	const { running, queued, finished } = categorizeAgents(agents, shouldShowFinished);
 
@@ -281,7 +274,6 @@ export function renderWidgetLines(params: {
 
 	const { finishedLines, runningLines, queuedLine } = buildSections(
 		{ running, queued, finished },
-		activityMap,
 		registry,
 		spinnerFrame,
 		theme,