@herbertgao/pi-extensions 2026.9.12 → 2026.9.13

package/node_modules/@narumitw/pi-btw/docs/workflows.md

@@ -17,8 +17,16 @@ Opening and closing without a new result does not reorder them.
 
 ## Read, select, and search
 
-The fullscreen workspace keeps answers above the editor and identifies itself with a fixed `btw · side thread` header.
-The main agent may keep running, but its rendering is suspended so new output cannot move a mouse selection; returning to Pi redraws that output.
+The dedicated workspace keeps answers above the editor and identifies itself with a fixed `btw · side thread` header.
+The default **Fullscreen** layout gives the side thread the complete workspace.
+**Side thread left** and **Side thread right** place it beside Pi's native, live main-thread rendering; terminals narrower than 80 columns show only the side thread.
+A single muted divider separates the panes; click either pane to move keyboard focus to it.
+Drag the divider with the primary mouse button to resize the side thread between 20% and 80% of the workspace.
+Releasing the button saves that side-thread ratio for either pane placement; a failed save restores the last saved width and reports the error.
+Pi's search and keyboard viewport controls apply to the active pane.
+The mouse wheel scrolls the pane under the pointer without moving keyboard focus, and a narrow terminal returns focus to the visible side thread.
+A branch selected through **Start from main thread tree…** supplies side-model context but does not replace the active main thread shown in the other pane.
+The main agent may keep running, and the main pane redraws its progress while either pane is active.
 Submit each question with Enter; successful prior questions and answers remain available to the side model.
 
 Drag the primary mouse button across the transcript to select text.

package/node_modules/@narumitw/pi-btw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@narumitw/pi-btw",
-  "version": "0.60.3",
+  "version": "0.61.0",
   "description": "Pi extension that adds a /btw side-question command.",
   "type": "module",
   "license": "MIT",

package/node_modules/@narumitw/pi-btw/src/btw.ts

@@ -12,7 +12,9 @@ import {
   getAnsweredTurns,
   summarizeBringToMain,
 } from "./bring-to-main.js";
+import { buildConversationContext } from "./conversation-context.js";
 import { type RunBtwFullscreen, runBtwFullscreen } from "./fullscreen-ui.js";
+import { registerBtwMainThreadUpdates } from "./main-thread-updates.js";
 import { pickMainEntry } from "./main-tree-picker.js";
 import {
   type BtwCommandMenuResult,
@@ -23,6 +25,8 @@ import {
 } from "./menu.js";
 import {
   type BtwSettings,
+  effectiveBtwLayout,
+  effectiveBtwSidePaneRatio,
   effectiveFullscreenCopyOnSelect,
   effectiveRememberThinkingLevelChanges,
   parseBtwModelReference,
@@ -47,8 +51,11 @@ import {
   type TranscriptPagerAction,
 } from "./transcript-pager.js";
 
+export { buildConversationContext } from "./conversation-context.js";
 export {
+  BTW_LAYOUTS,
   BTW_SETTINGS_FILE,
+  type BtwLayout,
   type BtwSettings,
   type BtwSettingsLoadResult,
   normalizeBtwSettings,
@@ -63,8 +70,6 @@ export {
 } from "./side-thread.js";
 export { sanitizeSingleLine } from "./text.js";
 
-const MAX_CONTEXT_CHARS = 40_000;
-
 interface LoadBtwThinkingLevelOptions {
   settingsPath?: string;
   warn?: (message: string) => void;
@@ -151,7 +156,7 @@ export async function loadBtwThinkingLevel(
 
   options.warn?.(
     sanitizeSingleLine(
-      `pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", omitted thinkingLevel for Same as main thread or thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", boolean rememberThinkingLevelChanges, and boolean fullscreenCopyOnSelect. Using current Pi thinking level.`,
+      `pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", omitted thinkingLevel for Same as main thread or thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", boolean rememberThinkingLevelChanges, boolean fullscreenCopyOnSelect, layout "fullscreen" | "left-pane" | "right-pane", and sidePaneRatio from 0.2 to 0.8. Using current Pi thinking level.`,
     ),
   );
   return currentThinkingLevel;
@@ -180,9 +185,9 @@ function notifySafely(
   }
 }
 
-// Keep this slightly-over-1,000-line command coordinator intact: its injectable menu,
-// request, resume, and delivery flows share the same thread-state and test seams;
-// settings, keybinding policy, terminal ownership, and rendering live in separate modules.
+// Keep the command coordinator intact: its injectable menu, request, resume, and
+// delivery flows share the same thread-state and test seams; settings, keybinding
+// policy, terminal ownership, and rendering live in separate modules.
 export interface BtwExtensionDependencies {
   showCommandMenu?: (
     pi: ExtensionAPI,
@@ -203,6 +208,7 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
   const resolveModel = dependencies.resolveModel ?? resolveBtwModelForCommand;
   const runThread = dependencies.runThread ?? runBtwThread;
   const runFullscreen = dependencies.runFullscreen ?? runBtwFullscreen;
+  const subscribeMainThreadUpdates = registerBtwMainThreadUpdates(pi);
   // Pi creates a fresh extension instance after session replacement or reload.
   const resumableThreads = new Map<string, BtwThreadState>();
   let nextThreadNumber = 1;
@@ -302,6 +308,11 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
           },
           {
             copyOnSelect: effectiveFullscreenCopyOnSelect(settings),
+            layout: effectiveBtwLayout(settings),
+            sidePaneRatio: effectiveBtwSidePaneRatio(settings),
+            persistSidePaneRatio: (ratio, signal) =>
+              updateBtwSettings({ sidePaneRatio: ratio }, { signal }).then(() => undefined),
+            subscribeMainThreadUpdates: (listener) => subscribeMainThreadUpdates(ctx.sessionManager, listener),
             ...(settings.keybindings ? { keybindings: settings.keybindings } : {}),
           },
         );
@@ -837,76 +848,3 @@ async function showThreadComposer(
       }),
   );
 }
-
-type MessageContentBlock = {
-  type?: string;
-  text?: string;
-  name?: string;
-  arguments?: unknown;
-  result?: unknown;
-};
-
-type SessionMessage = {
-  role?: string;
-  content?: unknown;
-  stopReason?: string;
-};
-
-type SessionEntry = {
-  type: string;
-  message?: SessionMessage;
-};
-
-export function buildConversationContext(entries: readonly SessionEntry[]) {
-  const sections: string[] = [];
-
-  for (const entry of entries) {
-    if (entry.type !== "message" || !entry.message?.role) continue;
-
-    const role = entry.message.role;
-    if (role !== "user" && role !== "assistant") continue;
-
-    const contentLines = extractContentLines(entry.message.content);
-    if (contentLines.length === 0) continue;
-
-    const label = role === "user" ? "User" : "Assistant";
-    const status =
-      entry.message.stopReason && entry.message.stopReason !== "stop" ? ` (${entry.message.stopReason})` : "";
-    sections.push(`${label}${status}: ${contentLines.join("\n")}`);
-  }
-
-  return truncateFromStart(sections.join("\n\n"), MAX_CONTEXT_CHARS);
-}
-
-function extractContentLines(content: unknown): string[] {
-  if (typeof content === "string") return [content.trim()].filter(Boolean);
-  if (!Array.isArray(content)) return [];
-
-  const lines: string[] = [];
-  for (const part of content) {
-    if (!part || typeof part !== "object") continue;
-    const block = part as MessageContentBlock;
-    if (block.type === "text" && typeof block.text === "string") {
-      lines.push(block.text.trim());
-    } else if (block.type === "toolCall" && typeof block.name === "string") {
-      lines.push(`Tool call: ${block.name}(${formatJson(block.arguments)})`);
-    } else if (block.type === "toolResult" && typeof block.name === "string") {
-      lines.push(`Tool result from ${block.name}: ${formatJson(block.result)}`);
-    }
-  }
-  return lines.filter(Boolean);
-}
-
-function formatJson(value: unknown) {
-  if (value === undefined) return "";
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-function truncateFromStart(text: string, maxChars: number) {
-  if (text.length <= maxChars) return text;
-  return `[Earlier context omitted; showing the last ${maxChars} characters.]\n${text.slice(-maxChars)}`;
-}

package/node_modules/@narumitw/pi-btw/src/conversation-context.ts

@@ -0,0 +1,74 @@
+const MAX_CONTEXT_CHARS = 40_000;
+
+type MessageContentBlock = {
+  type?: string;
+  text?: string;
+  name?: string;
+  arguments?: unknown;
+  result?: unknown;
+};
+
+type SessionMessage = {
+  role?: string;
+  content?: unknown;
+  stopReason?: string;
+};
+
+export type BtwSessionEntry = {
+  type: string;
+  message?: SessionMessage;
+};
+
+export function buildConversationContext(entries: readonly BtwSessionEntry[]): string {
+  const sections: string[] = [];
+
+  for (const entry of entries) {
+    if (entry.type !== "message" || !entry.message?.role) continue;
+
+    const role = entry.message.role;
+    if (role !== "user" && role !== "assistant") continue;
+
+    const contentLines = extractContentLines(entry.message.content);
+    if (contentLines.length === 0) continue;
+
+    const label = role === "user" ? "User" : "Assistant";
+    const status =
+      entry.message.stopReason && entry.message.stopReason !== "stop" ? ` (${entry.message.stopReason})` : "";
+    sections.push(`${label}${status}: ${contentLines.join("\n")}`);
+  }
+
+  return truncateFromStart(sections.join("\n\n"), MAX_CONTEXT_CHARS);
+}
+
+function extractContentLines(content: unknown): string[] {
+  if (typeof content === "string") return [content.trim()].filter(Boolean);
+  if (!Array.isArray(content)) return [];
+
+  const lines: string[] = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const block = part as MessageContentBlock;
+    if (block.type === "text" && typeof block.text === "string") {
+      lines.push(block.text.trim());
+    } else if (block.type === "toolCall" && typeof block.name === "string") {
+      lines.push(`Tool call: ${block.name}(${formatJson(block.arguments)})`);
+    } else if (block.type === "toolResult" && typeof block.name === "string") {
+      lines.push(`Tool result from ${block.name}: ${formatJson(block.result)}`);
+    }
+  }
+  return lines.filter(Boolean);
+}
+
+function formatJson(value: unknown): string {
+  if (value === undefined) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function truncateFromStart(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text;
+  return `[Earlier context omitted; showing the last ${maxChars} characters.]\n${text.slice(-maxChars)}`;
+}

package/node_modules/@narumitw/pi-btw/src/fullscreen-ui.ts

@@ -12,6 +12,7 @@ import {
   Key,
   type OverlayHandle,
   parseKey,
+  type ScrollView,
   type TUI,
   TuiAltScreen,
   type TuiInputListener,
@@ -19,7 +20,10 @@ import {
   truncateToWidth,
 } from "@earendil-works/pi-tui";
 import { type BtwKeybindingOverrides, BtwPasteGuard, resolveBtwShortcuts, setBtwShortcuts } from "./keybindings.js";
+import type { BtwMainThreadUpdateSubscription } from "./main-thread-updates.js";
+import type { BtwLayout } from "./settings.js";
 import { formatKeyLabel, sanitizeSingleLine } from "./text.js";
+import { type BtwFullscreenLayoutComponent, BtwMainThreadInput, BtwSplitPane } from "./workspace-layout.js";
 
 type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
 type BtwCustomFactory<T> = (
@@ -32,17 +36,23 @@ type BtwCustomFactory<T> = (
 type BtwFullscreenTui = TUI & {
   flash?: (message: string, durationMs?: number) => void;
   setLayoutRoot(component: Component | undefined): void;
+  hasFocusedOverlay?(): boolean;
   addInputListenerBeforeAll?(listener: TuiInputListener): () => void;
   addInputListenerBeforeViewport?(listener: TuiInputListener): () => void;
+  setViewportTarget?(scrollView: ScrollView | undefined): void;
 };
 
-export interface BtwFullscreenLayoutComponent extends Component {
-  getFullscreenLayout(): Component;
-}
+type FocusInspectableTui = TUI & {
+  getFocusedComponent?(): Component | null;
+};
 
 export interface BtwFullscreenOptions {
   keybindings?: BtwKeybindingOverrides;
   copyOnSelect?: boolean;
+  layout?: BtwLayout;
+  sidePaneRatio?: number;
+  persistSidePaneRatio?(ratio: number, signal: AbortSignal): Promise<void>;
+  subscribeMainThreadUpdates?: BtwMainThreadUpdateSubscription;
 }
 
 export type BtwFullscreenTuiFactory = (
@@ -158,6 +168,12 @@ class BtwTuiAltScreen extends TuiAltScreen {
     return this.isOverlayFocused();
   }
 
+  setViewportTarget(scrollView: ScrollView | undefined): void {
+    if (!scrollView) return;
+    const layout = Reflect.get(this, "currentLayout") as { primaryScrollView?: ScrollView } | undefined;
+    if (layout) layout.primaryScrollView = scrollView;
+  }
+
   override addInputListener(listener: TuiInputListener): () => void {
     let listeners = btwInputListeners.get(this);
     if (!listeners) {
@@ -419,7 +435,14 @@ class BtwFullscreenHost<T> implements Component {
   private parentRestoreQueued = false;
   private parentRestorePromise: Promise<void> | undefined;
   private cleanupError: unknown;
+  private removeMainThreadUpdateListener: (() => void) | undefined;
+  private mainThreadRefreshTimer: ReturnType<typeof setTimeout> | undefined;
+  private readonly mainThreadInput: BtwMainThreadInput;
   private readonly lifetimeController = new AbortController();
+  private readonly pendingSidePaneWrites = new Set<Promise<void>>();
+  private sidePaneRatio: number | undefined;
+  private sidePaneWriteGeneration = 0;
+  private confirmedSidePaneWriteGeneration = 0;
 
   constructor(
     private readonly parent: TUI,
@@ -431,6 +454,16 @@ class BtwFullscreenHost<T> implements Component {
     private readonly createTui: BtwFullscreenTuiFactory,
     private readonly options: BtwFullscreenOptions,
   ) {
+    const initialMainInput = getFocusedComponent(parent);
+    this.mainThreadInput = new BtwMainThreadInput(
+      initialMainInput,
+      () => {
+        const target = getFocusedComponent(parent);
+        return target === this ? initialMainInput : target;
+      },
+      () => this.fullscreen?.requestRender(),
+    );
+    this.sidePaneRatio = options.sidePaneRatio;
     queueMicrotask(() => void this.start());
   }
 
@@ -464,6 +497,7 @@ class BtwFullscreenHost<T> implements Component {
       this.fullscreen = this.createTui(this.parent, this.theme, this.keybindings, this.options);
       this.fullscreenCreated = true;
       this.fullscreen.start();
+      this.watchMainThreadUpdates();
       const shortcuts = resolveBtwShortcuts(
         this.options.keybindings,
         this.keybindings,
@@ -507,8 +541,11 @@ class BtwFullscreenHost<T> implements Component {
         }
         return { consume: true };
       });
-      outcome = { kind: "completed", value: await this.run(this.createContext()) };
+      const value = await this.run(this.createContext());
+      await this.waitForSidePaneWrites();
+      outcome = { kind: "completed", value };
     } catch (error) {
+      await this.waitForSidePaneWrites();
       outcome = { kind: "failed", error };
     }
 
@@ -547,7 +584,32 @@ class BtwFullscreenHost<T> implements Component {
     });
   }
 
+  private watchMainThreadUpdates(): void {
+    if ((this.options.layout ?? "fullscreen") === "fullscreen") return;
+    this.removeMainThreadUpdateListener = this.options.subscribeMainThreadUpdates?.(() => {
+      this.mainThreadInput.refreshTarget();
+      if (this.mainThreadRefreshTimer || this.disposed || this.finished) return;
+      this.mainThreadRefreshTimer = setTimeout(() => {
+        this.mainThreadRefreshTimer = undefined;
+        if (!this.disposed && !this.finished) this.fullscreen?.requestRender();
+      }, 0);
+      this.mainThreadRefreshTimer.unref();
+    });
+  }
+
   private restoreParent(): void {
+    if (this.mainThreadRefreshTimer) {
+      clearTimeout(this.mainThreadRefreshTimer);
+      this.mainThreadRefreshTimer = undefined;
+    }
+    const removeMainThreadUpdateListener = this.removeMainThreadUpdateListener;
+    this.removeMainThreadUpdateListener = undefined;
+    try {
+      removeMainThreadUpdateListener?.();
+    } catch (error) {
+      this.cleanupError ??= error;
+    }
+    this.mainThreadInput.dispose();
     const removeUpstreamAbortListener = this.removeUpstreamAbortListener;
     this.removeUpstreamAbortListener = undefined;
     try {
@@ -629,6 +691,8 @@ class BtwFullscreenHost<T> implements Component {
     return new Promise<Value>((resolve, reject) => {
       let component: (Component & { dispose?(): void }) | undefined;
       let overlay: OverlayHandle | undefined;
+      let splitPane: BtwSplitPane | undefined;
+      let removePaneFocusListener: (() => void) | undefined;
       let mounted = false;
       let layoutMounted = false;
       let factorySettled = false;
@@ -649,12 +713,21 @@ class BtwFullscreenHost<T> implements Component {
       };
       const unmount = () => {
         let cleanupError: unknown;
+        const removeFocusListener = removePaneFocusListener;
+        removePaneFocusListener = undefined;
+        try {
+          removeFocusListener?.();
+        } catch (error) {
+          cleanupError = error;
+        }
+        splitPane?.dispose();
+        splitPane = undefined;
         try {
           if (overlay) overlay.hide();
           else if (mounted && layoutMounted) fullscreen.setLayoutRoot(undefined);
           else if (mounted && component) fullscreen.removeChild(component);
         } catch (error) {
-          cleanupError = error;
+          cleanupError ??= error;
         }
         if (overlay || mounted) {
           try {
@@ -728,7 +801,7 @@ class BtwFullscreenHost<T> implements Component {
         return;
       }
       Promise.resolve(created)
-        .then((value) => {
+        .then(async (value) => {
           component = value;
           factorySettled = true;
           if (promiseSettled) {
@@ -739,6 +812,22 @@ class BtwFullscreenHost<T> implements Component {
             complete();
             return;
           }
+          const workspaceLayout = this.options.layout ?? "fullscreen";
+          if (!options?.overlay && workspaceLayout !== "fullscreen") {
+            await this.waitForSidePaneWrites();
+            if (promiseSettled) {
+              disposeComponent();
+              return;
+            }
+            if (closed) {
+              complete();
+              return;
+            }
+            if (this.disposed || this.finished || this.fullscreen !== fullscreen) {
+              fail(new FullscreenUiDisposedError());
+              return;
+            }
+          }
           if (options?.overlay) {
             const overlayOptions =
               typeof options.overlayOptions === "function" ? options.overlayOptions() : options.overlayOptions;
@@ -747,7 +836,38 @@ class BtwFullscreenHost<T> implements Component {
           } else {
             fullscreen.clear();
             mounted = true;
-            if (isFullscreenLayoutComponent(component)) {
+            if (workspaceLayout !== "fullscreen") {
+              layoutMounted = true;
+              const sideLayout = isFullscreenLayoutComponent(component) ? component.getFullscreenLayout() : component;
+              splitPane = new BtwSplitPane({
+                sideComponent: component,
+                sideLayout,
+                mainThread: this.parent,
+                mainLayout: getParentFullscreenLayout(this.parent),
+                mainInput: this.mainThreadInput,
+                sideScrollView: isFullscreenLayoutComponent(component) ? component.getPrimaryScrollView?.() : undefined,
+                layout: workspaceLayout,
+                theme: this.theme,
+                terminalColumns: () => fullscreen.terminal.columns,
+                terminalRows: () => fullscreen.terminal.rows,
+                hasFocusedOverlay: () => fullscreen.hasFocusedOverlay?.() ?? false,
+                setFocus: (target) => fullscreen.setFocus(target),
+                setViewportTarget: (target) => fullscreen.setViewportTarget?.(target),
+                requestRender: () => fullscreen.requestRender(),
+                sidePaneRatio: this.sidePaneRatio,
+                ...(this.options.persistSidePaneRatio
+                  ? { persistSidePaneRatio: (ratio: number) => this.persistSidePaneRatio(ratio) }
+                  : {}),
+              });
+              const addPaneFocusListener =
+                fullscreen.addInputListenerBeforeViewport?.bind(fullscreen) ??
+                fullscreen.addInputListener.bind(fullscreen);
+              removePaneFocusListener = addPaneFocusListener((data) => {
+                const consumed = splitPane?.handleTerminalInput(data);
+                return consumed ? { consume: true } : undefined;
+              });
+              fullscreen.setLayoutRoot(splitPane.getFullscreenLayout());
+            } else if (isFullscreenLayoutComponent(component)) {
               layoutMounted = true;
               fullscreen.setLayoutRoot(component.getFullscreenLayout());
             } else {
@@ -760,6 +880,75 @@ class BtwFullscreenHost<T> implements Component {
         .catch(fail);
     });
   }
+
+  private persistSidePaneRatio(ratio: number): Promise<void> {
+    const persist = this.options.persistSidePaneRatio;
+    if (!persist) {
+      this.sidePaneRatio = ratio;
+      return Promise.resolve();
+    }
+    const writeGeneration = ++this.sidePaneWriteGeneration;
+    let task!: Promise<void>;
+    task = Promise.resolve()
+      .then(() => persist(ratio, this.lifetimeController.signal))
+      .then(() => {
+        if (this.lifetimeController.signal.aborted || writeGeneration <= this.confirmedSidePaneWriteGeneration) {
+          return;
+        }
+        this.confirmedSidePaneWriteGeneration = writeGeneration;
+        this.sidePaneRatio = ratio;
+      })
+      .catch((error: unknown) => {
+        if (!this.lifetimeController.signal.aborted) {
+          const message = sanitizeSingleLine(
+            `Pi BTW pane width was not saved; the previous value remains active: ${formatError(error)}`,
+          );
+          try {
+            this.ctx.ui.notify(message, "error");
+          } catch {
+            // A replaced command context must not prevent rollback or cleanup.
+          }
+          this.fullscreen?.flash?.(message);
+        }
+        throw error;
+      })
+      .finally(() => this.pendingSidePaneWrites.delete(task));
+    this.pendingSidePaneWrites.add(task);
+    return task;
+  }
+
+  private async waitForSidePaneWrites(): Promise<void> {
+    while (this.pendingSidePaneWrites.size > 0) {
+      await Promise.allSettled([...this.pendingSidePaneWrites]);
+    }
+  }
+}
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function getFocusedComponent(tui: TUI): Component | null {
+  return (tui as FocusInspectableTui).getFocusedComponent?.() ?? null;
+}
+
+// Pi does not expose the mounted fullscreen layout root. Reusing this runtime
+// field lets Pi's own layout engine constrain its transcript and dock to the pane.
+function getParentFullscreenLayout(tui: TUI): Component | undefined {
+  if (tui.mode !== "fullscreen") return undefined;
+  const layoutRoot = Reflect.get(tui, "layoutRoot") as unknown;
+  return isComponent(layoutRoot) ? layoutRoot : undefined;
+}
+
+function isComponent(value: unknown): value is Component {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "render" in value &&
+    typeof value.render === "function" &&
+    "invalidate" in value &&
+    typeof value.invalidate === "function"
+  );
 }
 
 function isFullscreenLayoutComponent(component: Component): component is BtwFullscreenLayoutComponent {

package/node_modules/@narumitw/pi-btw/src/main-thread-updates.ts

@@ -0,0 +1,40 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export type BtwMainThreadUpdateSubscription = (listener: () => void) => () => void;
+type SessionManager = ExtensionContext["sessionManager"];
+
+export function registerBtwMainThreadUpdates(
+  pi: ExtensionAPI,
+): (sessionManager: SessionManager, listener: () => void) => () => void {
+  const listeners = new WeakMap<SessionManager, Set<() => void>>();
+  const notify = (ctx: ExtensionContext) => {
+    for (const listener of listeners.get(ctx.sessionManager) ?? []) listener();
+  };
+
+  pi.on("session_info_changed", (_event, ctx) => notify(ctx));
+  pi.on("session_compact", (_event, ctx) => notify(ctx));
+  pi.on("session_tree", (_event, ctx) => notify(ctx));
+  pi.on("agent_start", (_event, ctx) => notify(ctx));
+  pi.on("agent_end", (_event, ctx) => notify(ctx));
+  pi.on("agent_settled", (_event, ctx) => notify(ctx));
+  pi.on("turn_start", (_event, ctx) => notify(ctx));
+  pi.on("turn_end", (_event, ctx) => notify(ctx));
+  pi.on("message_start", (_event, ctx) => notify(ctx));
+  pi.on("message_update", (_event, ctx) => notify(ctx));
+  pi.on("message_end", (_event, ctx) => notify(ctx));
+  pi.on("tool_execution_start", (_event, ctx) => notify(ctx));
+  pi.on("tool_execution_update", (_event, ctx) => notify(ctx));
+  pi.on("tool_execution_end", (_event, ctx) => notify(ctx));
+  pi.on("model_select", (_event, ctx) => notify(ctx));
+  pi.on("thinking_level_select", (_event, ctx) => notify(ctx));
+
+  return (sessionManager, listener) => {
+    const active = listeners.get(sessionManager) ?? new Set<() => void>();
+    active.add(listener);
+    listeners.set(sessionManager, active);
+    return () => {
+      active.delete(listener);
+      if (active.size === 0) listeners.delete(sessionManager);
+    };
+  };
+}