fix(session): retry failed title generation (#39748)

packages/core/src/session/history.ts

@@ -117,21 +117,20 @@ export const preview = Effect.fn("SessionHistory.preview")(function* (
     .pipe(Effect.catch((error) => (error instanceof Instructions.InitializationBlocked ? error : Effect.die(error))))
 })
 
-/** Returns the session's sole user message, or `undefined` once a second one exists. */
-export const firstUserMessageIfOnly = Effect.fn("SessionHistory.firstUserMessageIfOnly")(function* (
+/** Returns the session's first user message. */
+export const firstUserMessage = Effect.fn("SessionHistory.firstUserMessage")(function* (
   db: DatabaseService,
   sessionID: SessionSchema.ID,
 ) {
-  const rows = yield* db
+  const row = yield* db
     .select()
     .from(SessionMessageTable)
     .where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "user")))
     .orderBy(asc(SessionMessageTable.seq))
-    .limit(2)
-    .all()
+    .get()
     .pipe(Effect.orDie)
-  if (rows.length !== 1) return undefined
-  const message = yield* decodeMessageRow(rows[0]).pipe(Effect.catch(() => Effect.succeed(undefined)))
+  if (!row) return undefined
+  const message = yield* decodeMessageRow(row).pipe(Effect.catch(() => Effect.succeed(undefined)))
   return message?.type === "user" ? message : undefined
 })
 

packages/core/src/session/runner/llm.ts

@@ -93,10 +93,9 @@ const layer = Layer.effect(
     const db = (yield* Database.Service).db
     const compaction = yield* SessionCompaction.Service
     const title = yield* SessionTitle.Service
-    // Title generation is a side effect of the first step; it must not delay step continuation.
-    // Tracked per process so repeated wakes before the second user message arrives don't
-    // re-fire a redundant LLM call; `SessionTitle` itself is idempotent based on durable history.
-    const titleStarted = new Set<SessionSchema.ID>()
+    // Title generation is a side effect of a successful step; it must not delay continuation.
+    // The in-flight set coalesces overlapping steps while title presence records success durably.
+    const titlesRunning = new Set<SessionSchema.ID>()
     const forkTitle = yield* FiberSet.makeRuntime<never, void, never>()
     /**
      * Drains eligible manual compaction and user input until the Session becomes idle.
@@ -125,7 +124,7 @@ const layer = Layer.effect(
       let step = 1
       while (true) {
         const result = yield* runStep(sessionID, promotable, step)
-        yield* startTitleOnce(sessionID)
+        if (step === 1) yield* startTitle(sessionID)
         yield* runPendingCompaction(sessionID)
         if (!result.needsContinuation && !(yield* SessionPending.has(db, sessionID, "steer"))) return
         promotable = "steer"
@@ -481,11 +480,20 @@ const layer = Layer.effect(
       }
     })
 
-    /** Fires title generation once per process after the first step makes a user message visible. */
-    const startTitleOnce = Effect.fnUntraced(function* (sessionID: SessionSchema.ID) {
-      if (titleStarted.has(sessionID)) return
-      titleStarted.add(sessionID)
-      forkTitle(title.generateForFirstPrompt(yield* getSession(sessionID)).pipe(Effect.ignore))
+    /** Starts one title request at a time after a successful step makes user input visible. */
+    const startTitle = Effect.fnUntraced(function* (sessionID: SessionSchema.ID) {
+      if (titlesRunning.has(sessionID)) return
+      titlesRunning.add(sessionID)
+      forkTitle(
+        title.generateForFirstPrompt(sessionID).pipe(
+          Effect.ignore,
+          Effect.ensuring(
+            Effect.sync(() => {
+              titlesRunning.delete(sessionID)
+            }),
+          ),
+        ),
+      )
     })
 
     const getSession = Effect.fn("SessionRunner.getSession")(function* (sessionID: SessionSchema.ID) {

packages/core/src/session/title.ts

@@ -1,7 +1,7 @@
 export * as SessionTitle from "./title"
 
 import { LLM, LLMClient, LLMError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
-import { Context, Effect, Layer, Stream } from "effect"
+import { Context, DateTime, Effect, Layer, Stream } from "effect"
 import { Agent } from "../agent"
 import { Database } from "../database/database"
 import { Bus } from "../bus"
@@ -14,8 +14,10 @@ import { SessionModelHeaders } from "./model-headers"
 import { SessionRunnerModel } from "./runner/model"
 import { SessionSchema } from "./schema"
 import { SessionUsage } from "./usage"
+import { SessionStore } from "./store"
 
 const MAX_LENGTH = 100
+const titleChanged = Symbol("Session title changed")
 
 type Dependencies = {
   readonly app: App.Info
@@ -25,24 +27,30 @@ type Dependencies = {
   }
   readonly agents: Agent.Interface
   readonly models: SessionRunnerModel.Interface
+  readonly store: SessionStore.Interface
 }
 
 export interface Interface {
-  /** Generates a title from the session's first user message and renames the session. Runs at most once per session. */
-  readonly generateForFirstPrompt: (session: SessionSchema.Info) => Effect.Effect<void>
+  /** Generates a title from the session's first user message when the session remains untitled. */
+  readonly generateForFirstPrompt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SessionTitle") {}
 
 const truncate = (value: string) => (value.length <= MAX_LENGTH ? value : `${value.slice(0, MAX_LENGTH - 3)}...`)
+const isUntitled = (session: SessionSchema.Info) =>
+  session.title === undefined || session.title === `New session - ${DateTime.formatIso(session.time.created)}`
 
 const make = (dependencies: Dependencies) => {
   const generateForFirstPrompt = Effect.fn("SessionTitle.generateForFirstPrompt")(function* (
     db: Database.Interface["db"],
-    session: SessionSchema.Info,
+    sessionID: SessionSchema.ID,
   ) {
+    const session = yield* dependencies.store.get(sessionID)
+    if (!session) return
     if (session.parentID) return
-    const firstUser = yield* SessionHistory.firstUserMessageIfOnly(db, session.id)
+    if (!isUntitled(session)) return
+    const firstUser = yield* SessionHistory.firstUserMessage(db, session.id)
     if (!firstUser) return
     const agent = yield* dependencies.agents.get(Agent.ID.make("title"))
     if (!agent) return
@@ -96,10 +104,19 @@ const make = (dependencies: Dependencies) => {
       .map((line) => line.trim())
       .find((line) => line.length > 0)
     if (!title) return
-    yield* dependencies.bus.publish(SessionEvent.Renamed, {
-      sessionID: session.id,
-      title: truncate(title),
-    })
+    const expectedSequence = (yield* Bus.latestSequence(db, sessionID)) + 1
+    const current = yield* dependencies.store.get(sessionID)
+    if (!current || !isUntitled(current)) return
+    yield* dependencies.bus
+      .publish(
+        SessionEvent.Renamed,
+        {
+          sessionID: session.id,
+          title: truncate(title),
+        },
+        { commit: (sequence) => (sequence === expectedSequence ? Effect.void : Effect.die(titleChanged)) },
+      )
+      .pipe(Effect.catchDefect((defect) => (defect === titleChanged ? Effect.void : Effect.die(defect))))
   })
   return { generateForFirstPrompt }
 }
@@ -111,11 +128,12 @@ export const layer = Layer.effect(
     const llm = yield* LLMClient.Service
     const agents = yield* Agent.Service
     const models = yield* SessionRunnerModel.Service
+    const store = yield* SessionStore.Service
     const database = yield* Database.Service
     const app = yield* App.Metadata
-    const title = make({ bus, llm, agents, models, app })
+    const title = make({ bus, llm, agents, models, store, app })
     return Service.of({
-      generateForFirstPrompt: (session) => title.generateForFirstPrompt(database.db, session),
+      generateForFirstPrompt: (sessionID) => title.generateForFirstPrompt(database.db, sessionID),
     })
   }),
 )
@@ -123,5 +141,5 @@ export const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node, llmClient, Agent.node, SessionRunnerModel.node, Database.node, App.node],
+  deps: [Bus.node, llmClient, Agent.node, SessionRunnerModel.node, SessionStore.node, Database.node, App.node],
 })