@jmoyers/harness 0.1.9 → 0.1.10

package/src/control-plane/stream-server.ts

@@ -85,6 +85,14 @@ import {
 import { closeOwnedStateStore as closeOwnedStreamServerStateStore } from './stream-server-state-store.ts';
 import { SessionStatusEngine } from './status/session-status-engine.ts';
 import { SessionPromptEngine } from './prompt/session-prompt-engine.ts';
+import {
+  appendThreadTitlePromptHistory,
+  createAnthropicThreadTitleNamer,
+  fallbackThreadTitleFromPromptHistory,
+  normalizeThreadTitleCandidate,
+  readThreadTitlePromptHistory,
+  type ThreadTitleNamer,
+} from './prompt/thread-title-namer.ts';
 import {
   eventIncludesRepositoryId as filterEventIncludesRepositoryId,
   eventIncludesTaskId as filterEventIncludesTaskId,
@@ -222,6 +230,14 @@ interface GitHubIntegrationConfig {
   readonly viewerLogin: string | null;
 }
 
+interface ThreadTitleConfig {
+  readonly enabled: boolean;
+  readonly apiKey: string | null;
+  readonly modelId: string | null;
+  readonly baseUrl: string | null;
+  readonly fetch: typeof fetch | null;
+}
+
 interface GitHubRemotePullRequest {
   readonly number: number;
   readonly title: string;
@@ -285,6 +301,8 @@ interface StartControlPlaneStreamServerOptions {
   githubFetch?: typeof fetch;
   readGitDirectorySnapshot?: GitDirectorySnapshotReader;
   lifecycleHooks?: HarnessLifecycleHooksConfig;
+  threadTitle?: Partial<ThreadTitleConfig>;
+  threadTitleNamer?: ThreadTitleNamer;
 }
 
 interface ConnectionState {
@@ -385,6 +403,17 @@ interface StreamJournalEntry {
   event: StreamObservedEvent;
 }
 
+interface ThreadTitleRefreshState {
+  inFlight: boolean;
+  pending: boolean;
+}
+
+interface ThreadTitleRefreshResult {
+  readonly status: 'updated' | 'unchanged' | 'skipped';
+  readonly conversation: ControlPlaneConversationRecord | null;
+  readonly reason: string | null;
+}
+
 interface DirectoryGitStatusCacheEntry {
   readonly summary: GitDirectorySnapshot['summary'];
   readonly repositorySnapshot: GitDirectorySnapshot['repository'];
@@ -437,12 +466,17 @@ const DEFAULT_AGENT_INSTALL_COMMANDS: Readonly<Record<AgentToolType, string | nu
 const DEFAULT_CURSOR_HOOK_RELAY_SCRIPT_PATH = fileURLToPath(
   new URL('../../scripts/cursor-hook-relay.ts', import.meta.url),
 );
+const THREAD_TITLE_AGENT_TYPES = new Set(['codex', 'claude', 'cursor']);
 const LIFECYCLE_TELEMETRY_EVENT_NAMES = new Set([
   'codex.user_prompt',
   'codex.turn.e2e_duration_ms',
   'codex.conversation_starts',
 ]);
 
+function isThreadTitleAgentType(agentType: string): boolean {
+  return THREAD_TITLE_AGENT_TYPES.has(agentType.trim().toLowerCase());
+}
+
 function shellEscape(value: string): string {
   if (value.length === 0) {
     return "''";
@@ -738,6 +772,33 @@ function normalizeGitHubIntegrationConfig(
   };
 }
 
+function normalizeThreadTitleConfig(
+  input: Partial<ThreadTitleConfig> | undefined,
+): ThreadTitleConfig {
+  const envApiKeyRaw = process.env.ANTHROPIC_API_KEY;
+  const envApiKey =
+    typeof envApiKeyRaw === 'string' && envApiKeyRaw.trim().length > 0 ? envApiKeyRaw.trim() : null;
+  const apiKeyRaw = input?.apiKey ?? envApiKey;
+  const apiKey =
+    typeof apiKeyRaw === 'string' && apiKeyRaw.trim().length > 0 ? apiKeyRaw.trim() : null;
+  const envModelRaw = process.env.HARNESS_THREAD_TITLE_MODEL;
+  const modelFromEnv =
+    typeof envModelRaw === 'string' && envModelRaw.trim().length > 0 ? envModelRaw.trim() : null;
+  const modelIdRaw = input?.modelId ?? modelFromEnv;
+  const modelId =
+    typeof modelIdRaw === 'string' && modelIdRaw.trim().length > 0 ? modelIdRaw.trim() : null;
+  const baseUrlRaw = input?.baseUrl;
+  const baseUrl =
+    typeof baseUrlRaw === 'string' && baseUrlRaw.trim().length > 0 ? baseUrlRaw.trim() : null;
+  return {
+    enabled: input?.enabled ?? apiKey !== null,
+    apiKey,
+    modelId,
+    baseUrl,
+    fetch: input?.fetch ?? null,
+  };
+}
+
 function parseGitHubOwnerRepoFromRemote(remoteUrl: string): { owner: string; repo: string } | null {
   const trimmed = remoteUrl.trim();
   if (trimmed.length === 0) {
@@ -1059,7 +1120,10 @@ export class ControlPlaneStreamServer {
   private readonly readGitDirectorySnapshot: GitDirectorySnapshotReader;
   private readonly statusEngine = new SessionStatusEngine();
   private readonly promptEngine = new SessionPromptEngine();
+  private readonly threadTitleNamer: ThreadTitleNamer | null;
   private readonly promptEventDedupeByKey = new Map<string, number>();
+  private readonly threadTitleRevisionBySessionId = new Map<string, number>();
+  private readonly threadTitleRefreshBySessionId = new Map<string, ThreadTitleRefreshState>();
   private readonly server: Server;
   private readonly telemetryServer: HttpServer | null;
   private telemetryAddress: AddressInfo | null = null;
@@ -1077,6 +1141,7 @@ export class ControlPlaneStreamServer {
   private githubTokenResolutionError: string | null = null;
   private gitStatusPollInFlight = false;
   private githubPollInFlight = false;
+  private githubPollPromise: Promise<void> | null = null;
   private readonly gitStatusRefreshInFlightDirectoryIds = new Set<string>();
   private readonly gitStatusByDirectoryId = new Map<string, DirectoryGitStatusCacheEntry>();
   private readonly gitStatusDirectoriesById = new Map<string, ControlPlaneDirectoryRecord>();
@@ -1088,6 +1153,7 @@ export class ControlPlaneStreamServer {
   private streamCursor = 0;
   private listening = false;
   private stateStoreClosed = false;
+  private closing = false;
 
   constructor(options: StartControlPlaneStreamServerOptions = {}) {
     this.host = options.host ?? '127.0.0.1';
@@ -1133,6 +1199,19 @@ export class ControlPlaneStreamServer {
         await readGitDirectorySnapshot(cwd, undefined, {
           includeCommitCount: false,
         }));
+    const threadTitleConfig = normalizeThreadTitleConfig(options.threadTitle);
+    if (options.threadTitleNamer !== undefined) {
+      this.threadTitleNamer = options.threadTitleNamer;
+    } else if (threadTitleConfig.enabled && threadTitleConfig.apiKey !== null) {
+      this.threadTitleNamer = createAnthropicThreadTitleNamer({
+        apiKey: threadTitleConfig.apiKey,
+        ...(threadTitleConfig.modelId === null ? {} : { modelId: threadTitleConfig.modelId }),
+        ...(threadTitleConfig.baseUrl === null ? {} : { baseUrl: threadTitleConfig.baseUrl }),
+        ...(threadTitleConfig.fetch === null ? {} : { fetch: threadTitleConfig.fetch }),
+      });
+    } else {
+      this.threadTitleNamer = null;
+    }
     this.lifecycleHooks = new LifecycleHooksRuntime(
       options.lifecycleHooks ?? {
         enabled: false,
@@ -1211,9 +1290,11 @@ export class ControlPlaneStreamServer {
   }
 
   async close(): Promise<void> {
+    this.closing = true;
     this.stopHistoryPolling();
     this.stopGitStatusPolling();
     this.stopGitHubPolling();
+    await this.waitForGitHubPollingToSettle();
 
     for (const sessionId of [...this.sessions.keys()]) {
       this.destroySession(sessionId, true);
@@ -1396,9 +1477,9 @@ export class ControlPlaneStreamServer {
     if (!this.github.enabled || this.githubPollTimer !== null) {
       return;
     }
-    void this.pollGitHub();
+    this.triggerGitHubPoll();
     this.githubPollTimer = setInterval(() => {
-      void this.pollGitHub();
+      this.triggerGitHubPoll();
     }, this.github.pollMs);
     this.githubPollTimer.unref();
   }
@@ -1411,6 +1492,49 @@ export class ControlPlaneStreamServer {
     this.githubPollTimer = null;
   }
 
+  private triggerGitHubPoll(): void {
+    void this.pollGitHub().catch((error: unknown) => {
+      if (this.shouldIgnoreGitHubPollError(error)) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.github.poll.failed', {
+        error: message,
+      });
+    });
+  }
+
+  private isStateStoreClosedError(error: unknown): boolean {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.trim().toLowerCase();
+    return normalized.includes('database has closed') || normalized.includes('database is closed');
+  }
+
+  private shouldSkipStateStoreWork(): boolean {
+    return this.closing || this.stateStoreClosed;
+  }
+
+  private shouldIgnoreGitHubPollError(error: unknown): boolean {
+    return this.shouldSkipStateStoreWork() || this.isStateStoreClosedError(error);
+  }
+
+  private async waitForGitHubPollingToSettle(): Promise<void> {
+    const pollPromise = this.githubPollPromise;
+    if (pollPromise === null) {
+      return;
+    }
+    try {
+      await pollPromise;
+    } catch (error: unknown) {
+      if (!this.shouldIgnoreGitHubPollError(error)) {
+        const message = error instanceof Error ? error.message : String(error);
+        recordPerfEvent('control-plane.github.poll.failed-on-close', {
+          error: message,
+        });
+      }
+    }
+  }
+
   private reloadGitStatusDirectoriesFromStore(): void {
     const directories = this.stateStore.listDirectories({
       includeArchived: false,
@@ -2112,11 +2236,11 @@ export class ControlPlaneStreamServer {
   }
 
   private async pollGitHub(): Promise<void> {
-    if (!this.github.enabled || this.githubPollInFlight) {
+    if (!this.github.enabled || this.githubPollInFlight || this.shouldSkipStateStoreWork()) {
       return;
     }
     this.githubPollInFlight = true;
-    try {
+    const pollPromise = (async () => {
       const directories = this.stateStore.listDirectories({
         includeArchived: false,
         limit: 1000,
@@ -2132,6 +2256,9 @@ export class ControlPlaneStreamServer {
         }
       >();
       for (const directory of directories) {
+        if (this.shouldSkipStateStoreWork()) {
+          return;
+        }
         const gitStatus = this.gitStatusByDirectoryId.get(directory.directoryId);
         const repositoryId = gitStatus?.repositoryId ?? null;
         if (repositoryId === null) {
@@ -2166,21 +2293,31 @@ export class ControlPlaneStreamServer {
           branchName,
         });
       }
-      if (targetsByKey.size === 0) {
+      if (targetsByKey.size === 0 || this.shouldSkipStateStoreWork()) {
         return;
       }
       const token = this.github.token ?? (await this.resolveGitHubTokenIfNeeded());
-      if (token === null) {
+      if (token === null || this.shouldSkipStateStoreWork()) {
         return;
       }
       await runWithConcurrencyLimit(
         [...targetsByKey.values()],
         this.github.maxConcurrency,
         async (target) => {
+          if (this.shouldSkipStateStoreWork()) {
+            return;
+          }
           await this.syncGitHubBranch(target);
         },
       );
+    })();
+    this.githubPollPromise = pollPromise;
+    try {
+      await pollPromise;
     } finally {
+      if (this.githubPollPromise === pollPromise) {
+        this.githubPollPromise = null;
+      }
       this.githubPollInFlight = false;
     }
   }
@@ -2192,6 +2329,9 @@ export class ControlPlaneStreamServer {
     repo: string;
     branchName: string;
   }): Promise<void> {
+    if (this.shouldSkipStateStoreWork()) {
+      return;
+    }
     const now = new Date().toISOString();
     const syncStateId = `github-sync:${input.repository.repositoryId}:${input.directory.directoryId}:${input.branchName}`;
     try {
@@ -2200,6 +2340,9 @@ export class ControlPlaneStreamServer {
         repo: input.repo,
         headBranch: input.branchName,
       });
+      if (this.shouldSkipStateStoreWork()) {
+        return;
+      }
       if (remotePr === null) {
         const staleOpen = this.stateStore.listGitHubPullRequests({
           repositoryId: input.repository.repositoryId,
@@ -2286,6 +2429,9 @@ export class ControlPlaneStreamServer {
         repo: input.repo,
         headSha: storedPr.headSha,
       });
+      if (this.shouldSkipStateStoreWork()) {
+        return;
+      }
       const rollup = summarizeGitHubCiRollup(jobs);
       const updatedPr =
         this.stateStore.updateGitHubPullRequestCiRollup(
@@ -2345,20 +2491,29 @@ export class ControlPlaneStreamServer {
         lastErrorAt: null,
       });
     } catch (error: unknown) {
+      if (this.shouldIgnoreGitHubPollError(error)) {
+        return;
+      }
       const message = error instanceof Error ? error.message : String(error);
-      this.stateStore.upsertGitHubSyncState({
-        stateId: syncStateId,
-        tenantId: input.directory.tenantId,
-        userId: input.directory.userId,
-        workspaceId: input.directory.workspaceId,
-        repositoryId: input.repository.repositoryId,
-        directoryId: input.directory.directoryId,
-        branchName: input.branchName,
-        lastSyncAt: now,
-        lastSuccessAt: null,
-        lastError: message,
-        lastErrorAt: now,
-      });
+      try {
+        this.stateStore.upsertGitHubSyncState({
+          stateId: syncStateId,
+          tenantId: input.directory.tenantId,
+          userId: input.directory.userId,
+          workspaceId: input.directory.workspaceId,
+          repositoryId: input.repository.repositoryId,
+          directoryId: input.directory.directoryId,
+          branchName: input.branchName,
+          lastSyncAt: now,
+          lastSuccessAt: null,
+          lastError: message,
+          lastErrorAt: now,
+        });
+      } catch (syncStateError: unknown) {
+        if (!this.shouldIgnoreGitHubPollError(syncStateError)) {
+          throw syncStateError;
+        }
+      }
     }
   }
 
@@ -2648,6 +2803,27 @@ export class ControlPlaneStreamServer {
     );
   }
 
+  private async refreshConversationTitle(conversationId: string): Promise<{
+    conversation: ControlPlaneConversationRecord;
+    status: 'updated' | 'unchanged' | 'skipped';
+    reason: string | null;
+  }> {
+    const existing = this.stateStore.getConversation(conversationId);
+    if (existing === null) {
+      throw new Error(`conversation not found: ${conversationId}`);
+    }
+    const refreshed = await this.refreshThreadTitle(conversationId);
+    const conversation = this.stateStore.getConversation(conversationId);
+    if (conversation === null) {
+      throw new Error(`conversation not found: ${conversationId}`);
+    }
+    return {
+      conversation,
+      status: refreshed.status,
+      reason: refreshed.reason,
+    };
+  }
+
   private handleInput(connectionId: string, sessionId: string, dataBase64: string): void {
     handleRuntimeInput(
       this as unknown as Parameters<typeof handleRuntimeInput>[0],
@@ -2749,6 +2925,7 @@ export class ControlPlaneStreamServer {
     if (!this.shouldPublishPromptEvent(sessionId, prompt)) {
       return;
     }
+    this.recordThreadPrompt(sessionId, prompt);
     this.publishObservedEvent(scope, {
       type: 'session-prompt-event',
       sessionId,
@@ -2774,6 +2951,190 @@ export class ControlPlaneStreamServer {
     this.publishSessionPromptObservedEventForScope(state.id, this.sessionScope(state), prompt);
   }
 
+  private recordThreadPrompt(sessionId: string, prompt: StreamSessionPromptRecord): void {
+    const conversation = this.stateStore.getConversation(sessionId);
+    if (conversation === null) {
+      this.threadTitleRevisionBySessionId.delete(sessionId);
+      this.threadTitleRefreshBySessionId.delete(sessionId);
+      return;
+    }
+    if (!isThreadTitleAgentType(conversation.agentType)) {
+      return;
+    }
+    const appended = appendThreadTitlePromptHistory(conversation.adapterState, prompt);
+    if (!appended.added) {
+      return;
+    }
+    this.stateStore.updateConversationAdapterState(sessionId, appended.nextAdapterState);
+    const liveState = this.sessions.get(sessionId);
+    if (liveState !== undefined) {
+      liveState.adapterState = appended.nextAdapterState;
+    }
+    const nextRevision = (this.threadTitleRevisionBySessionId.get(sessionId) ?? 0) + 1;
+    this.threadTitleRevisionBySessionId.set(sessionId, nextRevision);
+    if (this.threadTitleNamer !== null) {
+      this.scheduleThreadTitleRefresh(sessionId);
+    }
+  }
+
+  private scheduleThreadTitleRefresh(sessionId: string): void {
+    const state = this.threadTitleRefreshBySessionId.get(sessionId) ?? {
+      inFlight: false,
+      pending: false,
+    };
+    this.threadTitleRefreshBySessionId.set(sessionId, state);
+    if (state.inFlight) {
+      state.pending = true;
+      return;
+    }
+    state.inFlight = true;
+    state.pending = false;
+    void this.runThreadTitleRefreshLoop(sessionId, state);
+  }
+
+  private async runThreadTitleRefreshLoop(
+    sessionId: string,
+    refreshState: ThreadTitleRefreshState,
+  ): Promise<void> {
+    let shouldReschedule = false;
+    try {
+      while (true) {
+        refreshState.pending = false;
+        const revision = this.threadTitleRevisionBySessionId.get(sessionId) ?? 0;
+        if (revision <= 0) {
+          return;
+        }
+        await this.refreshThreadTitleForRevision(sessionId, revision);
+        const latestRevision = this.threadTitleRevisionBySessionId.get(sessionId) ?? 0;
+        if (!refreshState.pending && latestRevision === revision) {
+          return;
+        }
+      }
+    } finally {
+      refreshState.inFlight = false;
+      shouldReschedule = refreshState.pending;
+      if (!shouldReschedule) {
+        this.threadTitleRefreshBySessionId.delete(sessionId);
+      }
+    }
+    if (shouldReschedule) {
+      this.scheduleThreadTitleRefresh(sessionId);
+    }
+  }
+
+  private async refreshThreadTitle(
+    sessionId: string,
+    expectedRevision?: number,
+  ): Promise<ThreadTitleRefreshResult> {
+    if (this.threadTitleNamer === null) {
+      return {
+        status: 'skipped',
+        conversation: this.stateStore.getConversation(sessionId),
+        reason: 'thread-title-namer-disabled',
+      };
+    }
+    const conversation = this.stateStore.getConversation(sessionId);
+    if (conversation === null) {
+      if (expectedRevision !== undefined) {
+        this.threadTitleRevisionBySessionId.delete(sessionId);
+      }
+      return {
+        status: 'skipped',
+        conversation: null,
+        reason: 'conversation-not-found',
+      };
+    }
+    if (!isThreadTitleAgentType(conversation.agentType)) {
+      return {
+        status: 'skipped',
+        conversation,
+        reason: 'non-agent-thread',
+      };
+    }
+    const promptHistory = readThreadTitlePromptHistory(conversation.adapterState);
+    if (promptHistory.length === 0) {
+      return {
+        status: 'skipped',
+        conversation,
+        reason: 'prompt-history-empty',
+      };
+    }
+
+    let suggestedTitle: string | null = null;
+    try {
+      suggestedTitle = await this.threadTitleNamer.suggest({
+        conversationId: conversation.conversationId,
+        agentType: conversation.agentType,
+        currentTitle: conversation.title,
+        promptHistory,
+      });
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.thread-title.error', {
+        sessionId,
+        error: message,
+      });
+    }
+
+    if (expectedRevision !== undefined) {
+      const latestRevision = this.threadTitleRevisionBySessionId.get(sessionId) ?? 0;
+      if (latestRevision !== expectedRevision) {
+        return {
+          status: 'skipped',
+          conversation,
+          reason: 'stale-revision',
+        };
+      }
+    }
+
+    const nextTitle =
+      (suggestedTitle === null ? null : normalizeThreadTitleCandidate(suggestedTitle)) ??
+      fallbackThreadTitleFromPromptHistory(promptHistory);
+    if (conversation.title === nextTitle) {
+      return {
+        status: 'unchanged',
+        conversation,
+        reason: null,
+      };
+    }
+    const updated = this.stateStore.updateConversationTitle(sessionId, nextTitle);
+    if (updated === null) {
+      return {
+        status: 'skipped',
+        conversation: null,
+        reason: 'conversation-not-found',
+      };
+    }
+    this.publishConversationUpdatedObservedEvent(updated);
+    return {
+      status: 'updated',
+      conversation: updated,
+      reason: null,
+    };
+  }
+
+  private async refreshThreadTitleForRevision(sessionId: string, revision: number): Promise<void> {
+    await this.refreshThreadTitle(sessionId, revision);
+  }
+
+  private publishConversationUpdatedObservedEvent(
+    conversation: ControlPlaneConversationRecord,
+  ): void {
+    this.publishObservedEvent(
+      {
+        tenantId: conversation.tenantId,
+        userId: conversation.userId,
+        workspaceId: conversation.workspaceId,
+        directoryId: conversation.directoryId,
+        conversationId: conversation.conversationId,
+      },
+      {
+        type: 'conversation-updated',
+        conversation: this.conversationRecord(conversation),
+      },
+    );
+  }
+
   private setSessionStatus(
     state: SessionState,
     status: StreamSessionRuntimeStatus,
@@ -3176,6 +3537,8 @@ export class ControlPlaneStreamServer {
 
     this.sessions.delete(sessionId);
     this.launchCommandBySessionId.delete(sessionId);
+    this.threadTitleRevisionBySessionId.delete(sessionId);
+    this.threadTitleRefreshBySessionId.delete(sessionId);
     for (const [token, mappedSessionId] of this.telemetryTokenToSessionId.entries()) {
       if (mappedSessionId === sessionId) {
         this.telemetryTokenToSessionId.delete(token);

package/src/mux/input-shortcuts.ts

@@ -9,6 +9,7 @@ type MuxGlobalShortcutAction =
   | 'mux.conversation.critique.open-or-create'
   | 'mux.conversation.next'
   | 'mux.conversation.previous'
+  | 'mux.conversation.titles.refresh-all'
   | 'mux.conversation.interrupt'
   | 'mux.conversation.archive'
   | 'mux.conversation.takeover'
@@ -47,6 +48,7 @@ const ACTION_ORDER: readonly MuxGlobalShortcutAction[] = [
   'mux.conversation.critique.open-or-create',
   'mux.conversation.next',
   'mux.conversation.previous',
+  'mux.conversation.titles.refresh-all',
   'mux.conversation.interrupt',
   'mux.conversation.archive',
   'mux.conversation.takeover',
@@ -68,6 +70,7 @@ const DEFAULT_MUX_SHORTCUT_BINDINGS_RAW: Readonly<
   'mux.conversation.critique.open-or-create': ['ctrl+g'],
   'mux.conversation.next': ['ctrl+j'],
   'mux.conversation.previous': ['ctrl+k'],
+  'mux.conversation.titles.refresh-all': ['ctrl+r'],
   'mux.conversation.interrupt': [],
   'mux.conversation.archive': [],
   'mux.conversation.takeover': ['ctrl+l'],
@@ -580,6 +583,9 @@ function withDefaultBindings(
     'mux.conversation.previous':
       overrides?.['mux.conversation.previous'] ??
       DEFAULT_MUX_SHORTCUT_BINDINGS_RAW['mux.conversation.previous'],
+    'mux.conversation.titles.refresh-all':
+      overrides?.['mux.conversation.titles.refresh-all'] ??
+      DEFAULT_MUX_SHORTCUT_BINDINGS_RAW['mux.conversation.titles.refresh-all'],
     'mux.conversation.interrupt':
       overrides?.['mux.conversation.interrupt'] ??
       DEFAULT_MUX_SHORTCUT_BINDINGS_RAW['mux.conversation.interrupt'],
@@ -625,6 +631,9 @@ export function resolveMuxShortcutBindings(
       ),
       'mux.conversation.next': parseBindingsForAction(rawByAction['mux.conversation.next']),
       'mux.conversation.previous': parseBindingsForAction(rawByAction['mux.conversation.previous']),
+      'mux.conversation.titles.refresh-all': parseBindingsForAction(
+        rawByAction['mux.conversation.titles.refresh-all'],
+      ),
       'mux.conversation.interrupt': parseBindingsForAction(
         rawByAction['mux.conversation.interrupt'],
       ),

package/src/mux/live-mux/git-parsing.ts

@@ -98,6 +98,30 @@ export function shouldShowGitHubPrActions(input: {
   return normalizedTrackedBranch !== 'main';
 }
 
+function normalizeTrackedBranchForActions(value: string | null): string | null {
+  const trimmed = value?.trim() ?? '';
+  if (
+    trimmed.length === 0 ||
+    trimmed === '(detached)' ||
+    trimmed === '(loading)' ||
+    trimmed === 'HEAD'
+  ) {
+    return null;
+  }
+  return trimmed;
+}
+
+export function resolveGitHubTrackedBranchForActions(input: {
+  projectTrackedBranch: string | null;
+  currentBranch: string | null;
+}): string | null {
+  const trackedBranch = normalizeTrackedBranchForActions(input.projectTrackedBranch);
+  if (trackedBranch !== null) {
+    return trackedBranch;
+  }
+  return normalizeTrackedBranchForActions(input.currentBranch);
+}
+
 export function parseCommitCount(output: string): number | null {
   const trimmed = output.trim();
   if (trimmed.length === 0 || !/^\d+$/u.test(trimmed)) {

package/src/mux/live-mux/global-shortcut-handlers.ts

@@ -14,6 +14,7 @@ interface HandleGlobalShortcutOptions {
   conversationsHas: (sessionId: string) => boolean;
   queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
   archiveConversation: (sessionId: string) => Promise<void>;
+  refreshAllConversationTitles: () => Promise<void>;
   interruptConversation: (sessionId: string) => Promise<void>;
   takeoverConversation: (sessionId: string) => Promise<void>;
   openAddDirectoryPrompt: () => void;
@@ -37,6 +38,7 @@ export function handleGlobalShortcut(options: HandleGlobalShortcutOptions): bool
     conversationsHas,
     queueControlPlaneOp,
     archiveConversation,
+    refreshAllConversationTitles,
     interruptConversation,
     takeoverConversation,
     openAddDirectoryPrompt,
@@ -104,6 +106,12 @@ export function handleGlobalShortcut(options: HandleGlobalShortcutOptions): bool
     }
     return true;
   }
+  if (shortcut === 'mux.conversation.titles.refresh-all') {
+    queueControlPlaneOp(async () => {
+      await refreshAllConversationTitles();
+    }, 'shortcut-refresh-conversation-titles');
+    return true;
+  }
   if (shortcut === 'mux.conversation.interrupt') {
     const targetConversationId = resolveConversationForAction();
     if (targetConversationId !== null && conversationsHas(targetConversationId)) {