@jmoyers/harness 0.1.8 → 0.1.10

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

@@ -18,6 +18,7 @@ import {
   encodeStreamEnvelope,
   type StreamObservedEvent,
   type StreamSessionKeyEventRecord,
+  type StreamSessionPromptRecord,
   type StreamSessionController,
   type StreamSessionListSort,
   type StreamSessionRuntimeStatus,
@@ -83,6 +84,15 @@ import {
 } from './stream-server-session-runtime.ts';
 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,
@@ -220,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;
@@ -283,6 +301,8 @@ interface StartControlPlaneStreamServerOptions {
   githubFetch?: typeof fetch;
   readGitDirectorySnapshot?: GitDirectorySnapshotReader;
   lifecycleHooks?: HarnessLifecycleHooksConfig;
+  threadTitle?: Partial<ThreadTitleConfig>;
+  threadTitleNamer?: ThreadTitleNamer;
 }
 
 interface ConnectionState {
@@ -383,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'];
@@ -413,6 +444,8 @@ const DEFAULT_GITHUB_POLL_MS = 15_000;
 const HISTORY_POLL_JITTER_RATIO = 0.35;
 const SESSION_DIAGNOSTICS_BUCKET_MS = 10_000;
 const SESSION_DIAGNOSTICS_BUCKET_COUNT = 6;
+const PROMPT_EVENT_DEDUPE_TTL_MS = 5 * 60 * 1000;
+const MAX_PROMPT_EVENT_DEDUPE_ENTRIES = 4096;
 const DEFAULT_BOOTSTRAP_SESSION_COLS = 80;
 const DEFAULT_BOOTSTRAP_SESSION_ROWS = 24;
 const DEFAULT_TENANT_ID = 'tenant-local';
@@ -433,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 "''";
@@ -734,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) {
@@ -1054,6 +1119,11 @@ 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;
@@ -1071,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>();
@@ -1082,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';
@@ -1127,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,
@@ -1205,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);
@@ -1390,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();
   }
@@ -1405,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,
@@ -1943,6 +2073,31 @@ export class ControlPlaneStreamServer {
         event.observedAt,
       );
     }
+    if (inserted && resolvedSessionId !== null) {
+      const promptEvent = this.promptEngine.extractFromTelemetry({
+        agentType: 'codex',
+        source: event.source,
+        eventName: event.eventName,
+        summary: event.summary,
+        payload: event.payload,
+        observedAt: event.observedAt,
+      });
+      if (promptEvent !== null) {
+        const liveState = this.sessions.get(resolvedSessionId);
+        if (liveState !== undefined) {
+          this.publishSessionPromptObservedEvent(liveState, promptEvent);
+        } else {
+          const observedScope = this.observedScopeForSessionId(resolvedSessionId);
+          if (observedScope !== null) {
+            this.publishSessionPromptObservedEventForScope(
+              resolvedSessionId,
+              observedScope,
+              promptEvent,
+            );
+          }
+        }
+      }
+    }
     if (!inserted || resolvedSessionId === null) {
       return;
     }
@@ -2081,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,
@@ -2101,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) {
@@ -2135,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;
     }
   }
@@ -2161,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 {
@@ -2169,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,
@@ -2255,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(
@@ -2314,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;
+        }
+      }
     }
   }
 
@@ -2617,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],
@@ -2674,6 +2881,260 @@ export class ControlPlaneStreamServer {
     });
   }
 
+  private promptEventSecondBucket(observedAt: string): string {
+    const normalized = observedAt.trim();
+    if (normalized.length >= 19) {
+      return normalized.slice(0, 19);
+    }
+    return normalized;
+  }
+
+  private shouldPublishPromptEvent(sessionId: string, prompt: StreamSessionPromptRecord): boolean {
+    const bucket = this.promptEventSecondBucket(prompt.observedAt);
+    const dedupeKey = `${sessionId}:${prompt.hash}:${prompt.providerEventName ?? ''}:${bucket}`;
+    if (this.promptEventDedupeByKey.has(dedupeKey)) {
+      return false;
+    }
+    const nowMs = Date.now();
+    this.promptEventDedupeByKey.set(dedupeKey, nowMs);
+    if (this.promptEventDedupeByKey.size > MAX_PROMPT_EVENT_DEDUPE_ENTRIES) {
+      for (const [key, observedMs] of this.promptEventDedupeByKey) {
+        if (nowMs - observedMs > PROMPT_EVENT_DEDUPE_TTL_MS) {
+          this.promptEventDedupeByKey.delete(key);
+        }
+      }
+      if (this.promptEventDedupeByKey.size > MAX_PROMPT_EVENT_DEDUPE_ENTRIES) {
+        let dropCount = this.promptEventDedupeByKey.size - MAX_PROMPT_EVENT_DEDUPE_ENTRIES;
+        for (const key of this.promptEventDedupeByKey.keys()) {
+          this.promptEventDedupeByKey.delete(key);
+          dropCount -= 1;
+          if (dropCount <= 0) {
+            break;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  private publishSessionPromptObservedEventForScope(
+    sessionId: string,
+    scope: StreamObservedScope,
+    prompt: StreamSessionPromptRecord,
+  ): void {
+    if (!this.shouldPublishPromptEvent(sessionId, prompt)) {
+      return;
+    }
+    this.recordThreadPrompt(sessionId, prompt);
+    this.publishObservedEvent(scope, {
+      type: 'session-prompt-event',
+      sessionId,
+      prompt: {
+        text: prompt.text,
+        hash: prompt.hash,
+        confidence: prompt.confidence,
+        captureSource: prompt.captureSource,
+        providerEventName: prompt.providerEventName,
+        providerPayloadKeys: [...prompt.providerPayloadKeys],
+        observedAt: prompt.observedAt,
+      },
+      ts: new Date().toISOString(),
+      directoryId: scope.directoryId,
+      conversationId: scope.conversationId,
+    });
+  }
+
+  private publishSessionPromptObservedEvent(
+    state: SessionState,
+    prompt: StreamSessionPromptRecord,
+  ): void {
+    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,
@@ -3076,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);
@@ -3212,6 +3675,9 @@ export class ControlPlaneStreamServer {
     if (event.type === 'session-key-event') {
       return event.sessionId;
     }
+    if (event.type === 'session-prompt-event') {
+      return event.sessionId;
+    }
     if (event.type === 'session-control') {
       return event.sessionId;
     }