@jmoyers/harness 0.1.9 → 0.1.11

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);
@@ -1300,7 +1381,18 @@ export class ControlPlaneStreamServer {
   }
 
   private pollHistoryTimerTick(): void {
-    void this.pollHistoryFile();
+    void this.pollHistoryFile().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      if (this.shouldSkipStateStoreWork()) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.history.poll.failed', {
+        error: message,
+      });
+    });
   }
 
   private stopHistoryPolling(): void {
@@ -1318,9 +1410,9 @@ export class ControlPlaneStreamServer {
       return;
     }
     this.reloadGitStatusDirectoriesFromStore();
-    void this.pollGitStatus();
+    this.triggerGitStatusPoll();
     this.gitStatusPollTimer = setInterval(() => {
-      void this.pollGitStatus();
+      this.triggerGitStatusPoll();
     }, this.gitStatusMonitor.pollMs);
     this.gitStatusPollTimer.unref();
   }
@@ -1396,9 +1488,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 +1503,85 @@ export class ControlPlaneStreamServer {
     this.githubPollTimer = null;
   }
 
+  private triggerGitHubPoll(): void {
+    void this.pollGitHub().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      if (this.shouldIgnoreGitHubPollError(error)) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.github.poll.failed', {
+        error: message,
+      });
+    });
+  }
+
+  private triggerGitStatusPoll(): void {
+    void this.pollGitStatus().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      if (this.shouldSkipStateStoreWork()) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.git-status.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') ||
+      normalized.includes('cannot use a closed database')
+    );
+  }
+
+  private markStateStoreClosedIfDetected(error: unknown): boolean {
+    if (!this.isStateStoreClosedError(error)) {
+      return false;
+    }
+    this.stateStoreClosed = true;
+    this.stopGitHubPolling();
+    this.stopGitStatusPolling();
+    this.stopHistoryPolling();
+    return true;
+  }
+
+  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.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      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,
@@ -2081,9 +2252,15 @@ export class ControlPlaneStreamServer {
   }
 
   private async pollHistoryFile(): Promise<void> {
-    await pollStreamServerHistoryFile(
-      this as unknown as Parameters<typeof pollStreamServerHistoryFile>[0],
-    );
+    try {
+      await pollStreamServerHistoryFile(
+        this as unknown as Parameters<typeof pollStreamServerHistoryFile>[0],
+      );
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
+    }
   }
 
   private async pollHistoryFileUnsafe(): Promise<boolean> {
@@ -2093,9 +2270,15 @@ export class ControlPlaneStreamServer {
   }
 
   private async pollGitStatus(): Promise<void> {
-    await pollStreamServerGitStatus(
-      this as unknown as Parameters<typeof pollStreamServerGitStatus>[0],
-    );
+    try {
+      await pollStreamServerGitStatus(
+        this as unknown as Parameters<typeof pollStreamServerGitStatus>[0],
+      );
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
+    }
   }
 
   private async refreshGitStatusForDirectory(
@@ -2112,11 +2295,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 +2315,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 +2352,35 @@ 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;
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
     } finally {
+      if (this.githubPollPromise === pollPromise) {
+        this.githubPollPromise = null;
+      }
       this.githubPollInFlight = false;
     }
   }
@@ -2192,6 +2392,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 +2403,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 +2492,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 +2554,35 @@ export class ControlPlaneStreamServer {
         lastErrorAt: null,
       });
     } catch (error: unknown) {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      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.markStateStoreClosedIfDetected(syncStateError)) {
+          return;
+        }
+        if (!this.shouldIgnoreGitHubPollError(syncStateError)) {
+          throw syncStateError;
+        }
+      }
     }
   }
 
@@ -2648,6 +2872,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 +2994,7 @@ export class ControlPlaneStreamServer {
     if (!this.shouldPublishPromptEvent(sessionId, prompt)) {
       return;
     }
+    this.recordThreadPrompt(sessionId, prompt);
     this.publishObservedEvent(scope, {
       type: 'session-prompt-event',
       sessionId,
@@ -2774,6 +3020,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 +3606,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);