@gotgenes/pi-subagents 16.5.0 → 17.0.0

package/src/tools/foreground-runner.ts

@@ -1,7 +1,6 @@
 import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { AgentSpawnConfig } from "#src/lifecycle/subagent-manager";
-import type { AgentActivityAccess } from "#src/tools/agent-tool";
 import {
   buildDetails,
   formatLifetimeTokens,
@@ -10,14 +9,12 @@ import {
 } from "#src/tools/helpers";
 import type { ResolvedSpawnConfig } from "#src/tools/spawn-config";
 import type { ParentSessionInfo, Subagent } from "#src/types";
-import { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import {
   type AgentDetails,
   describeActivity,
   formatMs,
   SPINNER,
 } from "#src/ui/display";
-import { subscribeUIObserver } from "#src/ui/ui-observer";
 
 /** Narrow manager interface for the foreground runner. */
 export interface ForegroundManagerDeps {
@@ -29,12 +26,6 @@ export interface ForegroundManagerDeps {
   ): Promise<Subagent>;
 }
 
-/** Narrow widget interface for the foreground runner. */
-export interface ForegroundWidgetDeps {
-  ensureTimer(): void;
-  markFinished(id: string): void;
-}
-
 /** All values the foreground runner needs beyond the resolved config. */
 export interface ForegroundParams {
   config: ResolvedSpawnConfig;
@@ -44,13 +35,10 @@ export interface ForegroundParams {
 
 /**
  * Run an agent synchronously in the foreground, streaming spinner updates.
- * Owns: spinner interval, AgentActivityTracker creation, UI observer subscription,
- * streaming onUpdate callbacks, cleanup, and result formatting.
+ * Owns: spinner interval, streaming onUpdate callbacks, cleanup, and result formatting.
  */
 export async function runForeground(
   manager: ForegroundManagerDeps,
-  widget: ForegroundWidgetDeps,
-  agentActivity: AgentActivityAccess,
   params: ForegroundParams,
   signal: AbortSignal | undefined,
   onUpdate: ((update: AgentToolResult<any>) => void) | undefined,
@@ -58,10 +46,7 @@ export async function runForeground(
   const { identity, execution, presentation } = params.config;
   let spinnerFrame = 0;
   const startedAt = Date.now();
-  let fgId: string | undefined;
 
-  const fgState = new AgentActivityTracker(execution.effectiveMaxTurns);
-  let unsubUI: (() => void) | undefined;
   let recordRef: Subagent | undefined;
 
   const streamUpdate = () => {
@@ -70,11 +55,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?.({
@@ -109,34 +98,20 @@ export async function runForeground(
         parentSession: params.parentSession,
         observer: {
           onSessionCreated: (agent) => {
-            const sub = agent.subagentSession!;
-            fgState.setSession(sub);
             recordRef = agent;
-            unsubUI = subscribeUIObserver(sub, fgState, streamUpdate);
-            fgId = agent.id;
-            agentActivity.set(agent.id, fgState);
-            widget.ensureTimer();
           },
         },
       },
     );
   } catch (err) {
     clearInterval(spinnerInterval);
-    unsubUI?.();
     return textResult(err instanceof Error ? err.message : String(err));
   }
 
   clearInterval(spinnerInterval);
-  unsubUI?.();
-
-  // Clean up foreground agent from widget
-  if (fgId) {
-    agentActivity.delete(fgId);
-    widget.markFinished(fgId);
-  }
 
   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/types.ts

@@ -12,7 +12,7 @@ export type { AgentSessionEvent, ThinkingLevel };
 
 /**
  * Narrow session interface for event subscription.
- * Used by record-observer and ui-observer — only the subscribe method is needed.
+ * Used by record-observer — only the subscribe method is needed.
  */
 export interface SubscribableSession {
   subscribe(fn: (event: AgentSessionEvent) => void): () => void;

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,11 @@
  */
 
 import { AgentTypeRegistry } from "#src/config/agent-types";
-import type { SubagentManager } from "#src/lifecycle/subagent-manager";
-import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
+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 { renderWidgetLines } from "#src/ui/widget-renderer";
+import { renderWidgetLines, type WidgetAgent } from "#src/ui/widget-renderer";
 
 // ---- Types ----
 
@@ -61,7 +62,7 @@ export type UICtx = {
 
 // ---- Widget manager ----
 
-export class AgentWidget {
+export class AgentWidget implements SubagentManagerObserver {
   private uiCtx: UICtx | undefined;
   private widgetFrame = 0;
   private widgetInterval: ReturnType<typeof setInterval> | undefined;
@@ -79,7 +80,6 @@ export class AgentWidget {
 
   constructor(
     private manager: SubagentManager,
-    private agentActivity: Map<string, AgentActivityTracker>,
     private registry: AgentTypeRegistry,
   ) {}
 
@@ -108,9 +108,36 @@ export class AgentWidget {
     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) {
+    this.startLoop();
+  }
+
+  /** A background subagent was created (queued) — ensure the loop is live and render. */
+  onSubagentCreated(_record: Subagent) {
+    this.startLoop();
+  }
+
+  /** A subagent completed — render so the finished state is seeded and shown. */
+  onSubagentCompleted(_record: Subagent) {
+    this.update();
+  }
+
+  /** A subagent's session compacted — render to refresh the compaction count. */
+  onSubagentCompacted(_record: Subagent, _info: CompactionInfo) {
+    this.update();
+  }
+
+  /** Start the update timer (if not already running) and render immediately. */
+  private startLoop() {
+    this.ensureTimer();
+    this.update();
+  }
+
   /** Ensure the widget update timer is running. */
-  // fallow-ignore-next-line unused-class-member
-  ensureTimer() {
+  private ensureTimer() {
     this.widgetInterval ??= setInterval(() => this.update(), 80);
   }
 
@@ -121,19 +148,31 @@ export class AgentWidget {
     return age < maxAge;
   }
 
-  /** Record an agent as finished (call when agent completes). */
-  // fallow-ignore-next-line unused-class-member
-  markFinished(agentId: string) {
-    if (!this.finishedTurnAge.has(agentId)) {
-      this.finishedTurnAge.set(agentId, 0);
-    }
+  /** 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,
@@ -184,8 +223,8 @@ export class AgentWidget {
 
   /**
    * Seed linger tracking for any newly-observed finished agent.
-   * Replaces the external `markFinished` call NotificationManager used to make:
-   * the widget owns detection of completions it sees via `listAgents()`.
+   * 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.
    */

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,

package/src/ui/agent-activity-tracker.ts

@@ -1,84 +0,0 @@
-/**
- * agent-activity-tracker.ts — Per-agent live activity state with explicit transition methods.
- *
- * Replaces the mutable `AgentActivity` interface that was written via output arguments
- * in `ui-observer.ts`. Callers use named transition methods; readers use read-only accessors.
- */
-
-import type { SessionLike } from "#src/lifecycle/usage";
-
-/** Per-agent live activity state with explicit transition methods and read-only accessors. */
-export class AgentActivityTracker {
-	private _activeTools = new Map<string, string>();
-	private _toolKeySeq = 0;
-	private _responseText = "";
-	private _session: SessionLike | undefined = undefined;
-	private _turnCount = 1;
-
-	constructor(private readonly _maxTurns?: number) {}
-
-	// ── Transition methods (write surface) ──────────────────────────────────
-
-	/** Record that a tool has started executing. */
-	onToolStart(toolName: string): void {
-		this._activeTools.set(toolName + "_" + (++this._toolKeySeq), toolName);
-	}
-
-	/** Remove a tool from active tools (called when tool execution ends). No-op when no matching tool is active. */
-	onToolDone(toolName: string): void {
-		for (const [key, name] of this._activeTools) {
-			if (name === toolName) {
-				this._activeTools.delete(key);
-				break;
-			}
-		}
-	}
-
-	/** Reset the current response text (called at the start of each assistant message). */
-	onMessageStart(): void {
-		this._responseText = "";
-	}
-
-	/** Append a text delta to the current response text. */
-	onMessageUpdate(delta: string): void {
-		this._responseText += delta;
-	}
-
-	/** Record that a turn has ended; increments turnCount. */
-	onTurnEnd(): void {
-		this._turnCount++;
-	}
-
-	/** Bind the session reference (called once when the agent session is created). */
-	setSession(session: SessionLike): void {
-		this._session = session;
-	}
-
-	// ── Read-only accessors ──────────────────────────────────────────────────
-
-	/** Currently-active tools: key → tool name. Multiple entries for concurrent same-name tools. */
-	get activeTools(): ReadonlyMap<string, string> {
-		return this._activeTools;
-	}
-
-	/** The agent's latest partial response text (reset at each message start). */
-	get responseText(): string {
-		return this._responseText;
-	}
-
-	/** The active SDK session, or undefined before the first session is created. */
-	get session(): SessionLike | undefined {
-		return this._session;
-	}
-
-	/** Current turn count (starts at 1). */
-	get turnCount(): number {
-		return this._turnCount;
-	}
-
-	/** Effective max turns for this agent, or undefined for unlimited. */
-	get maxTurns(): number | undefined {
-		return this._maxTurns;
-	}
-
-}

package/src/ui/ui-observer.ts

@@ -1,61 +0,0 @@
-/**
- * ui-observer.ts — Subscribes to session events and updates AgentActivityTracker state.
- *
- * Replaces the callback-based createActivityTracker pattern with a direct
- * session subscription for streaming UI state (active tools, response text,
- * turn count, lifetime usage).
- */
-
-import type { SubscribableSession } from "#src/types";
-import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
-
-/**
- * Subscribe to session events and stream UI state into an AgentActivityTracker.
- *
- * Handles:
- * - `tool_execution_start` → `tracker.onToolStart(name)`
- * - `tool_execution_end` → `tracker.onToolEnd(name)`
- * - `message_start` → `tracker.onMessageStart()`
- * - `message_update` (text_delta) → `tracker.onMessageUpdate(delta)`
- * - `turn_end` → `tracker.onTurnEnd()`
- * - `message_end` (assistant, with usage) → `tracker.onUsageUpdate(usage)`
- *
- * Calls `onUpdate?.()` after each state mutation to trigger re-renders.
- *
- * @returns An unsubscribe function.
- */
-export function subscribeUIObserver(
-	session: SubscribableSession,
-	tracker: AgentActivityTracker,
-	onUpdate?: () => void,
-): () => void {
-	return session.subscribe((event) => {
-		if (event.type === "tool_execution_start") {
-			tracker.onToolStart(event.toolName);
-			onUpdate?.();
-		}
-
-		if (event.type === "tool_execution_end") {
-			tracker.onToolDone(event.toolName);
-			onUpdate?.();
-		}
-
-		if (event.type === "message_start") {
-			tracker.onMessageStart();
-		}
-
-		if (
-			event.type === "message_update" &&
-			event.assistantMessageEvent.type === "text_delta"
-		) {
-			tracker.onMessageUpdate(event.assistantMessageEvent.delta);
-			onUpdate?.();
-		}
-
-		if (event.type === "turn_end") {
-			tracker.onTurnEnd();
-			onUpdate?.();
-		}
-
-	});
-}