@nklisch/pi-enhanced 0.2.0 → 0.2.2

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

@@ -9,7 +9,7 @@
 import { randomUUID } from "node:crypto";
 import type { Model } from "@earendil-works/pi-ai";
 import type { AgentSessionEvent, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { debugLog } from "#src/debug";
+import { debugLog, runDetached, runSafely } from "#src/debug";
 import type { CreateSubagentSessionParams } from "#src/lifecycle/create-subagent-session";
 import {
   type LifecycleInterceptorRegistry,
@@ -264,30 +264,26 @@ export class Subagent {
 	 */
 	async run(): Promise<void> {
 		this.markRunning(Date.now());
-		this.execution.observer?.onStarted?.(this);
-		this.listeners.wireSignal(this.execution.signal, () => this.abort());
-
-		// Guard the await so the no-provider path stays synchronous, preserving
-		// the original run() timing: the factory is called in the same turn as
-		// spawn() when no workspace provider is registered.
-		let cwd: string | undefined;
-		if (this.workspaceBracket.hasProvider()) {
-			try {
+		try {
+			// Observer callbacks are extension-owned sinks, not part of the agent's
+			// work. A stale UI/context callback must not leave a background record
+			// running with a slot held and no terminal notification.
+			runSafely("subagent onStarted observer", () => this.execution.observer?.onStarted?.(this));
+			this.listeners.wireSignal(this.execution.signal, () => this.abort());
+
+			// Guard the await so the no-provider path stays synchronous, preserving
+			// the original run() timing: the factory is called in the same turn as
+			// spawn() when no workspace provider is registered.
+			let cwd: string | undefined;
+			if (this.workspaceBracket.hasProvider()) {
 				cwd = await this.workspaceBracket.prepare({
 					agentId: this.id,
 					agentType: this.type,
 					baseCwd: this.execution.baseCwd,
 					invocation: this.invocation,
 				});
-			} catch (err) {
-				this.markError(err);
-				this.listeners.release();
-				this.execution.observer?.onRunFinished?.(this);
-				return;
 			}
-		}
 
-		try {
 			this.subagentSession = await this.execution.createSubagentSession({
 				snapshot: this.execution.snapshot,
 				type: this.type,
@@ -296,27 +292,24 @@ export class Subagent {
 				model: this.execution.model,
 				thinkingLevel: this.execution.thinkingLevel,
 			});
-		} catch (err) {
-			// The factory disposed its own session on a post-creation failure.
-			this.failRun(err);
-			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),
-		}));
-		this.execution.observer?.onSessionCreated?.(this);
-
-		const runConfig = this.execution.getRunConfig?.();
-		const lifecycle = this.createTurnLifecycle("initial");
-		try {
+			// 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) => runSafely(
+					"subagent onCompacted observer",
+					() => this.execution.observer?.onCompacted?.(this, info),
+				),
+			}));
+			runSafely("subagent onSessionCreated observer", () => this.execution.observer?.onSessionCreated?.(this));
+
+			const runConfig = this.execution.getRunConfig?.();
+			const lifecycle = this.createTurnLifecycle("initial");
 			const result = await this.subagentSession.runTurnLoop(this.execution.prompt, {
 				maxTurns: this.execution.maxTurns,
 				defaultMaxTurns: runConfig?.defaultMaxTurns,
@@ -326,6 +319,8 @@ export class Subagent {
 			});
 			this.completeRun(result);
 		} catch (err) {
+			// One outer failure path guarantees terminal state, listener release,
+			// workspace cleanup, and the manager's completion funnel.
 			this.failRun(err);
 		}
 	}
@@ -389,12 +384,15 @@ export class Subagent {
 		const executionSignal = signal
 			? AbortSignal.any([this.abortController.signal, signal])
 			: this.abortController.signal;
-		this.listeners.attachObserver(subscribeSubagentObserver(subagentSession, this.state, {
-			onCompact: (info) => this.execution.observer?.onCompacted?.(this, info),
-		}));
-
-		const lifecycle = this.createTurnLifecycle("resume", executionSignal);
 		try {
+			this.listeners.attachObserver(subscribeSubagentObserver(subagentSession, this.state, {
+				onCompact: (info) => runSafely(
+					"subagent onCompacted observer",
+					() => this.execution.observer?.onCompacted?.(this, info),
+				),
+			}));
+
+			const lifecycle = this.createTurnLifecycle("resume", executionSignal);
 			if (lifecycle) {
 				const result = await subagentSession.resumeLifecycleTurnLoop(
 					prompt,
@@ -415,7 +413,7 @@ export class Subagent {
 			this.markError(err);
 		} finally {
 			this.listeners.release();
-			this.execution.observer?.onResumedFinished?.(this);
+			runSafely("subagent onResumedFinished observer", () => this.execution.observer?.onResumedFinished?.(this));
 		}
 	}
 
@@ -527,7 +525,7 @@ export class Subagent {
 	/** Stop a queued agent through the same terminal observer funnel as a run. */
 	stopQueued(): void {
 		this.state.stopQueued();
-		this.execution.observer?.onRunFinished?.(this);
+		runSafely("subagent onRunFinished observer", () => this.execution.observer?.onRunFinished?.(this));
 	}
 
 	/**
@@ -557,7 +555,7 @@ export class Subagent {
 	 */
 	private flushPendingSteers(): void {
 		for (const msg of this._pendingSteers) {
-			this.subagentSession?.steer(msg).catch(() => {});
+			runDetached("subagent buffered steer", () => this.subagentSession?.steer(msg));
 		}
 		this._pendingSteers = [];
 	}
@@ -580,16 +578,23 @@ export class Subagent {
 				: result.steered
 					? "steered"
 					: "completed";
-		const finalResult =
-			result.responseText +
-			this.workspaceBracket.dispose({ status: finalStatus, description: this.description });
+		let finalResult = result.responseText;
+		try {
+			finalResult += this.workspaceBracket.dispose({ status: finalStatus, description: this.description });
+		} catch (error) {
+			// Workspace teardown belongs to the run's terminal boundary. If it
+			// fails, report an error once rather than re-entering disposal from the
+			// outer catch path.
+			this.failRun(error);
+			return;
+		}
 
 		if (result.failure) this.markFailed(result.failure, finalResult);
 		else if (result.aborted) this.markAborted(finalResult);
 		else if (result.steered) this.markSteered(finalResult);
 		else this.markCompleted(finalResult);
 
-		this.execution.observer?.onRunFinished?.(this);
+		runSafely("subagent onRunFinished observer", () => this.execution.observer?.onRunFinished?.(this));
 	}
 
 	/** Dispose the wrapped session, firing the `disposed` lifecycle event. */
@@ -616,7 +621,7 @@ export class Subagent {
 			this.workspaceBracket.dispose({ status: "error", description: this.description });
 		} catch (cleanupErr) { debugLog("workspace dispose on agent error", cleanupErr); }
 
-		this.execution.observer?.onRunFinished?.(this);
+		runSafely("subagent onRunFinished observer", () => this.execution.observer?.onRunFinished?.(this));
 	}
 }
 

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

@@ -53,7 +53,11 @@ export class WorkspaceBracket {
 	 * disposal is desired (e.g. failRun).
 	 */
 	dispose(outcome: WorkspaceDisposeOutcome): string {
-		if (!this.prepared) return "";
-		return this.prepared.dispose(outcome)?.resultAddendum ?? "";
+		const prepared = this.prepared;
+		// Clear the owned resource before calling user code. If disposal throws,
+		// an outer failure path must not invoke the provider a second time.
+		this.prepared = undefined;
+		if (!prepared) return "";
+		return prepared.dispose(outcome)?.resultAddendum ?? "";
 	}
 }

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

@@ -7,6 +7,7 @@
  * the caller forwards itself to its own lifecycle observer via onCompact.
  */
 
+import { runSafely } from "#src/debug";
 import type { SubagentState } from "#src/lifecycle/subagent-state";
 import type { CompactionInfo, SubscribableSession } from "#src/types";
 
@@ -34,45 +35,47 @@ export function subscribeSubagentObserver(
   options?: SubagentObserverOptions,
 ): () => void {
   return session.subscribe((event) => {
-    if (event.type === "tool_execution_start") {
-      state.addActiveTool(event.toolName);
-    }
+    runSafely("subagent session observer", () => {
+      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 === "tool_execution_end") {
+        state.removeActiveTool(event.toolName);
+        state.incrementToolUses();
+      }
 
-    if (event.type === "message_start") {
-      state.resetResponseText();
-    }
+      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 === "message_update" &&
+        event.assistantMessageEvent.type === "text_delta"
+      ) {
+        state.appendResponseText(event.assistantMessageEvent.delta);
+      }
 
-    if (event.type === "turn_end") {
-      state.incrementTurnCount();
-    }
+      if (event.type === "turn_end") {
+        state.incrementTurnCount();
+      }
 
-    if (event.type === "message_end" && event.message.role === "assistant") {
-      const u = event.message.usage;
-      state.addUsage({
-        input: u.input,
-        output: u.output,
-        cacheWrite: u.cacheWrite,
-      });
-    }
+      if (event.type === "message_end" && event.message.role === "assistant") {
+        const u = event.message.usage;
+        state.addUsage({
+          input: u.input,
+          output: u.output,
+          cacheWrite: u.cacheWrite,
+        });
+      }
 
-    if (event.type === "compaction_end" && !event.aborted && event.result) {
-      state.incrementCompactions();
-      options?.onCompact?.({
-        reason: event.reason,
-        tokensBefore: event.result.tokensBefore,
-      });
-    }
+      if (event.type === "compaction_end" && !event.aborted && event.result) {
+        state.incrementCompactions();
+        options?.onCompact?.({
+          reason: event.reason,
+          tokensBefore: event.result.tokensBefore,
+        });
+      }
+    });
   });
 }

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

@@ -1,3 +1,4 @@
+import { runSafely } from "#src/debug";
 import type { SubagentManagerObserver } from "#src/lifecycle/subagent-manager";
 import { buildEventData, type NotificationSystem } from "#src/observation/notification";
 import type { CompactionInfo, Subagent } from "#src/types";
@@ -35,11 +36,11 @@ export class SubagentEventsObserver implements SubagentManagerObserver {
 
 	onSubagentStarted(record: Subagent): void {
 		// Emit started event when agent transitions to running (including from queue).
-		this.emit("subagents:started", {
+		runSafely("subagent event emission started", () => this.emit("subagents:started", {
 			id: record.id,
 			type: record.type,
 			description: record.description,
-		});
+		}));
 	}
 
 	onSubagentCompleted(record: Subagent): void {
@@ -47,13 +48,13 @@ export class SubagentEventsObserver implements SubagentManagerObserver {
 		const isError = record.status === "error" || record.status === "stopped" || record.status === "aborted";
 		const eventData = buildEventData(record);
 		if (isError) {
-			this.emit("subagents:failed", eventData);
+			runSafely("subagent event emission failed", () => this.emit("subagents:failed", eventData));
 		} else {
-			this.emit("subagents:completed", eventData);
+			runSafely("subagent event emission completed", () => this.emit("subagents:completed", eventData));
 		}
 
 		// Persist final record for cross-extension history reconstruction.
-		this.appendEntry("subagents:record", {
+		runSafely("subagent record append", () => this.appendEntry("subagents:record", {
 			id: record.id,
 			type: record.type,
 			description: record.description,
@@ -62,16 +63,16 @@ export class SubagentEventsObserver implements SubagentManagerObserver {
 			error: record.error,
 			startedAt: record.startedAt,
 			completedAt: record.completedAt,
-		});
+		}));
 
 		// The manager decides whether to nudge (it owns the consumed-result state).
-		this.notifications.sendCompletion(record);
+		runSafely("subagent completion notification", () => this.notifications.sendCompletion(record));
 	}
 
 	onSubagentResumed(record: Subagent): void {
 		const eventData = buildEventData(record);
-		this.emit("subagents:resumed", eventData);
-		this.appendEntry("subagents:record", {
+		runSafely("subagent event emission resumed", () => this.emit("subagents:resumed", eventData));
+		runSafely("subagent record append resumed", () => this.appendEntry("subagents:record", {
 			id: record.id,
 			type: record.type,
 			description: record.description,
@@ -80,28 +81,28 @@ export class SubagentEventsObserver implements SubagentManagerObserver {
 			error: record.error,
 			startedAt: record.startedAt,
 			completedAt: record.completedAt,
-		});
+		}));
 	}
 
 	onSubagentCompacted(record: Subagent, info: CompactionInfo): void {
 		// Emit compacted event when agent's session compacts (preserves count on record).
-		this.emit("subagents:compacted", {
+		runSafely("subagent event emission compacted", () => this.emit("subagents:compacted", {
 			id: record.id,
 			type: record.type,
 			description: record.description,
 			reason: info.reason,
 			tokensBefore: info.tokensBefore,
 			compactionCount: record.compactionCount,
-		});
+		}));
 	}
 
 	onSubagentCreated(record: Subagent): void {
 		// Emit created event for background agents (before limiter admission).
-		this.emit("subagents:created", {
+		runSafely("subagent event emission created", () => this.emit("subagents:created", {
 			id: record.id,
 			type: record.type,
 			description: record.description,
 			isBackground: true,
-		});
+		}));
 	}
 }

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

@@ -1,4 +1,5 @@
 import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { runSafely } from "#src/debug";
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { AgentSpawnConfig } from "#src/lifecycle/subagent-manager";
 import {
@@ -50,27 +51,29 @@ export async function runForeground(
 
   let recordRef: Subagent | undefined;
 
-  const streamUpdate = () => {
-    const toolUses = recordRef?.toolUses ?? 0;
-    const details: AgentDetails = {
-      ...presentation.detailBase,
-      toolUses,
-      tokens: recordRef ? formatLifetimeTokens(recordRef) : "",
-      // 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(
-        recordRef?.activeTools ?? new Map(),
-        recordRef?.responseText ?? "",
-      ),
-      spinnerFrame: spinnerFrame % SPINNER.length,
-    };
-    onUpdate?.({
-      content: [{ type: "text", text: `${toolUses} tool uses...` }],
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Pi SDK ToolCallUpdate details type is not exported
-      details: details as any,
+  const streamUpdate = (): void => {
+    runSafely("foreground progress update", () => {
+      const toolUses = recordRef?.toolUses ?? 0;
+      const details: AgentDetails = {
+        ...presentation.detailBase,
+        toolUses,
+        tokens: recordRef ? formatLifetimeTokens(recordRef) : "",
+        // 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(
+          recordRef?.activeTools ?? new Map(),
+          recordRef?.responseText ?? "",
+        ),
+        spinnerFrame: spinnerFrame % SPINNER.length,
+      };
+      onUpdate?.({
+        content: [{ type: "text", text: `${toolUses} tool uses...` }],
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Pi SDK ToolCallUpdate details type is not exported
+        details: details as any,
+      });
     });
   };
 
@@ -81,10 +84,10 @@ export async function runForeground(
     streamUpdate();
   }, 500);
 
-  streamUpdate();
-
   let record: Subagent;
   try {
+    streamUpdate();
+
     record = await manager.spawnAndWait(
       params.snapshot,
       identity.subagentType,
@@ -107,12 +110,14 @@ export async function runForeground(
       },
     );
   } catch (err) {
-    clearInterval(spinnerInterval);
+    // Only the spawn boundary converts to an error-text result. Post-spawn
+    // formatting is internal code; its defects stay thrown tool errors so Pi
+    // reports isError rather than a success-shaped result.
     return textResult(err instanceof Error ? err.message : String(err));
+  } finally {
+    clearInterval(spinnerInterval);
   }
 
-  clearInterval(spinnerInterval);
-
   // Foreground delivery returns the complete outcome inline, so retention can
   // use the shorter consumed-session window.
   record.markConsumed();

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

@@ -7,6 +7,7 @@
  */
 
 import { AgentTypeRegistry } from "#src/config/agent-types";
+import { debugLog, runSafely } from "#src/debug";
 import type { Subagent } from "#src/lifecycle/subagent";
 import type { SubagentManagerObserver } from "#src/lifecycle/subagent-manager";
 import type { CompactionInfo } from "#src/types";
@@ -121,7 +122,7 @@ export class AgentWidget implements SubagentManagerObserver {
     // Lifecycle events can arrive before the first tool gives us a UI context.
     // Refresh when that context becomes available, but let update() decide
     // whether any active record actually needs an animation timer.
-    if (contextChanged && this.uiCtx && this.backgroundAgents.size > 0) this.update();
+    if (contextChanged && this.uiCtx && this.backgroundAgents.size > 0) this.refresh();
   }
 
   /**
@@ -141,7 +142,7 @@ export class AgentWidget implements SubagentManagerObserver {
         this.finishedTurnAge.set(id, nextAge);
       }
     }
-    this.update();
+    this.refresh();
   }
 
   // ---- SubagentManagerObserver: react to lifecycle, self-drive the timer ----
@@ -164,7 +165,7 @@ export class AgentWidget implements SubagentManagerObserver {
   onSubagentCompleted(record: Subagent) {
     if (!this.trackBackground(record)) return;
     this.finishedTurnAge.set(record.id, 0);
-    this.update();
+    this.refresh();
   }
 
   /** A resumed subagent started — ensure the update loop is live and render. */
@@ -178,38 +179,38 @@ export class AgentWidget implements SubagentManagerObserver {
   onSubagentResumed(record: Subagent) {
     if (!this.trackBackground(record)) return;
     this.finishedTurnAge.set(record.id, 0);
-    this.update();
+    this.refresh();
   }
 
   /** A subagent's session compacted — render to refresh the compaction count. */
   onSubagentCompacted(record: Subagent, _info: CompactionInfo) {
-    if (this.trackBackground(record)) this.update();
+    if (this.trackBackground(record)) this.refresh();
   }
 
   /** Remove terminal state when the manager clears a parent session. */
   onSubagentCleared(record: Subagent) {
     if (!this.backgroundAgents.delete(record.id)) return;
     this.finishedTurnAge.delete(record.id);
-    this.update();
+    this.refresh();
   }
 
   /** Refresh immediately; update() owns the timer lifecycle. */
   private startLoop() {
     if (!this.uiCtx) return;
-    this.update();
+    this.refresh();
   }
 
   /** Ensure the widget update timer is running while active records animate. */
   private ensureTimer() {
     this.widgetInterval ??= setInterval(
-      () => this.update(),
+      () => this.refresh(),
       AgentWidget.STATUS_REFRESH_INTERVAL_MS,
     );
   }
 
   /** Stop animated refreshes while leaving any static finished widget intact. */
   private stopTimer() {
-    if (this.widgetInterval) {
+    if (this.widgetInterval !== undefined) {
       clearInterval(this.widgetInterval);
       this.widgetInterval = undefined;
     }
@@ -285,12 +286,12 @@ export class AgentWidget implements SubagentManagerObserver {
    */
   private clearWidget(): void {
     if (this.widgetRegistered) {
-      this.uiCtx!.setWidget("agents", undefined);
+      runSafely("agent widget clear widget", () => this.uiCtx!.setWidget("agents", undefined));
       this.widgetRegistered = false;
       this.tui = undefined;
     }
     if (this.lastStatusText !== undefined) {
-      this.uiCtx!.setStatus("subagents", undefined);
+      runSafely("agent widget clear status", () => this.uiCtx!.setStatus("subagents", undefined));
       this.lastStatusText = undefined;
     }
     this.stopTimer();
@@ -334,21 +335,45 @@ export class AgentWidget implements SubagentManagerObserver {
     // Register widget callback once; subsequent updates use requestRender()
     // which re-invokes render() without replacing the component (avoids layout thrashing).
     if (!this.widgetRegistered) {
-      this.uiCtx.setWidget("agents", (tui, theme) => {
-        this.tui = tui;
-        return {
-          render: () => this.renderWidget(tui, theme),
-          invalidate: () => {
-            // Theme changed — force re-registration so factory captures fresh theme.
-            this.widgetRegistered = false;
-            this.tui = undefined;
-          },
-        };
-      }, { placement: "aboveEditor" });
-      this.widgetRegistered = true;
+      try {
+        this.uiCtx!.setWidget("agents", (tui, theme) => {
+          this.tui = tui;
+          return {
+            // TUI render callbacks run after the lifecycle callback that
+            // registered them; contain SDK/theme failures at this boundary too.
+            render: () => {
+              try {
+                return this.renderWidget(tui, theme);
+              } catch (error) {
+                debugLog("agent widget render", error);
+                return [];
+              }
+            },
+            invalidate: () => {
+              // Theme changed — force re-registration so factory captures fresh theme.
+              this.widgetRegistered = false;
+              this.tui = undefined;
+            },
+          };
+        }, { placement: "aboveEditor" });
+        this.widgetRegistered = true;
+      } catch (error) {
+        debugLog("agent widget register", error);
+        this.stopTimer();
+      }
     } else {
       // Widget already registered — just request a re-render of existing components.
-      this.tui?.requestRender();
+      runSafely("agent widget request render", () => this.tui?.requestRender());
+    }
+  }
+
+  /** Contain UI refresh failures and stop a timer that can no longer make progress. */
+  private refresh(): void {
+    try {
+      this.update();
+    } catch (error) {
+      debugLog("agent widget update", error);
+      this.stopTimer();
     }
   }
 
@@ -356,8 +381,8 @@ export class AgentWidget implements SubagentManagerObserver {
   dispose() {
     this.stopTimer();
     if (this.uiCtx) {
-      this.uiCtx.setWidget("agents", undefined);
-      this.uiCtx.setStatus("subagents", undefined);
+      runSafely("agent widget dispose widget", () => this.uiCtx!.setWidget("agents", undefined));
+      runSafely("agent widget dispose status", () => this.uiCtx!.setStatus("subagents", undefined));
     }
     this.widgetRegistered = false;
     this.tui = undefined;