pi-one-ui 0.7.0 → 0.7.1

package/extensions/app/runtime/tui-runtime.ts

@@ -1,20 +1,24 @@
+import { isDeepStrictEqual } from "node:util";
 import type {
   ExtensionAPI,
   ExtensionContext,
   Theme,
 } from "@earendil-works/pi-coding-agent";
+import aliases from "../../features/aliases.ts";
+import contextInspector from "../../features/context-inspector/index.ts";
+import effortCommand from "../../features/effort-command.ts";
+import sessionReference from "../../features/session-reference/index.ts";
+import subagentAutocomplete from "../../features/subagent-autocomplete.ts";
 import registerContext, {
-  type ContextExtensionOptions,
   type ContextRuntimeController,
 } from "../../layouts/context/index.ts";
-import { EditorLayoutController } from "../../layouts/editor/controller.ts";
-import { FooterLayoutController } from "../../layouts/footer/controller.ts";
-import registerHeaderLayout from "../../layouts/header/index.ts";
-import {
-  WorkingLineLayoutController,
-  type WorkingLineMessage,
-  type WorkingLineMessageEnd,
-} from "../../layouts/working-line/controller.ts";
+import { EditorLayoutController } from "../../layouts/editor/index.ts";
+import { FooterLayoutController } from "../../layouts/footer/index.ts";
+import registerHeader, {
+  applyStartupHeader,
+} from "../../layouts/header/index.ts";
+import { SelectorController } from "../../layouts/overlay/selector-controller.ts";
+import { WorkingLineLayoutController } from "../../layouts/working-line/controller.ts";
 import {
   renderTurnSummaryEntry,
   TURN_SUMMARY_ENTRY_TYPE,
@@ -29,261 +33,202 @@ import {
   syncState,
 } from "../../services/session-state.ts";
 import { resolveFooterTelemetry } from "../../services/telemetry.ts";
+import { type Config, config, setConfig } from "../config/renderer.ts";
 import {
-  ensureConfigExists,
+  type EditorComponentConfig,
   hasUnsupportedComponentStyle,
   loadConfig,
-  mergeConfig,
   type PolishedTuiConfig,
-  saveEditorComponentPatch,
-  saveFooterComponentPatch,
-  saveWorkingLineComponentPatch,
 } from "../config/shell.ts";
-import { type ConfigRecord, configStore } from "../config/store.ts";
+import { InputRouter } from "../overlay/input-router.ts";
+import { OverlayManager } from "../overlay/overlay-manager.ts";
 import {
-  createPiExtensionPort,
-  type PiExtensionPort,
-} from "../host/pi-extension-port.ts";
-import { createPiUiPort, type PiUiPort } from "../host/pi-ui-port.ts";
-import { SelectorController } from "../overlay/selector-controller.ts";
-import { LayoutRegistry } from "../ownership/layout-registry.ts";
-import { showOneUiPanel, type TuiPanelRuntime } from "../panel.ts";
+  type SettingsChange,
+  SettingsController,
+} from "../settings/controller.ts";
+import { showOneUiPanel } from "../settings/panel.ts";
 import { EventCoordinator } from "./event-coordinator.ts";
+import { installFlushDockedBash } from "./flush-docked-bash.ts";
 import { RenderScheduler } from "./render-scheduler.ts";
-import { RuntimeStateStore } from "./runtime-state.ts";
 import { SessionLifecycle } from "./session-lifecycle.ts";
 
-export type TuiRuntimeContext = {
-  readonly extensions: PiExtensionPort;
-  readonly state: RuntimeStateStore;
-  readonly render: RenderScheduler;
-  readonly layouts: LayoutRegistry;
-  readonly ui: () => PiUiPort | undefined;
-};
-
-/**
- * The single composition root for the plugin. Remaining compatibility glue
- * is mounted behind this seam while Layout ownership is finalized.
- */
+/** 产品入口只组织组件、Feature 和共享生命周期。 */
 export class TuiRuntime {
-  private readonly pi: ExtensionAPI;
-  readonly extensions: PiExtensionPort;
-  readonly state = new RuntimeStateStore();
-  readonly layouts = new LayoutRegistry();
-
+  readonly render = new RenderScheduler();
+  readonly settings = new SettingsController();
+  readonly overlays = new OverlayManager();
+  readonly input = new InputRouter();
   private readonly coordinator: EventCoordinator;
-  private readonly renderScheduler: RenderScheduler;
-  private activeUi: PiUiPort | undefined;
+  private readonly coordinatedPi: ExtensionAPI;
+  private context: ContextRuntimeController | undefined;
   private installed = false;
-  private editorController: EditorLayoutController | undefined;
-  private footerController: FooterLayoutController | undefined;
-  private workingLineController: WorkingLineLayoutController | undefined;
-  private contextController: ContextRuntimeController | undefined;
+  private currentContext: ExtensionContext | undefined;
 
-  /**
-   * Creates the runtime services and coordinates session lifecycle ownership.
-   */
   constructor(pi: ExtensionAPI) {
-    this.pi = pi;
-    this.extensions = createPiExtensionPort(pi);
-    this.renderScheduler = new RenderScheduler((force) =>
-      this.activeUi?.requestRender(force),
-    );
     this.coordinator = new EventCoordinator({
-      on: (event, handler) =>
-        this.extensions.on(event as never, handler as never),
+      on: (event, handler) => pi.on(event as never, handler as never),
     });
+    this.coordinatedPi = this.coordinator.coordinate(pi);
   }
 
-  /**
-   * Returns the shared render scheduler used by installed layouts.
-   */
-  get render(): RenderScheduler {
-    return this.renderScheduler;
-  }
-
-  /**
-   * Returns the active session UI port, when a TUI session is mounted.
-   */
-  ui(): PiUiPort | undefined {
-    return this.activeUi;
-  }
-
-  /**
-   * Exposes the narrow runtime contract consumed by the settings panel.
-   *
-   * @returns Layout-independent panel operations.
-   */
-  private panelRuntime(): TuiPanelRuntime {
-    return {
-      setEditorComponent: (patch, ctx) =>
-        this.editorController?.setComponent(patch, ctx) ?? { applied: false },
-      setUserMessagesComponent: (patch, ctx) =>
-        this.contextController?.setUserMessagesComponent(patch, ctx),
-      setWorkingLineComponent: (patch, ctx) =>
-        this.workingLineController?.setComponent(patch, ctx) ?? {
-          applied: false,
-          reason: "WorkingLine runtime is not available",
-        },
-      setFooterComponent: (patch, ctx) =>
-        this.footerController?.setComponent(patch, ctx),
-      setContextMode: (mode, ctx) => this.contextController?.setMode(mode, ctx),
-      updateContextConfig: (patch, ctx) =>
-        this.contextController?.updateConfig(patch, ctx),
-    };
-  }
-
-  /**
-   * Installs the runtime once and mounts remaining layout lifecycle glue.
-   */
   install(): void {
-    if (this.installed) return;
+    if (this.installed) {
+      return;
+    }
     this.installed = true;
-
-    const contextOptions: ContextExtensionOptions = {
-      onRuntimeController: (controller) => {
-        this.contextController = controller;
+    setConfig(this.settings.snapshot().renderer);
+    const pi = this.coordinatedPi;
+    this.coordinator.on("session_start", (_event, ctx) => {
+      this.overlays.startSession();
+      this.input.clear();
+      this.currentContext = ctx;
+    });
+    this.coordinator.on("session_shutdown", () => {
+      this.overlays.reset();
+      this.input.clear();
+    });
+    const bindings = createLayoutRuntime(pi, {
+      render: this.render,
+      settings: this.settings,
+      onConfigChanged: (previous, ctx) => {
+        this.context?.applyConfig(ctx, previous);
+        if (previous.showStartupHeader !== config.showStartupHeader) {
+          applyStartupHeader(ctx);
+        }
       },
-    };
-
-    const layoutBindings = createLayoutRuntime(this.pi, this.coordinator);
-    layoutBindings.workingLineController.setSummaryWriterEnabled(false);
-    this.editorController = layoutBindings.editorController;
-    this.footerController = layoutBindings.footerController;
-    this.workingLineController = layoutBindings.workingLineController;
-    layoutBindings.installEventHandlers(this.coordinator);
-    registerHeaderLayout(this.pi);
-    registerContext(this.pi, contextOptions);
-    this.coordinator.on("session_start", async (_event, ctx) => {
-      this.state.start(ctx.mode);
+    });
+    bindings.workingLineController.setSummaryWriterEnabled(false);
+    bindings.installEventHandlers(this.coordinator);
+    registerHeader(pi);
+    this.context = registerContext(pi, {
+      getConfig: bindings.getConfig,
+      services: {
+        input: this.input,
+        overlays: this.overlays,
+        render: this.render,
+      },
+    });
+    if (config.enableAliases) {
+      aliases(pi);
+    }
+    if (config.enableEffortCommand) {
+      effortCommand(pi);
+    }
+    if (config.enableContextCommand) {
+      contextInspector(pi, this.overlays);
+    }
+    if (config.enableSessionReference) {
+      sessionReference(pi);
+    }
+    if (config.enableSubagentAutocomplete) {
+      subagentAutocomplete(pi);
+    }
+    let cleanupBash: (() => void) | undefined;
+    this.coordinator.on("session_start", (_event, ctx) => {
       if (ctx.mode === "tui" && ctx.hasUI) {
-        // Pi exposes redraw through concrete TUI components; layouts will
-        // connect that callback when they migrate behind this runtime.
-        this.activeUi = createPiUiPort(ctx);
+        cleanupBash = installFlushDockedBash();
       }
     });
-    this.coordinator.on("session_shutdown", (_event, ctx) => {
-      this.activeUi = undefined;
-      this.state.shutdown();
+    this.coordinator.on("session_shutdown", () => {
+      cleanupBash?.();
+      cleanupBash = undefined;
+      this.currentContext = undefined;
     });
     this.coordinator.install();
-
-    this.extensions.registerCommand("oneui", {
+    pi.registerCommand("oneui", {
       description: "Open pi-one-ui settings",
       handler: async (_args, ctx) => {
-        await showOneUiPanel(ctx, { runtime: this.panelRuntime() });
+        await showOneUiPanel(ctx, {
+          settings: this.settings,
+          overlays: this.overlays,
+        });
       },
     });
   }
+
+  async dispose(ctx = this.currentContext): Promise<void> {
+    if (ctx && this.currentContext) {
+      await this.coordinator.dispatch(
+        "session_shutdown",
+        { type: "session_shutdown", reason: "quit" },
+        ctx,
+      );
+    }
+  }
 }
 
-/**
- * Creates a single TUI runtime for the plugin composition root.
- */
 export function createTuiRuntime(pi: ExtensionAPI): TuiRuntime {
   return new TuiRuntime(pi);
 }
 
-/**
- * Reports whether a context exposes the interactive TUI layout.
- *
- * @param ctx Candidate Pi extension context.
- * @returns Whether the context can install TUI-owned layouts.
- */
 function isTuiContext(ctx: ExtensionContext): boolean {
-  try {
-    const mode = ctx.mode;
-    return ctx.hasUI && (mode === undefined || mode === "tui");
-  } catch {
-    return false;
-  }
+  const mode = ctx.mode;
+  return ctx.hasUI && (mode === undefined || mode === "tui");
 }
 
-/**
- * Creates the layout controllers and shared services used by TuiRuntime.
- *
- * @param pi Pi extension API.
- * @param eventCoordinator Shared lifecycle event coordinator.
- * @returns Layout controllers and lifecycle registration bindings.
- */
-function createLayoutRuntime(
+type LayoutRuntimeOptions = {
+  render?: RenderScheduler;
+  settings?: SettingsController;
+  onConfigChanged?: (previous: Config, ctx: ExtensionContext) => void;
+};
+
+/** 生产运行时与组件集成测试共同使用的实际装配。 */
+export function createLayoutRuntime(
   pi: ExtensionAPI,
-  eventCoordinator: EventCoordinator,
+  options: LayoutRuntimeOptions = {},
 ) {
   const sessionLifecycle = new SessionLifecycle();
+  const render = options.render ?? new RenderScheduler();
+  const settings = options.settings ?? new SettingsController();
   let currentConfig: PolishedTuiConfig = loadConfig();
-  configStore.subscribe((record: ConfigRecord) => {
-    currentConfig = mergeConfig(record);
-  });
+  let unsubscribeConfig: (() => void) | undefined;
+  let activeTheme: Theme | undefined;
+  let minimalistProjectRoot: string | undefined;
+  let activeTuiContext: ExtensionContext | undefined;
   const sessionState = new SessionStateService({
     getCacheHitIcon: () => currentConfig.icons.cacheHit,
     resolveTelemetry: resolveFooterTelemetry,
     syncState,
   });
   const state = sessionState.state;
-  // Keep the capability guard defensive for hosts with incomplete extension APIs.
   if (typeof pi.registerEntryRenderer === "function") {
-    pi.registerEntryRenderer(TURN_SUMMARY_ENTRY_TYPE, (entry, options, theme) =>
-      renderTurnSummaryEntry(
-        entry,
-        {
-          ...options,
-          workingLineHigh: currentConfig.colors.workingLineHigh,
-        },
-        theme,
-      ),
+    pi.registerEntryRenderer(
+      TURN_SUMMARY_ENTRY_TYPE,
+      (entry, entryOptions, theme) =>
+        renderTurnSummaryEntry(
+          entry,
+          {
+            ...entryOptions,
+            workingLineHigh: currentConfig.colors.workingLineHigh,
+          },
+          theme,
+        ),
     );
   }
-  let activeTheme: Theme | undefined;
-  let minimalistProjectRoot: string | undefined;
-  let activeTuiContext: ExtensionContext | undefined;
-
-  /**
-   * Requests redraws from the Editor controller and shared render seam.
-   */
-  const refresh = () => {
-    if (!sessionLifecycle.isCurrent()) return;
-    editorController.requestRender();
+  const refresh = (): void => {
+    if (sessionLifecycle.isCurrent()) {
+      render.request();
+    }
   };
   const liveContext = new LiveContextController(sessionLifecycle, refresh);
-  const getActiveTheme = () => activeTheme;
-  const getCurrentConfig = () => currentConfig;
-
-  /**
-   * Reloads the canonical configuration after an external test-support write.
-   *
-   * @returns The refreshed normalized configuration snapshot.
-   */
-  const reloadConfig = (): PolishedTuiConfig => {
-    currentConfig = loadConfig();
-    return currentConfig;
-  };
+  const getConfig = () => currentConfig;
+  const syncFooterState = (ctx: ExtensionContext) => sessionState.sync(ctx);
   const workingLineController = new WorkingLineLayoutController({
     pi,
-    getConfig: getCurrentConfig,
-    saveComponent: (patch) => {
-      currentConfig = saveWorkingLineComponentPatch(patch);
-      return currentConfig;
-    },
+    getConfig,
     getTheme: () => activeTheme as Theme,
     sessionLifecycle,
     refresh,
-    onAgentActiveChanged: (active) => {
-      editorController.setAgentRunActive(active);
-    },
+    onAgentActiveChanged: (active) =>
+      editorController.setAgentRunActive(active),
   });
-  const getThinkingLevel = () =>
-    sessionLifecycle.isCurrent() ? pi.getThinkingLevel() : ("off" as const);
   const editorController = new EditorLayoutController({
-    getConfig: getCurrentConfig,
-    saveComponent: (patch) => {
-      currentConfig = saveEditorComponentPatch(patch);
-      return currentConfig;
-    },
+    getConfig,
     getState: () => state,
     sessionLifecycle,
-    render: { request: () => footerController.requestRender() },
-    getThinkingLevel,
+    render,
+    getThinkingLevel: () =>
+      sessionLifecycle.isCurrent() ? pi.getThinkingLevel() : "off",
     getAgentDurationMs: () => workingLineController.duration().elapsedMs() ?? 0,
     isAgentActive: () => workingLineController.isAgentActive(),
     isAgentDurationActive: () => workingLineController.duration().isActive(),
@@ -291,13 +236,14 @@ function createLayoutRuntime(
       workingLineController.duration().subscribe(() => listener()),
     getProjectRoot: () => minimalistProjectRoot,
     onProjectRequirementChanged: () => {
-      if (activeTuiContext) projectRefreshService.reconcile(activeTuiContext);
+      if (activeTuiContext) {
+        projectRefreshService.reconcile(activeTuiContext);
+      }
     },
-    onModelLabelChanged: (ctx) => syncFooterState(ctx),
+    onModelLabelChanged: syncFooterState,
   });
-  const syncFooterState = (ctx: ExtensionContext) => sessionState.sync(ctx);
   const projectRefreshService = new ProjectRefreshService({
-    getConfig: getCurrentConfig,
+    getConfig,
     state,
     sessionLifecycle,
     getFooterReferences: () => footerController.installedFooterReferences(),
@@ -312,133 +258,206 @@ function createLayoutRuntime(
   });
   const scheduleProjectRefresh = (
     ctx: ExtensionContext,
-    options?: ScheduleProjectRefreshOptions,
-  ) => projectRefreshService.schedule(ctx, options);
-
-  /**
-   * Synchronizes shared session state and requests a visible redraw.
-   *
-   * @param ctx Active Pi extension context.
-   * @param project Whether project data should be scheduled.
-   */
-  const refreshInteractiveState = (ctx: ExtensionContext, project = false) => {
-    if (!sessionLifecycle.isCurrent() || !ctx.hasUI) return;
-    editorController.reconcileOwnership(ctx);
-    syncFooterState(ctx);
-    if (project) scheduleProjectRefresh(ctx);
-    refresh();
-  };
-
-  const selectorController = new SelectorController({
-    getConfig: getCurrentConfig,
-  });
+    refreshOptions?: ScheduleProjectRefreshOptions,
+  ) => projectRefreshService.schedule(ctx, refreshOptions);
+  const selectorController = new SelectorController({ getConfig });
   const footerController = new FooterLayoutController({
-    getConfig: getCurrentConfig,
-    saveComponent: (patch) => {
-      currentConfig = saveFooterComponentPatch(patch);
-      return currentConfig;
-    },
+    getConfig,
     state,
     sessionLifecycle,
+    render,
     refresh,
     scheduleProjectRefresh: (ctx) => scheduleProjectRefresh(ctx),
     getLiveContext: () => liveContext.get(),
     onProjectRequirementChanged: (ctx, force) =>
       projectRefreshService.reconcile(ctx, force),
-    onModelLabelChanged: (ctx) => syncFooterState(ctx),
+    onModelLabelChanged: syncFooterState,
   });
 
-  const applyConfiguredUi = (ctx: ExtensionContext) => {
-    if (!isTuiContext(ctx)) return;
+  const applyConfig = (
+    previous: PolishedTuiConfig,
+    previousRenderer: Config,
+    ctx: ExtensionContext,
+    change?: SettingsChange,
+  ): void => {
+    if (!sessionLifecycle.isCurrent() || !isTuiContext(ctx)) {
+      return;
+    }
+    const oldEditor = previous.components.editor;
+    const editor = currentConfig.components.editor;
+    const patch: Partial<EditorComponentConfig> = {};
+    for (const key of [
+      "style",
+      "modelLabel",
+      "borderColorMode",
+      "viewportIndicators",
+    ] as const) {
+      if (oldEditor[key] !== editor[key]) {
+        Object.assign(patch, { [key]: editor[key] });
+      }
+    }
+    const preset = change?.id.startsWith("preset:") ?? false;
+    if (
+      preset ||
+      change?.id === "editorStyle" ||
+      hasUnsupportedComponentStyle(previous, "editor") !==
+        hasUnsupportedComponentStyle(currentConfig, "editor")
+    ) {
+      patch.style = editor.style;
+    }
+    const editorChange = editorController.applyConfig(patch, ctx);
+    const oldFooter = previous.components.footer;
+    const footer = currentConfig.components.footer;
+    const footerChange = footerController.applyConfig(
+      {
+        ...(oldFooter.style !== footer.style ||
+        preset ||
+        change?.id === "footerStyle" ||
+        hasUnsupportedComponentStyle(previous, "footer") !==
+          hasUnsupportedComponentStyle(currentConfig, "footer")
+          ? { style: footer.style }
+          : {}),
+        ...(oldFooter.modelLabel !== footer.modelLabel
+          ? { modelLabel: footer.modelLabel }
+          : {}),
+      },
+      ctx,
+      oldFooter.style,
+    );
+    const workingLineUpdated = Boolean(
+      preset ||
+        !isDeepStrictEqual(
+          previous.components.workingLine,
+          currentConfig.components.workingLine,
+        ),
+    );
+    const workingLineChange = workingLineUpdated
+      ? workingLineController.applyConfig(ctx)
+      : undefined;
     selectorController.reconcile();
-    projectRefreshService.reconcile(ctx);
-    footerController.reconcileSessionTimer();
+    options.onConfigChanged?.(previousRenderer, ctx);
+    refresh();
+    const failures = [
+      editorChange,
+      footerChange,
+      ...(workingLineChange ? [workingLineChange] : []),
+    ]
+      .filter((result) => !result.applied)
+      .map(
+        (result) =>
+          new Error(
+            result.reason ?? "Layout could not apply the configuration",
+          ),
+      );
+    if (failures.length > 0) {
+      throw new AggregateError(
+        failures,
+        "Layout configuration could not be applied",
+      );
+    }
+  };
+  const subscribeConfig = (): void => {
+    unsubscribeConfig?.();
+    unsubscribeConfig = settings.subscribe((snapshot, change) => {
+      const previous = currentConfig;
+      const previousRenderer = { ...config };
+      currentConfig = snapshot.shell;
+      setConfig(snapshot.renderer);
+      if (activeTuiContext) {
+        applyConfig(previous, previousRenderer, activeTuiContext, change);
+      }
+    });
   };
 
-  /**
-   * Installs compatibility layouts around the extracted Editor controller.
-   */
-  const installUi = (ctx: ExtensionContext) => {
-    if (!isTuiContext(ctx)) return;
+  const refreshInteractiveState = (
+    ctx: ExtensionContext,
+    project = false,
+  ): void => {
+    if (!sessionLifecycle.isCurrent() || !ctx.hasUI) {
+      return;
+    }
+    editorController.reconcileOwnership(ctx);
+    syncFooterState(ctx);
+    if (project) {
+      scheduleProjectRefresh(ctx);
+    }
+    refresh();
+  };
+  const reloadConfig = (): PolishedTuiConfig => {
+    currentConfig = loadConfig();
+    return currentConfig;
+  };
+  const installUi = (ctx: ExtensionContext): void => {
+    if (!isTuiContext(ctx)) {
+      return;
+    }
     activeTuiContext = ctx;
     activeTheme = ctx.ui.theme;
-    ensureConfigExists();
-    currentConfig = loadConfig();
+    reloadConfig();
     syncFooterState(ctx);
     projectRefreshService.stop();
-
     footerController.install(ctx);
     editorController.install(ctx, true);
     selectorController.startSession(ctx);
-    applyConfiguredUi(ctx);
+    projectRefreshService.reconcile(ctx);
+    footerController.reconcileSessionTimer();
     refresh();
   };
-
-  /**
-   * Cleans all session-owned layout resources in dependency order.
-   */
-  const cleanupUi = (ctx?: ExtensionContext) => {
-    if (!ctx || !sessionLifecycle.isCurrent()) return;
+  const dispose = (ctx = activeTuiContext): void => {
+    if (!sessionLifecycle.isCurrent()) {
+      return;
+    }
+    sessionLifecycle.shutdown();
+    activeTuiContext = undefined;
+    unsubscribeConfig?.();
+    unsubscribeConfig = undefined;
+    liveContext.shutdown();
+    if (ctx) {
+      workingLineController.dispose(ctx);
+    }
     editorController.cleanup(ctx);
     footerController.cleanup(ctx);
     projectRefreshService.stop();
     selectorController.cleanup();
     activeTheme = undefined;
-    activeTuiContext = undefined;
+    render.dispose();
   };
-
-  const syncInteractiveState = (_event: unknown, ctx: ExtensionContext) => {
+  const syncInteractiveState = (_event: unknown, ctx: ExtensionContext) =>
     refreshInteractiveState(ctx);
-  };
   const syncInteractiveAndProjectState = (
     _event: unknown,
     ctx: ExtensionContext,
-  ) => {
+  ) => refreshInteractiveState(ctx, true);
+  const syncWithUsage = (_event: unknown, ctx: ExtensionContext) => {
+    sessionState.invalidateUsageCache();
     refreshInteractiveState(ctx, true);
   };
 
-  /**
-   * Registers session and runtime effects with the supplied event coordinator.
-   *
-   * @param coordinator Shared lifecycle event coordinator.
-   */
   const installEventHandlers = (coordinator: EventCoordinator): void => {
     coordinator.on("session_start", (_event, ctx) => {
+      dispose();
       sessionLifecycle.start();
+      render.reset();
+      subscribeConfig();
       liveContext.startSession();
       sessionState.startSession();
       minimalistProjectRoot = undefined;
       installUi(ctx);
       workingLineController.startSession(ctx);
     });
-
-    coordinator.on("session_shutdown", async (_event, ctx) => {
-      liveContext.shutdown();
-      workingLineController.dispose(ctx);
-      cleanupUi(ctx);
-    });
-
-    const syncInteractiveAndProjectStateWithUsage = (
-      _event: unknown,
-      ctx: ExtensionContext,
-    ) => {
-      sessionState.invalidateUsageCache();
-      refreshInteractiveState(ctx, true);
-    };
-
+    coordinator.on("session_shutdown", (_event, ctx) => dispose(ctx));
     coordinator.on("agent_start", (event, ctx) => {
       liveContext.clear();
       workingLineController.agentStart(ctx);
       syncInteractiveState(event, ctx);
     });
-    coordinator.on("turn_start", (_event, ctx) => {
-      workingLineController.turnStart(ctx);
-    });
+    coordinator.on("turn_start", (_event, ctx) =>
+      workingLineController.turnStart(ctx),
+    );
     coordinator.on("agent_end", (event, ctx) => {
       liveContext.clear();
       workingLineController.agentEnd(ctx);
-      // Reconcile once more after Pi has persisted the assistant message.
-      syncInteractiveAndProjectStateWithUsage(event, ctx);
+      syncWithUsage(event, ctx);
     });
     coordinator.on("model_select", (event, ctx) => {
       liveContext.clear();
@@ -447,68 +466,51 @@ function createLayoutRuntime(
     coordinator.on("thinking_level_select", syncInteractiveState);
     coordinator.on("session_info_changed", syncInteractiveState);
     coordinator.on("message_update", (event, ctx) => {
-      const payload = event as {
-        message: WorkingLineMessage;
-        assistantMessageEvent?: Parameters<
-          WorkingLineLayoutController["messageUpdate"]
-        >[1];
-      };
-      liveContext.update(payload.message);
+      liveContext.update(event.message);
       workingLineController.messageUpdate(
-        payload.message,
-        payload.assistantMessageEvent,
+        event.message,
+        event.assistantMessageEvent,
         ctx,
       );
     });
     coordinator.on("message_end", (event, ctx) => {
-      const payload = event as {
-        message: WorkingLineMessageEnd & { stopReason?: string };
-      };
-      const result = workingLineController.messageEnd(payload.message, ctx);
-      // Pi notifies extensions before persisting a successful message, so retain its live
-      // context until agent_end; accepted failed messages clear immediately instead of showing
-      // stale usage. Rejected and duplicate finals are not authoritative.
+      const result = workingLineController.messageEnd(event.message, ctx);
       if (
         result.status === "accepted" &&
-        payload.message.role === "assistant" &&
-        (payload.message.stopReason === "error" ||
-          payload.message.stopReason === "aborted")
+        event.message.role === "assistant" &&
+        (event.message.stopReason === "error" ||
+          event.message.stopReason === "aborted")
       ) {
         liveContext.clear();
       }
-      syncInteractiveAndProjectStateWithUsage(event, ctx);
-    });
-    coordinator.on("agent_settled", (_event, ctx) => {
-      workingLineController.agentSettled(ctx);
+      syncWithUsage(event, ctx);
     });
+    coordinator.on("agent_settled", (_event, ctx) =>
+      workingLineController.agentSettled(ctx),
+    );
     coordinator.on("tool_execution_start", (event, ctx) => {
       liveContext.clear();
-      const payload = event as { toolCallId: string; toolName: string };
-      workingLineController.toolStart(
-        payload.toolCallId,
-        payload.toolName,
-        ctx,
-      );
+      workingLineController.toolStart(event.toolCallId, event.toolName, ctx);
       syncInteractiveState(event, ctx);
     });
     coordinator.on("tool_execution_end", (event, ctx) => {
-      const payload = event as { toolCallId: string };
-      workingLineController.toolEnd(payload.toolCallId, ctx);
+      workingLineController.toolEnd(event.toolCallId, ctx);
       syncInteractiveAndProjectState(event, ctx);
     });
     coordinator.on("session_compact", (event, ctx) => {
       liveContext.clear();
-      syncInteractiveAndProjectStateWithUsage(event, ctx);
+      syncWithUsage(event, ctx);
     });
     coordinator.on("session_tree", (event, ctx) => {
       liveContext.clear();
-      syncInteractiveAndProjectStateWithUsage(event, ctx);
+      syncWithUsage(event, ctx);
     });
   };
 
   return {
     sessionLifecycle,
-    getConfig: getCurrentConfig,
+    settings,
+    getConfig,
     editorController,
     footerController,
     workingLineController,
@@ -516,5 +518,6 @@ function createLayoutRuntime(
     projectRefreshService,
     reloadConfig,
     installEventHandlers,
+    dispose,
   };
 }