@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/left-rail-pointer-handler.ts

@@ -0,0 +1,329 @@
+import { detectConversationDoubleClick } from '../mux/double-click.ts';
+import {
+  actionAtWorkspaceRailCell,
+  conversationIdAtWorkspaceRailRow,
+  kindAtWorkspaceRailRow,
+  projectIdAtWorkspaceRailRow,
+  repositoryIdAtWorkspaceRailRow,
+  type buildWorkspaceRailViewRows,
+} from '../mux/workspace-rail-model.ts';
+import type {
+  RailPointerHitDispatcher,
+  RailPointerHitResolver,
+} from '../../packages/harness-ui/src/interaction/rail-pointer-input.ts';
+
+type RailAction = ReturnType<typeof actionAtWorkspaceRailCell>;
+
+interface ConversationTitleClickState {
+  readonly conversationId: string;
+  readonly atMs: number;
+}
+
+interface LeftRailPointerHit {
+  readonly selectedConversationId: string | null;
+  readonly selectedProjectId: string | null;
+  readonly selectedRepositoryId: string | null;
+  readonly selectedAction: RailAction;
+  readonly supportsConversationTitleEditClick: boolean;
+}
+
+interface LeftRailPointerState {
+  readonly railViewState: {
+    readLatestRows(): ReturnType<typeof buildWorkspaceRailViewRows>;
+  };
+  readonly conversationTitleEditConversationId: () => string | null;
+  readonly activeConversationId: () => string | null;
+  readonly repositoriesCollapsed: () => boolean;
+  readonly resolveDirectoryForAction: () => string | null;
+  readonly previousConversationClickState: () => ConversationTitleClickState | null;
+  readonly nowMs: () => number;
+  readonly isConversationPaneActive: () => boolean;
+  readonly directoriesHas: (directoryId: string) => boolean;
+}
+
+interface LeftRailPointerActions {
+  readonly clearConversationTitleEditClickState: () => void;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly queueArchiveConversation: (conversationId: string) => void;
+  readonly openAddDirectoryPrompt: () => void;
+  readonly openRepositoryPromptForCreate: () => void;
+  readonly repositoryExists: (repositoryId: string) => boolean;
+  readonly openRepositoryPromptForEdit: (repositoryId: string) => void;
+  readonly queueArchiveRepository: (repositoryId: string) => void;
+  readonly toggleRepositoryGroup: (repositoryGroupId: string) => void;
+  readonly selectLeftNavRepository: (repositoryGroupId: string) => void;
+  readonly expandAllRepositoryGroups: () => void;
+  readonly collapseAllRepositoryGroups: () => void;
+  readonly enterHomePane: () => void;
+  readonly enterNimPane?: () => void;
+  readonly enterTasksPane?: () => void;
+  readonly queueCloseDirectory: (directoryId: string) => void;
+  readonly toggleShortcutsCollapsed: () => void;
+  readonly setConversationClickState: (next: ConversationTitleClickState | null) => void;
+  readonly ensureConversationPaneActive: (conversationId: string) => void;
+  readonly beginConversationTitleEdit: (conversationId: string) => void;
+  readonly queueActivateConversation: (conversationId: string) => void;
+  readonly queueActivateConversationAndEdit: (conversationId: string) => void;
+  readonly enterProjectPane: (directoryId: string) => void;
+  readonly enterGitHubPane?: (directoryId: string) => void;
+  readonly toggleGitHubProjectExpanded?: (directoryId: string) => void;
+  readonly markDirty: () => void;
+}
+
+interface LeftRailPointerConfig {
+  readonly conversationTitleEditDoubleClickWindowMs: number;
+}
+
+export class LeftRailPointerHandler
+  implements
+    RailPointerHitResolver<LeftRailPointerHit>,
+    RailPointerHitDispatcher<LeftRailPointerHit>
+{
+  constructor(
+    private readonly state: LeftRailPointerState,
+    private readonly actions: LeftRailPointerActions,
+    private readonly config: LeftRailPointerConfig,
+  ) {}
+
+  resolveHit(rowIndex: number, colIndex: number, railCols: number): LeftRailPointerHit {
+    const rows = this.state.railViewState.readLatestRows();
+    const selectedConversationId = conversationIdAtWorkspaceRailRow(rows, rowIndex);
+    const selectedProjectId = projectIdAtWorkspaceRailRow(rows, rowIndex);
+    const selectedRepositoryId = repositoryIdAtWorkspaceRailRow(rows, rowIndex);
+    const selectedAction = actionAtWorkspaceRailCell(rows, rowIndex, colIndex, railCols);
+    const selectedRowKind = kindAtWorkspaceRailRow(rows, rowIndex);
+    return {
+      selectedConversationId,
+      selectedProjectId,
+      selectedRepositoryId,
+      selectedAction,
+      supportsConversationTitleEditClick:
+        selectedRowKind === 'conversation-title' || selectedRowKind === 'conversation-body',
+    };
+  }
+
+  shouldKeepConversationTitleEditActive(hit: LeftRailPointerHit): boolean {
+    const editConversationId = this.state.conversationTitleEditConversationId();
+    return (
+      editConversationId !== null &&
+      hit.selectedConversationId === editConversationId &&
+      hit.supportsConversationTitleEditClick
+    );
+  }
+
+  dispatchHit(hit: LeftRailPointerHit): boolean {
+    if (this.handleAction(hit)) {
+      return true;
+    }
+    this.handleConversation(hit);
+    return true;
+  }
+
+  private handleAction(hit: LeftRailPointerHit): boolean {
+    const targetDirectoryId = hit.selectedProjectId ?? this.state.resolveDirectoryForAction();
+    if (hit.selectedAction === 'conversation.new') {
+      this.actions.clearConversationTitleEditClickState();
+      if (targetDirectoryId !== null) {
+        this.actions.openNewThreadPrompt(targetDirectoryId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'conversation.delete') {
+      this.actions.clearConversationTitleEditClickState();
+      const activeConversationId = this.state.activeConversationId();
+      if (activeConversationId !== null) {
+        this.actions.queueArchiveConversation(activeConversationId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'project.add') {
+      this.actions.clearConversationTitleEditClickState();
+      this.actions.openAddDirectoryPrompt();
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'repository.add') {
+      this.actions.clearConversationTitleEditClickState();
+      this.actions.openRepositoryPromptForCreate();
+      return true;
+    }
+
+    if (hit.selectedAction === 'repository.edit') {
+      this.actions.clearConversationTitleEditClickState();
+      if (
+        hit.selectedRepositoryId !== null &&
+        this.actions.repositoryExists(hit.selectedRepositoryId)
+      ) {
+        this.actions.openRepositoryPromptForEdit(hit.selectedRepositoryId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'repository.archive') {
+      this.actions.clearConversationTitleEditClickState();
+      if (
+        hit.selectedRepositoryId !== null &&
+        this.actions.repositoryExists(hit.selectedRepositoryId)
+      ) {
+        this.actions.queueArchiveRepository(hit.selectedRepositoryId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'repository.toggle') {
+      this.actions.clearConversationTitleEditClickState();
+      if (hit.selectedRepositoryId !== null) {
+        this.actions.toggleRepositoryGroup(hit.selectedRepositoryId);
+        this.actions.selectLeftNavRepository(hit.selectedRepositoryId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'repositories.toggle') {
+      this.actions.clearConversationTitleEditClickState();
+      if (this.state.repositoriesCollapsed()) {
+        this.actions.expandAllRepositoryGroups();
+      } else {
+        this.actions.collapseAllRepositoryGroups();
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'home.open') {
+      this.actions.clearConversationTitleEditClickState();
+      this.actions.enterHomePane();
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'nim.open') {
+      this.actions.clearConversationTitleEditClickState();
+      if (this.actions.enterNimPane !== undefined) {
+        this.actions.enterNimPane();
+      } else {
+        this.actions.enterHomePane();
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'tasks.open') {
+      this.actions.clearConversationTitleEditClickState();
+      if (this.actions.enterTasksPane !== undefined) {
+        this.actions.enterTasksPane();
+      } else {
+        this.actions.enterHomePane();
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'project.close') {
+      this.actions.clearConversationTitleEditClickState();
+      if (targetDirectoryId !== null) {
+        this.actions.queueCloseDirectory(targetDirectoryId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'project.github.open') {
+      this.actions.clearConversationTitleEditClickState();
+      if (targetDirectoryId !== null && this.state.directoriesHas(targetDirectoryId)) {
+        if (this.actions.enterGitHubPane !== undefined) {
+          this.actions.enterGitHubPane(targetDirectoryId);
+        } else {
+          this.actions.enterProjectPane(targetDirectoryId);
+        }
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'project.github.toggle') {
+      this.actions.clearConversationTitleEditClickState();
+      if (
+        targetDirectoryId !== null &&
+        this.state.directoriesHas(targetDirectoryId) &&
+        this.actions.toggleGitHubProjectExpanded !== undefined
+      ) {
+        this.actions.toggleGitHubProjectExpanded(targetDirectoryId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedAction === 'shortcuts.toggle') {
+      this.actions.clearConversationTitleEditClickState();
+      this.actions.toggleShortcutsCollapsed();
+      this.actions.markDirty();
+      return true;
+    }
+
+    return false;
+  }
+
+  private handleConversation(hit: LeftRailPointerHit): boolean {
+    const conversationClick =
+      hit.selectedConversationId !== null && hit.supportsConversationTitleEditClick
+        ? detectConversationDoubleClick(
+            this.state.previousConversationClickState(),
+            hit.selectedConversationId,
+            this.state.nowMs(),
+            this.config.conversationTitleEditDoubleClickWindowMs,
+          )
+        : {
+            doubleClick: false,
+            nextState: null,
+          };
+    this.actions.setConversationClickState(conversationClick.nextState);
+
+    const activeConversationId = this.state.activeConversationId();
+    if (
+      hit.selectedConversationId !== null &&
+      hit.selectedConversationId === activeConversationId
+    ) {
+      if (!this.state.isConversationPaneActive()) {
+        if (conversationClick.doubleClick) {
+          this.actions.queueActivateConversationAndEdit(hit.selectedConversationId);
+        } else {
+          this.actions.queueActivateConversation(hit.selectedConversationId);
+        }
+      } else if (conversationClick.doubleClick) {
+        this.actions.beginConversationTitleEdit(hit.selectedConversationId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedConversationId !== null) {
+      if (conversationClick.doubleClick) {
+        this.actions.queueActivateConversationAndEdit(hit.selectedConversationId);
+      } else {
+        this.actions.queueActivateConversation(hit.selectedConversationId);
+      }
+      this.actions.markDirty();
+      return true;
+    }
+
+    if (hit.selectedProjectId !== null && this.state.directoriesHas(hit.selectedProjectId)) {
+      this.actions.setConversationClickState(null);
+      this.actions.enterProjectPane(hit.selectedProjectId);
+      this.actions.markDirty();
+      return true;
+    }
+
+    this.actions.setConversationClickState(null);
+    this.actions.markDirty();
+    return true;
+  }
+}

package/src/services/mux-ui-state-persistence.ts

@@ -2,6 +2,8 @@ export interface MuxUiStateSnapshot {
   paneWidthPercent: number;
   repositoriesCollapsed: boolean;
   shortcutsCollapsed: boolean;
+  startupPane: 'home' | 'nim';
+  showDebugBar: boolean;
 }
 
 interface MuxUiStatePersistenceOptions {
@@ -76,7 +78,9 @@ export class MuxUiStatePersistence {
     return (
       left.paneWidthPercent === right.paneWidthPercent &&
       left.repositoriesCollapsed === right.repositoriesCollapsed &&
-      left.shortcutsCollapsed === right.shortcutsCollapsed
+      left.shortcutsCollapsed === right.shortcutsCollapsed &&
+      left.startupPane === right.startupPane &&
+      left.showDebugBar === right.showDebugBar
     );
   }
 }

package/src/services/recording.ts

@@ -7,7 +7,7 @@ interface RenderTerminalRecordingToGifInput {
   readonly outputPath: string;
 }
 
-interface RecordingServiceOptions {
+export interface RecordingServiceOptions {
   readonly recordingWriter: RecordingWriter | null;
   readonly recordingPath: string | null;
   readonly recordingGifOutputPath: string | null;
@@ -17,37 +17,50 @@ interface RecordingServiceOptions {
   readonly writeStderr: (text: string) => void;
 }
 
-export class RecordingService {
-  constructor(private readonly options: RecordingServiceOptions) {}
+export interface RecordingService {
+  closeWriter(): Promise<unknown | null>;
+  finalizeAfterShutdown(recordingCloseError: unknown | null): Promise<void>;
+}
+
+export function createRecordingService(options: RecordingServiceOptions): RecordingService {
+  function formatCloseError(recordingCloseError: unknown): string {
+    if (recordingCloseError instanceof Error) {
+      return recordingCloseError.message;
+    }
+    if (typeof recordingCloseError === 'string') {
+      return recordingCloseError;
+    }
+    return 'unknown error';
+  }
 
-  async closeWriter(): Promise<unknown | null> {
-    if (this.options.recordingWriter === null) {
+  async function closeWriter(): Promise<unknown | null> {
+    if (options.recordingWriter === null) {
       return null;
     }
     try {
-      await this.options.recordingWriter.close();
+      await options.recordingWriter.close();
       return null;
     } catch (error: unknown) {
       return error;
     }
   }
 
-  async finalizeAfterShutdown(recordingCloseError: unknown | null): Promise<void> {
+  async function finalizeAfterShutdown(recordingCloseError: unknown | null): Promise<void> {
     if (
-      this.options.recordingGifOutputPath !== null &&
-      this.options.recordingPath !== null &&
+      options.recordingGifOutputPath !== null &&
+      options.recordingPath !== null &&
       recordingCloseError === null
     ) {
       try {
-        await this.options.renderTerminalRecordingToGif({
-          recordingPath: this.options.recordingPath,
-          outputPath: this.options.recordingGifOutputPath,
+        await options.renderTerminalRecordingToGif({
+          recordingPath: options.recordingPath,
+          outputPath: options.recordingGifOutputPath,
         });
-        this.options.writeStderr(
-          `[mux-recording] jsonl=${this.options.recordingPath} gif=${this.options.recordingGifOutputPath}\n`,
+        options.writeStderr(
+          `[mux-recording] jsonl=${options.recordingPath} gif=${options.recordingGifOutputPath}\n`,
         );
       } catch (error: unknown) {
-        this.options.writeStderr(
+        options.writeStderr(
           `[mux-recording] gif-export-failed ${
             error instanceof Error ? error.message : String(error)
           }\n`,
@@ -57,19 +70,14 @@ export class RecordingService {
     }
 
     if (recordingCloseError !== null) {
-      this.options.writeStderr(
-        `[mux-recording] close-failed ${this.formatCloseError(recordingCloseError)}\n`,
+      options.writeStderr(
+        `[mux-recording] close-failed ${formatCloseError(recordingCloseError)}\n`,
       );
     }
   }
 
-  private formatCloseError(recordingCloseError: unknown): string {
-    if (recordingCloseError instanceof Error) {
-      return recordingCloseError.message;
-    }
-    if (typeof recordingCloseError === 'string') {
-      return recordingCloseError;
-    }
-    return 'unknown error';
-  }
+  return {
+    closeWriter,
+    finalizeAfterShutdown,
+  };
 }

package/src/services/runtime-command-menu-agent-tools.ts

@@ -75,7 +75,7 @@ interface RuntimeCommandMenuAgentToolsOptions {
   readonly markDirty: () => void;
 }
 
-export class RuntimeCommandMenuAgentTools {
+export class RuntimeCommandMenuAgentToolsCache {
   private readonly statusByAgent = new Map<InstallableAgentType, AgentToolStatusRecord>();
 
   constructor(private readonly options: RuntimeCommandMenuAgentToolsOptions) {}

package/src/services/runtime-control-actions.ts

@@ -28,7 +28,9 @@ interface RuntimeConversationTitleRefreshResult {
 
 const THREAD_TITLE_AGENT_TYPES = new Set(['codex', 'claude', 'cursor']);
 
-interface RuntimeControlActionsOptions<TConversation extends RuntimeConversationControlState> {
+export interface RuntimeControlActionsOptions<
+  TConversation extends RuntimeConversationControlState,
+> {
   readonly conversationById: (sessionId: string) => TConversation | undefined;
   readonly interruptSession: (sessionId: string) => Promise<RuntimeInterruptResult>;
   readonly nowIso: () => string;
@@ -57,81 +59,101 @@ interface RuntimeControlActionsOptions<TConversation extends RuntimeConversation
   ) => Promise<RuntimeConversationTitleRefreshResult>;
 }
 
-export class RuntimeControlActions<TConversation extends RuntimeConversationControlState> {
-  constructor(private readonly options: RuntimeControlActionsOptions<TConversation>) {}
+export interface RuntimeControlActions {
+  interruptConversation(sessionId: string): Promise<void>;
+  toggleGatewayProfiler(): Promise<void>;
+  toggleGatewayStatusTimeline(): Promise<void>;
+  toggleGatewayRenderTrace(conversationId: string | null): Promise<void>;
+  refreshAllConversationTitles(): Promise<void>;
+}
+
+export function createRuntimeControlActions<TConversation extends RuntimeConversationControlState>(
+  options: RuntimeControlActionsOptions<TConversation>,
+): RuntimeControlActions {
+  const scopeMessage = (prefix: string, message: string): string => {
+    if (options.sessionName === null) {
+      return `[${prefix}] ${message}`;
+    }
+    return `[${prefix}:${options.sessionName}] ${message}`;
+  };
 
-  async interruptConversation(sessionId: string): Promise<void> {
-    const conversation = this.options.conversationById(sessionId);
+  const setNotices = (message: string): void => {
+    options.setTaskPaneNotice(message);
+    options.setDebugFooterNotice(message);
+  };
+
+  const interruptConversation = async (sessionId: string): Promise<void> => {
+    const conversation = options.conversationById(sessionId);
     if (conversation === undefined || !conversation.live) {
       return;
     }
-    const result = await this.options.interruptSession(sessionId);
+    const result = await options.interruptSession(sessionId);
     if (!result.interrupted) {
       return;
     }
     conversation.status = 'completed';
     conversation.attentionReason = null;
-    conversation.lastEventAt = this.options.nowIso();
-    this.options.markDirty();
-  }
+    conversation.lastEventAt = options.nowIso();
+    options.markDirty();
+  };
 
-  async toggleGatewayProfiler(): Promise<void> {
+  const toggleGatewayProfiler = async (): Promise<void> => {
     try {
-      const result = await this.options.toggleGatewayProfiler({
-        invocationDirectory: this.options.invocationDirectory,
-        sessionName: this.options.sessionName,
+      const result = await options.toggleGatewayProfiler({
+        invocationDirectory: options.invocationDirectory,
+        sessionName: options.sessionName,
       });
-      this.setNotices(this.scopeMessage('profile', result.message));
+      setNotices(scopeMessage('profile', result.message));
     } catch (error: unknown) {
       const message = error instanceof Error ? error.message : String(error);
-      this.setNotices(this.scopeMessage('profile', message));
+      setNotices(scopeMessage('profile', message));
     } finally {
-      this.options.markDirty();
+      options.markDirty();
     }
-  }
+  };
 
-  async toggleGatewayStatusTimeline(): Promise<void> {
+  const toggleGatewayStatusTimeline = async (): Promise<void> => {
     try {
-      const result = await this.options.toggleGatewayStatusTimeline({
-        invocationDirectory: this.options.invocationDirectory,
-        sessionName: this.options.sessionName,
+      const result = await options.toggleGatewayStatusTimeline({
+        invocationDirectory: options.invocationDirectory,
+        sessionName: options.sessionName,
       });
-      this.setNotices(this.scopeMessage('status-trace', result.message));
+      setNotices(scopeMessage('status-trace', result.message));
     } catch (error: unknown) {
       const message = error instanceof Error ? error.message : String(error);
-      this.setNotices(this.scopeMessage('status-trace', message));
+      setNotices(scopeMessage('status-trace', message));
     } finally {
-      this.options.markDirty();
+      options.markDirty();
     }
-  }
+  };
 
-  async toggleGatewayRenderTrace(conversationId: string | null): Promise<void> {
+  const toggleGatewayRenderTrace = async (conversationId: string | null): Promise<void> => {
     try {
-      const result = await this.options.toggleGatewayRenderTrace({
-        invocationDirectory: this.options.invocationDirectory,
-        sessionName: this.options.sessionName,
+      const result = await options.toggleGatewayRenderTrace({
+        invocationDirectory: options.invocationDirectory,
+        sessionName: options.sessionName,
         conversationId,
       });
-      this.setNotices(this.scopeMessage('render-trace', result.message));
+      setNotices(scopeMessage('render-trace', result.message));
     } catch (error: unknown) {
       const message = error instanceof Error ? error.message : String(error);
-      this.setNotices(this.scopeMessage('render-trace', message));
+      setNotices(scopeMessage('render-trace', message));
     } finally {
-      this.options.markDirty();
+      options.markDirty();
     }
-  }
+  };
 
-  async refreshAllConversationTitles(): Promise<void> {
-    const listConversationIds = this.options.listConversationIdsForTitleRefresh;
-    const resolveAgentType = this.options.conversationAgentTypeForTitleRefresh;
-    const refreshConversationTitle = this.options.refreshConversationTitle;
+  const refreshAllConversationTitles = async (): Promise<void> => {
+    const listConversationIds = options.listConversationIdsForTitleRefresh;
+    const resolveAgentType = options.conversationAgentTypeForTitleRefresh;
+    const refreshConversationTitle = options.refreshConversationTitle;
     if (
       listConversationIds === undefined ||
       resolveAgentType === undefined ||
       refreshConversationTitle === undefined
     ) {
-      this.setNotices(this.scopeMessage('thread-title', 'refresh unavailable'));
-      this.options.markDirty();
+      setNotices(scopeMessage('thread-title', 'refresh unavailable'));
+      options.markDirty();
       return;
     }
     const allConversationIds = listConversationIds();
@@ -140,16 +162,16 @@ export class RuntimeControlActions<TConversation extends RuntimeConversationCont
       return agentType !== undefined && THREAD_TITLE_AGENT_TYPES.has(agentType);
     });
     if (eligibleConversationIds.length === 0) {
-      this.setNotices(this.scopeMessage('thread-title', 'no agent threads to refresh'));
-      this.options.markDirty();
+      setNotices(scopeMessage('thread-title', 'no agent threads to refresh'));
+      options.markDirty();
       return;
     }
     const total = eligibleConversationIds.length;
     let updated = 0;
     let unchanged = 0;
     let skipped = 0;
-    this.setNotices(this.scopeMessage('thread-title', `refreshing names 0/${String(total)}`));
-    this.options.markDirty();
+    setNotices(scopeMessage('thread-title', `refreshing names 0/${String(total)}`));
+    options.markDirty();
     for (let index = 0; index < eligibleConversationIds.length; index += 1) {
       const sessionId = eligibleConversationIds[index]!;
       try {
@@ -164,29 +186,25 @@ export class RuntimeControlActions<TConversation extends RuntimeConversationCont
       } catch {
         skipped += 1;
       }
-      this.setNotices(
-        this.scopeMessage('thread-title', `refreshing names ${String(index + 1)}/${String(total)}`),
+      setNotices(
+        scopeMessage('thread-title', `refreshing names ${String(index + 1)}/${String(total)}`),
       );
-      this.options.markDirty();
+      options.markDirty();
     }
-    this.setNotices(
-      this.scopeMessage(
+    setNotices(
+      scopeMessage(
         'thread-title',
         `refreshed ${String(updated)} updated ${String(unchanged)} unchanged ${String(skipped)} skipped`,
       ),
     );
-    this.options.markDirty();
-  }
-
-  private scopeMessage(prefix: string, message: string): string {
-    if (this.options.sessionName === null) {
-      return `[${prefix}] ${message}`;
-    }
-    return `[${prefix}:${this.options.sessionName}] ${message}`;
-  }
+    options.markDirty();
+  };
 
-  private setNotices(message: string): void {
-    this.options.setTaskPaneNotice(message);
-    this.options.setDebugFooterNotice(message);
-  }
+  return {
+    interruptConversation,
+    toggleGatewayProfiler,
+    toggleGatewayStatusTimeline,
+    toggleGatewayRenderTrace,
+    refreshAllConversationTitles,
+  };
 }