From b2d6a80ef94527e26196cf9159b592627c699188 Mon Sep 17 00:00:00 2001
From: Haider <haider@altimate.ai>
Date: Fri, 6 Nov 2026 20:35:28 +0530
Subject: [PATCH 1/4] fix(session): retry a failed session title on later turns
 and report why it failed

A session whose first title request fails kept `New session - <time>` for
the rest of its life: `ensureTitle` ran only when the session had exactly
one user message, and the log line for the failure carried the AI SDK's
generic "No output generated. Check the stream for errors." rather than the
provider's error. A field report after 0.12.8 (placeholder titles on every
new TUI session) could not be diagnosed from the log or from telemetry.

- `ensureTitle` runs on every turn while the title still matches the
  placeholder pattern, up to the fifth user message, always with the first
  message as context, so a transient failure heals on the next turn and a
  permanently broken small model stops costing requests after five.
- The title call reads the stream itself and records the provider's error
  (class name, keyword class, HTTP status) in the `failed to generate title`
  log line and in a new `title_generation_failed` telemetry event. No
  message text is sent.
- `TestLLMServer.title(...)` queues answers for title requests so tests can
  make title generation fail; the automatic "E2E Title" remains the default.
- Docs: the event is in the telemetry catalogue, and the models page says
  what `small_model` drives and how a bad value shows up.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 docs/docs/configure/models.md                 |   2 +
 docs/docs/reference/telemetry.md              |   2 +
 .../opencode/src/altimate/telemetry/index.ts  |  17 ++
 packages/opencode/src/session/prompt.ts       |  79 ++++--
 packages/opencode/test/lib/llm-server.ts      |  21 ++
 .../opencode/test/session/title-retry.test.ts | 246 ++++++++++++++++++
 .../opencode/test/telemetry/telemetry.test.ts |   3 +-
 7 files changed, 351 insertions(+), 19 deletions(-)
 create mode 100644 packages/opencode/test/session/title-retry.test.ts

diff --git a/docs/docs/configure/models.md b/docs/docs/configure/models.md
index efd8ef0ae2..3905baed40 100644
--- a/docs/docs/configure/models.md
+++ b/docs/docs/configure/models.md
@@ -18,6 +18,8 @@ altimate supports models from all configured providers. Use the `model` and `sma
 
 The model format is `provider/model-name`.
 
+`small_model` handles the background requests that are not part of the conversation: the session title, prompt enhancement and context compaction. When it is not set, Altimate Code picks a cheap model from the same provider (Claude Haiku, Gemini Flash or GPT-5 nano when the provider lists one) and otherwise uses the chat model. A `small_model` the provider cannot serve fails only these background requests: chat keeps working, while new sessions keep their `New session - <time>` placeholder title and compaction fails. Altimate Code retries the title on the next turns and reports the failure in telemetry.
+
 ## Browsing Models
 
 In the TUI:
diff --git a/docs/docs/reference/telemetry.md b/docs/docs/reference/telemetry.md
index 2fd4ae6584..0bcec29e50 100644
--- a/docs/docs/reference/telemetry.md
+++ b/docs/docs/reference/telemetry.md
@@ -24,6 +24,7 @@ We collect the following categories of events:
 | `auth_logout` | A user logs out (provider only) |
 | `mcp_server_status` | An MCP server connects, disconnects, or errors (server name and transport) |
 | `provider_error` | An AI provider returns an error (error type and HTTP status, but no request content) |
+| `title_generation_failed` | A session-title request failed, so the session keeps its `New session - <time>` placeholder until a later turn's retry succeeds. Provider, model, which user message triggered the attempt, error class and type, HTTP status when there was one. No message text. |
 | `engine_started` | The native tool engine initializes (version and duration) |
 | `engine_error` | The native tool engine fails to start (phase and truncated error) |
 | `upgrade_attempted` | A CLI upgrade is attempted (version and method) |
@@ -251,6 +252,7 @@ Event type names use **snake_case** with a `domain_action` pattern:
 - `mcp_server_status`, `mcp_server_census` for MCP server lifecycle
 - `engine_started`, `engine_error` for native engine events
 - `provider_error` for AI provider errors
+- `title_generation_failed` for a session-title request the small model did not answer
 - `session_forked` for session lifecycle
 - `environment_census` for environment snapshot events
 - `context_utilization`, `context_overflow_recovered` for context management events
diff --git a/packages/opencode/src/altimate/telemetry/index.ts b/packages/opencode/src/altimate/telemetry/index.ts
index b8051f90c9..844e8f00f0 100644
--- a/packages/opencode/src/altimate/telemetry/index.ts
+++ b/packages/opencode/src/altimate/telemetry/index.ts
@@ -428,6 +428,23 @@ export namespace Telemetry {
         error_message: string
         http_status?: number
       }
+    // altimate_change start — a session-title request failed, so the session keeps its
+    // `New session - <time>` placeholder until a later turn's retry succeeds
+    | {
+        type: "title_generation_failed"
+        timestamp: number
+        session_id: string
+        provider_id: string
+        model_id: string
+        /** Which user message of the session triggered the request: 1 is the first, retries count up. */
+        attempt: number
+        /** The error's class name (`APICallError`, `TypeError`, ...), no message text. */
+        error_type: string
+        /** Keyword classification from classifyError(). */
+        error_class: string
+        http_status?: number
+      }
+    // altimate_change end
     // DEPRECATED: Python engine eliminated. These event types are retained
     // for backward compatibility with existing telemetry dashboards but
     // are never fired by the native TypeScript implementation.
diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index bbc390bb9e..65e90e8dda 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -4863,6 +4863,11 @@ NOTE: At any point in time through this workflow you should feel free to ask the
     return result
   }
 
+  // altimate_change start — how many user messages of a session may each trigger a title request
+  // while the session still carries its placeholder title.
+  const TITLE_MAX_ATTEMPTS = 5
+  // altimate_change end
+
   async function ensureTitle(input: {
     session: Session.Info
     history: MessageV2.WithParts[]
@@ -4878,10 +4883,16 @@ NOTE: At any point in time through this workflow you should feel free to ask the
     )
     if (firstRealUserIdx === -1) return
 
-    const isFirst =
-      input.history.filter((m) => m.info.role === "user" && !m.parts.every((p) => "synthetic" in p && p.synthetic))
-        .length === 1
-    if (!isFirst) return
+    // altimate_change start — retry while the placeholder stands. Upstream requested a title only
+    // on the first user message, so one failed small-model call left `New session - <time>` for the
+    // rest of the session (field report, altimate-code 0.12.8). Later turns retry with the same
+    // first-message context, bounded so a permanently broken small model does not cost a failed
+    // request on every turn.
+    const attempt = input.history.filter(
+      (m) => m.info.role === "user" && !m.parts.every((p) => "synthetic" in p && p.synthetic),
+    ).length
+    if (attempt > TITLE_MAX_ATTEMPTS) return
+    // altimate_change end
 
     // Gather all messages up to and including the first real user message for context
     // This includes any shell/subtask executions that preceded the user's first prompt
@@ -4930,21 +4941,53 @@ NOTE: At any point in time through this workflow you should feel free to ask the
           : await MessageV2.toModelMessages(contextMessages, model)),
       ],
     })
-    const text = await Promise.resolve(result.text).catch((err: unknown) => {
-      log.error("failed to generate title", { error: err })
-      return undefined
-    })
-    if (text) {
-      const cleaned = text
-        .replace(/<think>[\s\S]*?<\/think>\s*/g, "")
-        .split("\n")
-        .map((line: string) => line.trim())
-        .find((line: string) => line.length > 0)
-      if (!cleaned) return
-
-      const title = cleaned.length > 100 ? cleaned.substring(0, 97) + "..." : cleaned
-      return Session.setTitle({ sessionID: input.session.id, title })
+    // altimate_change start — read the stream itself. `result.text` rejects with the SDK's generic
+    // "No output generated. Check the stream for errors." and the provider's own error reaches only
+    // the stream's error part, so the log never said why a title failed. Record the real error and
+    // report it, so the next field report is answerable from App Insights.
+    let text = ""
+    let failure: unknown
+    try {
+      for await (const part of result.fullStream) {
+        if (part.type === "text-delta") text += part.text
+        else if (part.type === "error") failure = part.error
+      }
+    } catch (err) {
+      failure = err
     }
+    if (failure !== undefined || text.trim().length === 0) {
+      const err = failure ?? new Error("the model returned no text")
+      const message = err instanceof Error ? err.message : String(err)
+      const status = (err as { statusCode?: unknown })?.statusCode
+      log.error("failed to generate title", {
+        error: err,
+        attempt,
+        providerID: model.providerID,
+        modelID: model.id,
+      })
+      Telemetry.track({
+        type: "title_generation_failed",
+        timestamp: Date.now(),
+        session_id: input.session.id,
+        provider_id: model.providerID,
+        model_id: model.id,
+        attempt,
+        error_type: err instanceof Error ? err.name : typeof err,
+        error_class: Telemetry.classifyError(message),
+        ...(typeof status === "number" ? { http_status: status } : {}),
+      })
+      return
+    }
+    // altimate_change end
+    const cleaned = text
+      .replace(/<think>[\s\S]*?<\/think>\s*/g, "")
+      .split("\n")
+      .map((line: string) => line.trim())
+      .find((line: string) => line.length > 0)
+    if (!cleaned) return
+
+    const title = cleaned.length > 100 ? cleaned.substring(0, 97) + "..." : cleaned
+    return Session.setTitle({ sessionID: input.session.id, title })
   }
 
   // altimate_change start — Effect Context.Service facade over the existing Promise namespace.
diff --git a/packages/opencode/test/lib/llm-server.ts b/packages/opencode/test/lib/llm-server.ts
index c996412397..e14043941e 100644
--- a/packages/opencode/test/lib/llm-server.ts
+++ b/packages/opencode/test/lib/llm-server.ts
@@ -616,6 +616,8 @@ namespace TestLLMServer {
     readonly url: string
     readonly push: (...input: (Item | Reply)[]) => Effect.Effect<void>
     readonly pushMatch: (match: Match, ...input: (Item | Reply)[]) => Effect.Effect<void>
+    /** Answers for the next title requests, in order; the automatic "E2E Title" resumes after them. */
+    readonly title: (...input: (Item | Reply)[]) => Effect.Effect<void>
     readonly textMatch: (match: Match, value: string, opts?: { usage?: Usage }) => Effect.Effect<void>
     readonly toolMatch: (match: Match, name: string, input: unknown) => Effect.Effect<void>
     readonly text: (value: string, opts?: { usage?: Usage }) => Effect.Effect<void>
@@ -648,6 +650,7 @@ export class TestLLMServer extends Context.Service<TestLLMServer, TestLLMServer.
 
       let hits: Hit[] = []
       let list: Queue[] = []
+      let titles: Item[] = [] // altimate_change — answers for title requests, see handle()
       let waits: Wait[] = []
       let misses: Hit[] = []
 
@@ -679,6 +682,18 @@ export class TestLLMServer extends Context.Service<TestLLMServer, TestLLMServer.
         const body = yield* req.json.pipe(Effect.orElseSucceed(() => ({})))
         const current = hit(req.originalUrl, body, { ...req.headers })
         if (isTitleRequest(body)) {
+          // altimate_change start — a queued title item answers the request instead of the automatic
+          // "E2E Title", so a test can make title generation fail. Kept apart from the main queue:
+          // a title request carries the first user message, so body matchers would catch it too.
+          const queued = titles.shift()
+          if (queued) {
+            hits = [...hits, current]
+            yield* notify()
+            if (queued.type !== "sse") return fail(queued)
+            if (mode === "responses") return send(responses(queued, modelFrom(body)))
+            return send(queued)
+          }
+          // altimate_change end
           hits = [...hits, current]
           yield* notify()
           const auto: Sse = { type: "sse", head: [role()], tail: [textLine("E2E Title"), finishLine("stop")] }
@@ -720,6 +735,12 @@ export class TestLLMServer extends Context.Service<TestLLMServer, TestLLMServer.
         pushMatch: Effect.fn("TestLLMServer.pushMatch")(function* (match: Match, ...input: (Item | Reply)[]) {
           queueMatch(match, ...input)
         }),
+        // altimate_change start — answers for the next title requests, in order; the automatic
+        // "E2E Title" resumes once they are used up
+        title: Effect.fn("TestLLMServer.title")(function* (...input: (Item | Reply)[]) {
+          titles = [...titles, ...input.map((value) => item(value))]
+        }),
+        // altimate_change end
         textMatch: Effect.fn("TestLLMServer.textMatch")(function* (
           match: Match,
           value: string,
diff --git a/packages/opencode/test/session/title-retry.test.ts b/packages/opencode/test/session/title-retry.test.ts
new file mode 100644
index 0000000000..ff26396573
--- /dev/null
+++ b/packages/opencode/test/session/title-retry.test.ts
@@ -0,0 +1,246 @@
+// altimate_change - new file
+/**
+ * Session titles through the real prompt loop. A failed title request no longer leaves the
+ * `New session - <time>` placeholder for the life of the session: the next turns retry with the
+ * first message as context, a bounded number of times, and each failure is reported with the
+ * provider's error rather than the SDK's generic "No output generated".
+ */
+import { expect, spyOn } from "bun:test"
+import { Effect, Layer } from "effect"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Session } from "@/session/session"
+import { Session as LegacySession } from "../../src/session"
+import { SessionPrompt } from "../../src/session/prompt"
+import { SessionSummary } from "../../src/session/summary"
+import { Database } from "@opencode-ai/core/database/database"
+import { SessionProjector } from "@opencode-ai/core/session/projector"
+import { Telemetry } from "@/telemetry"
+import { testEffect } from "../lib/effect"
+import { TestLLMServer, httpError } from "../lib/llm-server"
+import { provideTmpdirServerLegacy } from "./legacy-instance"
+import { LSP } from "@/lsp/lsp"
+import { MCP } from "../../src/mcp"
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+
+const mcp = Layer.succeed(
+  MCP.Service,
+  MCP.Service.of({
+    status: () => Effect.succeed({}),
+    clients: () => Effect.succeed({}),
+    tools: () => Effect.succeed({}),
+    prompts: () => Effect.succeed({}),
+    resources: () => Effect.succeed({}),
+    add: () => Effect.succeed({ status: { status: "disabled" as const } }),
+    connect: () => Effect.void,
+    disconnect: () => Effect.void,
+    remove: () => Effect.void,
+    getPrompt: () => Effect.succeed(undefined),
+    readResource: () => Effect.succeed(undefined),
+    startAuth: () => Effect.die("unexpected MCP auth"),
+    authenticate: () => Effect.die("unexpected MCP auth"),
+    finishAuth: () => Effect.die("unexpected MCP auth"),
+    removeAuth: () => Effect.void,
+    supportsOAuth: () => Effect.succeed(false),
+    hasStoredTokens: () => Effect.succeed(false),
+    getAuthStatus: () => Effect.succeed("not_authenticated" as const),
+    entry: () => Effect.succeed(undefined),
+    listMeta: () => Effect.succeed(undefined),
+    snapshot: () => Effect.succeed({ tools: {}, meta: undefined }),
+  }),
+)
+
+const lsp = Layer.succeed(
+  LSP.Service,
+  LSP.Service.of({
+    init: () => Effect.void,
+    status: () => Effect.succeed([]),
+    hasClients: () => Effect.succeed(false),
+    touchFile: () => Effect.void,
+    diagnostics: () => Effect.succeed({}),
+    hover: () => Effect.succeed(undefined),
+    definition: () => Effect.succeed([]),
+    references: () => Effect.succeed([]),
+    implementation: () => Effect.succeed([]),
+    documentSymbol: () => Effect.succeed([]),
+    workspaceSymbol: () => Effect.succeed([]),
+    prepareCallHierarchy: () => Effect.succeed([]),
+    incomingCalls: () => Effect.succeed([]),
+    outgoingCalls: () => Effect.succeed([]),
+  }),
+)
+
+const root = LayerNode.group([
+  SessionPrompt.node,
+  Session.node,
+  SessionProjector.node,
+  SessionSummary.node,
+  Database.node,
+  CrossSpawnSpawner.node,
+  LayerNode.make(TestLLMServer.layer, []),
+])
+const it = testEffect(
+  LayerNode.buildLayer(root, {
+    replacements: [
+      LayerNode.replace(MCP.node, mcp),
+      LayerNode.replace(LSP.node, lsp),
+      LayerNode.replace(RuntimeFlags.node, RuntimeFlags.layer({ experimentalEventSystem: true })),
+    ],
+  }),
+)
+
+const providerCfg = (url: string) => ({
+  provider: {
+    test: {
+      name: "Test",
+      id: "test",
+      env: [],
+      npm: "@ai-sdk/openai-compatible",
+      models: {
+        "test-model": {
+          id: "test-model",
+          name: "Test Model",
+          attachment: false,
+          reasoning: false,
+          temperature: false,
+          tool_call: true,
+          release_date: "2025-01-01",
+          limit: { context: 100000, output: 10000 },
+          cost: { input: 0, output: 0 },
+          options: {},
+        },
+      },
+      options: { apiKey: "test-key", baseURL: url },
+    },
+  },
+  model: "test/test-model",
+})
+
+const TITLE_MARKER = "Generate a title for this conversation"
+const PROVIDER_REJECTION = { error: { message: "Thinking budget is not supported for this model." } }
+
+type Failed = Extract<Telemetry.Event, { type: "title_generation_failed" }>
+
+/** Records title failure events for the duration of the test. */
+const recordTitleFailures = Effect.acquireRelease(
+  Effect.sync(() => {
+    const events: Failed[] = []
+    const spy = spyOn(Telemetry, "track").mockImplementation((event) => {
+      if (event.type === "title_generation_failed") events.push(event)
+    })
+    return { events, spy }
+  }),
+  ({ spy }) => Effect.sync(() => spy.mockRestore()),
+)
+
+/** The title request is fire-and-forget, so the session row is polled until it changes or the wait runs out. */
+const titleAfter = Effect.fnUntraced(function* (sessionID: Session.Info["id"], settled: (title: string) => boolean) {
+  const sessions = yield* Session.Service
+  let title = ""
+  for (let i = 0; i < 150; i++) {
+    title = (yield* sessions.get(sessionID)).title
+    if (settled(title)) return title
+    yield* Effect.sleep("20 millis")
+  }
+  return title
+})
+
+it.live(
+  "a failed title request is retried on the next turn with the first message as context",
+  () =>
+    provideTmpdirServerLegacy(
+      Effect.fnUntraced(function* ({ llm }) {
+        const { events } = yield* recordTitleFailures
+        const prompt = yield* SessionPrompt.Service
+        const sessions = yield* Session.Service
+        const session = yield* sessions.create({
+          permission: [{ permission: "*", pattern: "*", action: "allow" }],
+        })
+        expect(LegacySession.isDefaultTitle(session.title)).toBe(true)
+
+        // The provider rejects the first title request; the automatic "E2E Title" answers the next one.
+        yield* llm.title(httpError(400, PROVIDER_REJECTION))
+        yield* llm.text("first answer")
+        yield* prompt.prompt({
+          sessionID: session.id,
+          agent: "build",
+          parts: [{ type: "text", text: "first message" }],
+        })
+        yield* llm.wait(2)
+
+        // The placeholder stands after the failure, and the failure names the provider's error.
+        let failed = events
+        for (let i = 0; i < 150 && failed.length === 0; i++) {
+          yield* Effect.sleep("20 millis")
+          failed = events
+        }
+        expect(failed).toHaveLength(1)
+        expect(failed[0]).toMatchObject({
+          provider_id: "test",
+          model_id: "test-model",
+          attempt: 1,
+          http_status: 400,
+        })
+        expect(typeof failed[0].error_type).toBe("string")
+        expect(LegacySession.isDefaultTitle((yield* sessions.get(session.id)).title)).toBe(true)
+
+        yield* llm.text("second answer")
+        yield* prompt.prompt({
+          sessionID: session.id,
+          agent: "build",
+          parts: [{ type: "text", text: "second message" }],
+        })
+
+        // The second turn retried and the retry's answer became the title.
+        const title = yield* titleAfter(session.id, (t) => !LegacySession.isDefaultTitle(t))
+        expect(title).toBe("E2E Title")
+
+        const titleHits = (yield* llm.hits).filter((hit) => JSON.stringify(hit.body).includes(TITLE_MARKER))
+        expect(titleHits).toHaveLength(2)
+        // Both requests describe the conversation's start, not the turn that triggered the retry.
+        for (const hit of titleHits) {
+          const body = JSON.stringify(hit.body)
+          expect(body).toContain("first message")
+          expect(body).not.toContain("second message")
+        }
+        expect(events).toHaveLength(1)
+      }),
+      { git: true, config: providerCfg },
+    ),
+  { timeout: 60_000 },
+)
+
+it.live(
+  "a title that keeps failing is given up after five turns",
+  () =>
+    provideTmpdirServerLegacy(
+      Effect.fnUntraced(function* ({ llm }) {
+        const { events } = yield* recordTitleFailures
+        const prompt = yield* SessionPrompt.Service
+        const sessions = yield* Session.Service
+        const session = yield* sessions.create({
+          permission: [{ permission: "*", pattern: "*", action: "allow" }],
+        })
+
+        // Enough rejections for every turn: the sixth turn must not ask at all.
+        for (let i = 0; i < 6; i++) yield* llm.title(httpError(400, PROVIDER_REJECTION))
+        for (let i = 1; i <= 6; i++) {
+          yield* llm.text(`answer ${i}`)
+          yield* prompt.prompt({
+            sessionID: session.id,
+            agent: "build",
+            parts: [{ type: "text", text: `message ${i}` }],
+          })
+        }
+        // Two requests per turn for the first five turns, one for the sixth.
+        yield* llm.wait(11)
+
+        const titleHits = (yield* llm.hits).filter((hit) => JSON.stringify(hit.body).includes(TITLE_MARKER))
+        expect(titleHits).toHaveLength(5)
+        expect(LegacySession.isDefaultTitle((yield* sessions.get(session.id)).title)).toBe(true)
+        expect(events.map((event) => event.attempt)).toEqual([1, 2, 3, 4, 5])
+      }),
+      { git: true, config: providerCfg },
+    ),
+  { timeout: 90_000 },
+)
diff --git a/packages/opencode/test/telemetry/telemetry.test.ts b/packages/opencode/test/telemetry/telemetry.test.ts
index 533e5cec63..593759d34a 100644
--- a/packages/opencode/test/telemetry/telemetry.test.ts
+++ b/packages/opencode/test/telemetry/telemetry.test.ts
@@ -217,6 +217,7 @@ const ALL_EVENT_TYPES: Telemetry.Event["type"][] = [
   "auth_logout",
   "mcp_server_status",
   "provider_error",
+  "title_generation_failed", // altimate_change
   "engine_started",
   "engine_error",
   "upgrade_attempted",
@@ -261,7 +262,7 @@ const ALL_EVENT_TYPES: Telemetry.Event["type"][] = [
 
 describe("telemetry.event-types", () => {
   test("all event types are valid", () => {
-    expect(ALL_EVENT_TYPES.length).toBe(54)
+    expect(ALL_EVENT_TYPES.length).toBe(55)
   })
 })
 

From 58b43202b4f78ddeaa4304bcdaac996ed3d0b2bb Mon Sep 17 00:00:00 2001
From: Haider <haider@altimate.ai>
Date: Fri, 6 Nov 2026 21:15:23 +0530
Subject: [PATCH 2/4] fix(session): report a title failure that happens before
 the request, and keep one title request in flight

Review findings on the title retry:

- The model lookup and `LLM.stream` ran outside the try, so a `small_model`
  the provider does not list threw out of the fire-and-forget call with no
  log line and no event, on every one of the five attempts. Both now sit
  inside the try; when no model was resolved the report names the
  session's provider and model.
- `http_status` is read from `RetryError.lastError` too, so retried 429
  and 5xx failures carry their status.
- Error parts that are strings or plain objects (openai-compatible and
  Anthropic in-band errors) keep their name and message in the report.
- One title request per session at a time: a slow first request and the
  next turn's retry no longer both set the title.
- `TestLLMServer.reset` clears the title queue.
- Docs: `small_model` does not drive compaction; the paragraph names the
  title and prompt enhancement and says the title is retried five times.
- Two more tests: the unlisted `small_model` is reported with
  `ProviderModelNotFoundError` and no request; a held title request is not
  doubled by the next turn.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 docs/docs/configure/models.md                 |   2 +-
 .../opencode/src/altimate/telemetry/index.ts  |   2 +-
 packages/opencode/src/session/prompt.ts       | 130 +++++++++++-------
 packages/opencode/test/lib/llm-server.ts      |   1 +
 .../opencode/test/session/title-retry.test.ts |  90 +++++++++++-
 5 files changed, 172 insertions(+), 53 deletions(-)

diff --git a/docs/docs/configure/models.md b/docs/docs/configure/models.md
index 3905baed40..3a845aba55 100644
--- a/docs/docs/configure/models.md
+++ b/docs/docs/configure/models.md
@@ -18,7 +18,7 @@ altimate supports models from all configured providers. Use the `model` and `sma
 
 The model format is `provider/model-name`.
 
-`small_model` handles the background requests that are not part of the conversation: the session title, prompt enhancement and context compaction. When it is not set, Altimate Code picks a cheap model from the same provider (Claude Haiku, Gemini Flash or GPT-5 nano when the provider lists one) and otherwise uses the chat model. A `small_model` the provider cannot serve fails only these background requests: chat keeps working, while new sessions keep their `New session - <time>` placeholder title and compaction fails. Altimate Code retries the title on the next turns and reports the failure in telemetry.
+`small_model` handles the small background requests that are not part of the conversation, such as the session title and prompt enhancement. When it is not set, Altimate Code picks a cheap model from the same provider (Claude Haiku, Gemini Flash or GPT-5 nano when the provider lists one) and otherwise uses the chat model. A `small_model` the provider cannot serve, or does not list, fails only those requests: chat keeps working, while new sessions keep their `New session - <time>` placeholder title until a retry succeeds. Altimate Code retries the title on each of the first five messages of a session and reports every failure in telemetry.
 
 ## Browsing Models
 
diff --git a/packages/opencode/src/altimate/telemetry/index.ts b/packages/opencode/src/altimate/telemetry/index.ts
index 844e8f00f0..27eaf6f800 100644
--- a/packages/opencode/src/altimate/telemetry/index.ts
+++ b/packages/opencode/src/altimate/telemetry/index.ts
@@ -438,7 +438,7 @@ export namespace Telemetry {
         model_id: string
         /** Which user message of the session triggered the request: 1 is the first, retries count up. */
         attempt: number
-        /** The error's class name (`APICallError`, `TypeError`, ...), no message text. */
+        /** The error's class name (`AI_APICallError`, `AI_RetryError`, `ProviderModelNotFoundError`, ...), no message text. */
         error_type: string
         /** Keyword classification from classifyError(). */
         error_class: string
diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index 65e90e8dda..af28717052 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -4866,6 +4866,34 @@ NOTE: At any point in time through this workflow you should feel free to ask the
   // altimate_change start — how many user messages of a session may each trigger a title request
   // while the session still carries its placeholder title.
   const TITLE_MAX_ATTEMPTS = 5
+  /** Sessions with a title request in flight: one at a time, so a slow request and the next
+   * turn's retry cannot both set the title. */
+  const titleInFlight = new Set<string>()
+  /** Name, message and HTTP status of a title failure. Covers errors that are not Error instances
+   * (openai-compatible in-band errors are strings, Anthropic's are plain objects) and the SDK's
+   * RetryError, which carries the status on its last attempt rather than on itself. */
+  function describeTitleError(err: unknown): { name: string; message: string; status?: number } {
+    const statusOf = (value: unknown) => {
+      const o = value as { statusCode?: unknown; lastError?: { statusCode?: unknown } } | undefined
+      const code = o?.statusCode ?? o?.lastError?.statusCode
+      return typeof code === "number" ? code : undefined
+    }
+    if (err instanceof Error) return { name: err.name, message: err.message, status: statusOf(err) }
+    if (err && typeof err === "object") {
+      const o = err as Record<string, unknown>
+      const name = typeof o.name === "string" ? o.name : typeof o.type === "string" ? o.type : "object"
+      let message = typeof o.message === "string" ? o.message : ""
+      if (!message) {
+        try {
+          message = JSON.stringify(err).slice(0, 500)
+        } catch {
+          message = "[object]"
+        }
+      }
+      return { name, message, status: statusOf(err) }
+    }
+    return { name: typeof err, message: String(err) }
+  }
   // altimate_change end
 
   async function ensureTitle(input: {
@@ -4906,75 +4934,77 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 
     const agent = await Agent.get("title")
     if (!agent) return
-    const model = await iife(async () => {
-      // altimate_change start — agent.model carries core ProviderV2.ID/ModelV2.ID brands; re-brand to fork ProviderID/ModelID (identity at runtime)
-      if (agent.model)
-        return await Provider.getModel(ProviderID.make(agent.model.providerID), ModelID.make(agent.model.modelID))
-      // altimate_change end
-      return (
-        (await Provider.getSmallModel(input.providerID)) ?? (await Provider.getModel(input.providerID, input.modelID))
-      )
-    })
-    const result = await LLM.stream({
-      agent,
-      user: firstRealUser.info as MessageV2.User,
-      system: [],
-      small: true,
-      tools: {},
-      // altimate_change start — title generation is toolless, but without an explicit "none" the
-      // historical-tool-stub injection in LLM.stream repopulates `tools` from any tool parts in
-      // the context, which both re-declares tools this request cannot use and suppresses the
-      // toolless message flattening. compaction.ts passes the same flag for the same reason.
-      toolChoice: "none" as const,
-      // altimate_change end
-      model,
-      abort: new AbortController().signal,
-      sessionID: input.session.id,
-      retries: 2,
-      messages: [
-        {
-          role: "user",
-          content: "Generate a title for this conversation:\n",
-        },
-        ...(hasOnlySubtaskParts
-          ? [{ role: "user" as const, content: subtaskParts.map((p) => p.prompt).join("\n") }]
-          : await MessageV2.toModelMessages(contextMessages, model)),
-      ],
-    })
     // altimate_change start — read the stream itself. `result.text` rejects with the SDK's generic
     // "No output generated. Check the stream for errors." and the provider's own error reaches only
-    // the stream's error part, so the log never said why a title failed. Record the real error and
-    // report it, so the next field report is answerable from App Insights.
+    // the stream's error part, so the log never said why a title failed. The model lookup sits in
+    // the same try: a `small_model` the provider does not list used to throw out of this
+    // fire-and-forget call with no log line and no event. Record the real error and report it, so
+    // the next field report is answerable from App Insights.
+    if (titleInFlight.has(input.session.id)) return
+    titleInFlight.add(input.session.id)
     let text = ""
     let failure: unknown
+    let model: Provider.Model | undefined
     try {
+      model = await iife(async () => {
+        // agent.model carries core ProviderV2.ID/ModelV2.ID brands; re-brand to fork ProviderID/ModelID (identity at runtime)
+        if (agent.model)
+          return await Provider.getModel(ProviderID.make(agent.model.providerID), ModelID.make(agent.model.modelID))
+        return (
+          (await Provider.getSmallModel(input.providerID)) ??
+          (await Provider.getModel(input.providerID, input.modelID))
+        )
+      })
+      const result = await LLM.stream({
+        agent,
+        user: firstRealUser.info as MessageV2.User,
+        system: [],
+        small: true,
+        tools: {},
+        // title generation is toolless, but without an explicit "none" the historical-tool-stub
+        // injection in LLM.stream repopulates `tools` from any tool parts in the context, which both
+        // re-declares tools this request cannot use and suppresses the toolless message flattening.
+        // compaction.ts passes the same flag for the same reason.
+        toolChoice: "none" as const,
+        model,
+        abort: new AbortController().signal,
+        sessionID: input.session.id,
+        retries: 2,
+        messages: [
+          {
+            role: "user",
+            content: "Generate a title for this conversation:\n",
+          },
+          ...(hasOnlySubtaskParts
+            ? [{ role: "user" as const, content: subtaskParts.map((p) => p.prompt).join("\n") }]
+            : await MessageV2.toModelMessages(contextMessages, model)),
+        ],
+      })
       for await (const part of result.fullStream) {
         if (part.type === "text-delta") text += part.text
         else if (part.type === "error") failure = part.error
       }
     } catch (err) {
       failure = err
+    } finally {
+      titleInFlight.delete(input.session.id)
     }
     if (failure !== undefined || text.trim().length === 0) {
       const err = failure ?? new Error("the model returned no text")
-      const message = err instanceof Error ? err.message : String(err)
-      const status = (err as { statusCode?: unknown })?.statusCode
-      log.error("failed to generate title", {
-        error: err,
-        attempt,
-        providerID: model.providerID,
-        modelID: model.id,
-      })
+      const described = describeTitleError(err)
+      const providerID = model?.providerID ?? input.providerID
+      const modelID = model?.id ?? input.modelID
+      log.error("failed to generate title", { error: err, attempt, providerID, modelID })
       Telemetry.track({
         type: "title_generation_failed",
         timestamp: Date.now(),
         session_id: input.session.id,
-        provider_id: model.providerID,
-        model_id: model.id,
+        provider_id: providerID,
+        model_id: modelID,
         attempt,
-        error_type: err instanceof Error ? err.name : typeof err,
-        error_class: Telemetry.classifyError(message),
-        ...(typeof status === "number" ? { http_status: status } : {}),
+        error_type: described.name,
+        error_class: Telemetry.classifyError(described.message),
+        ...(described.status !== undefined ? { http_status: described.status } : {}),
       })
       return
     }
diff --git a/packages/opencode/test/lib/llm-server.ts b/packages/opencode/test/lib/llm-server.ts
index e14043941e..3e155069f5 100644
--- a/packages/opencode/test/lib/llm-server.ts
+++ b/packages/opencode/test/lib/llm-server.ts
@@ -788,6 +788,7 @@ export class TestLLMServer extends Context.Service<TestLLMServer, TestLLMServer.
         reset: Effect.sync(() => {
           hits = []
           list = []
+          titles = [] // altimate_change
           waits = []
           misses = []
         }),
diff --git a/packages/opencode/test/session/title-retry.test.ts b/packages/opencode/test/session/title-retry.test.ts
index ff26396573..02c2b8e1a0 100644
--- a/packages/opencode/test/session/title-retry.test.ts
+++ b/packages/opencode/test/session/title-retry.test.ts
@@ -16,7 +16,7 @@ import { Database } from "@opencode-ai/core/database/database"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { Telemetry } from "@/telemetry"
 import { testEffect } from "../lib/effect"
-import { TestLLMServer, httpError } from "../lib/llm-server"
+import { TestLLMServer, httpError, reply } from "../lib/llm-server"
 import { provideTmpdirServerLegacy } from "./legacy-instance"
 import { LSP } from "@/lsp/lsp"
 import { MCP } from "../../src/mcp"
@@ -244,3 +244,91 @@ it.live(
     ),
   { timeout: 90_000 },
 )
+
+/** The same provider, with a `small_model` it does not list. */
+const providerCfgBadSmallModel = (url: string) => ({ ...providerCfg(url), small_model: "test/does-not-exist" })
+
+it.live(
+  "a small_model the provider does not list is reported, not thrown",
+  () =>
+    provideTmpdirServerLegacy(
+      Effect.fnUntraced(function* ({ llm }) {
+        const { events } = yield* recordTitleFailures
+        const prompt = yield* SessionPrompt.Service
+        const sessions = yield* Session.Service
+        const session = yield* sessions.create({
+          permission: [{ permission: "*", pattern: "*", action: "allow" }],
+        })
+
+        yield* llm.text("first answer")
+        yield* prompt.prompt({
+          sessionID: session.id,
+          agent: "build",
+          parts: [{ type: "text", text: "first message" }],
+        })
+
+        // The lookup fails before any request is made, and that failure is still recorded.
+        let failed = events
+        for (let i = 0; i < 150 && failed.length === 0; i++) {
+          yield* Effect.sleep("20 millis")
+          failed = events
+        }
+        expect(failed).toHaveLength(1)
+        expect(failed[0]).toMatchObject({ provider_id: "test", model_id: "test-model", attempt: 1 })
+        expect(failed[0].error_type).toBe("ProviderModelNotFoundError")
+        expect(failed[0].http_status).toBeUndefined()
+        const titleHits = (yield* llm.hits).filter((hit) => JSON.stringify(hit.body).includes(TITLE_MARKER))
+        expect(titleHits).toHaveLength(0)
+        expect(LegacySession.isDefaultTitle((yield* sessions.get(session.id)).title)).toBe(true)
+      }),
+      { git: true, config: providerCfgBadSmallModel },
+    ),
+  { timeout: 60_000 },
+)
+
+it.live(
+  "a title request still in flight is not doubled by the next turn",
+  () =>
+    provideTmpdirServerLegacy(
+      Effect.fnUntraced(function* ({ llm }) {
+        const { events } = yield* recordTitleFailures
+        const prompt = yield* SessionPrompt.Service
+        const sessions = yield* Session.Service
+        const session = yield* sessions.create({
+          permission: [{ permission: "*", pattern: "*", action: "allow" }],
+        })
+
+        // The first title answer is held open across the second turn.
+        const gate = Promise.withResolvers<void>()
+        yield* llm.title(reply().wait(gate.promise).text("Slow first title").stop())
+        yield* llm.text("first answer")
+        yield* llm.text("second answer")
+        yield* prompt.prompt({
+          sessionID: session.id,
+          agent: "build",
+          parts: [{ type: "text", text: "first message" }],
+        })
+        yield* prompt.prompt({
+          sessionID: session.id,
+          agent: "build",
+          parts: [{ type: "text", text: "second message" }],
+        })
+
+        // Two chat requests and one title request: the second turn did not start another.
+        yield* llm.wait(3)
+        yield* Effect.sleep("100 millis")
+        let titleHits = (yield* llm.hits).filter((hit) => JSON.stringify(hit.body).includes(TITLE_MARKER))
+        expect(titleHits).toHaveLength(1)
+        expect(LegacySession.isDefaultTitle((yield* sessions.get(session.id)).title)).toBe(true)
+
+        gate.resolve()
+        const title = yield* titleAfter(session.id, (t) => !LegacySession.isDefaultTitle(t))
+        expect(title).toBe("Slow first title")
+        titleHits = (yield* llm.hits).filter((hit) => JSON.stringify(hit.body).includes(TITLE_MARKER))
+        expect(titleHits).toHaveLength(1)
+        expect(events).toHaveLength(0)
+      }),
+      { git: true, config: providerCfg },
+    ),
+  { timeout: 60_000 },
+)

From 966518b482e635ab25d7cf3537be0c2ec5cfff40 Mon Sep 17 00:00:00 2001
From: Haider <haider@altimate.ai>
Date: Fri, 6 Nov 2026 22:50:17 +0530
Subject: [PATCH 3/4] fix(session): a generated title never replaces a name the
 user gave while the request ran

Bot review findings on the title retry:

- Before setting the generated title, re-read the session and keep a title
  the user chose while the request was in flight; only the placeholder is
  replaced.
- The telemetry reference says retries stop after the fifth user message
  and describes `attempt` as 1 to 5.
- Test fixture: queued title answers go through the same reset-stream
  handling as other answers, and the hit bookkeeping is written once.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 docs/docs/reference/telemetry.md         |  2 +-
 packages/opencode/src/session/prompt.ts  |  5 +++++
 packages/opencode/test/lib/llm-server.ts | 10 ++++++----
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/docs/docs/reference/telemetry.md b/docs/docs/reference/telemetry.md
index 0bcec29e50..b7b33e3176 100644
--- a/docs/docs/reference/telemetry.md
+++ b/docs/docs/reference/telemetry.md
@@ -24,7 +24,7 @@ We collect the following categories of events:
 | `auth_logout` | A user logs out (provider only) |
 | `mcp_server_status` | An MCP server connects, disconnects, or errors (server name and transport) |
 | `provider_error` | An AI provider returns an error (error type and HTTP status, but no request content) |
-| `title_generation_failed` | A session-title request failed, so the session keeps its `New session - <time>` placeholder until a later turn's retry succeeds. Provider, model, which user message triggered the attempt, error class and type, HTTP status when there was one. No message text. |
+| `title_generation_failed` | A session-title request failed, so the session keeps its `New session - <time>` placeholder until a retry succeeds; retries stop after the fifth user message. Provider, model, `attempt` (1 to 5), error class and type, HTTP status when there was one. No message text. |
 | `engine_started` | The native tool engine initializes (version and duration) |
 | `engine_error` | The native tool engine fails to start (phase and truncated error) |
 | `upgrade_attempted` | A CLI upgrade is attempted (version and method) |
diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index af28717052..c5fe56d8e0 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -5017,6 +5017,11 @@ NOTE: At any point in time through this workflow you should feel free to ask the
     if (!cleaned) return
 
     const title = cleaned.length > 100 ? cleaned.substring(0, 97) + "..." : cleaned
+    // altimate_change start — the user may have named the session while the request was in flight;
+    // a generated title only ever replaces the placeholder.
+    const current = await Session.get(input.session.id).catch(() => undefined)
+    if (current && !Session.isDefaultTitle(current.title)) return
+    // altimate_change end
     return Session.setTitle({ sessionID: input.session.id, title })
   }
 
diff --git a/packages/opencode/test/lib/llm-server.ts b/packages/opencode/test/lib/llm-server.ts
index 3e155069f5..a43c39491b 100644
--- a/packages/opencode/test/lib/llm-server.ts
+++ b/packages/opencode/test/lib/llm-server.ts
@@ -686,16 +686,18 @@ export class TestLLMServer extends Context.Service<TestLLMServer, TestLLMServer.
           // "E2E Title", so a test can make title generation fail. Kept apart from the main queue:
           // a title request carries the first user message, so body matchers would catch it too.
           const queued = titles.shift()
+          hits = [...hits, current]
+          yield* notify()
           if (queued) {
-            hits = [...hits, current]
-            yield* notify()
             if (queued.type !== "sse") return fail(queued)
             if (mode === "responses") return send(responses(queued, modelFrom(body)))
+            if (queued.reset) {
+              yield* reset(queued)
+              return HttpServerResponse.empty()
+            }
             return send(queued)
           }
           // altimate_change end
-          hits = [...hits, current]
-          yield* notify()
           const auto: Sse = { type: "sse", head: [role()], tail: [textLine("E2E Title"), finishLine("stop")] }
           if (mode === "responses") return send(responses(auto, modelFrom(body)))
           return send(auto)

From ec8f74a4619ef24f74755d29aa8355def8f0de97 Mon Sep 17 00:00:00 2001
From: Haider <haider@altimate.ai>
Date: Fri, 6 Nov 2026 23:08:44 +0530
Subject: [PATCH 4/4] fix(session): report thinking-only title answers, log the
 failure without the raw error, and keep error_type identifier-shaped

Bot review findings on the title retry:

- An answer with no usable line (empty, or thinking only) is reported as a
  failed attempt instead of silently using one of the five.
- The `failed to generate title` log line carries the error's name,
  message (capped) and status, not the raw error object, which for a
  provider error can carry the request body.
- `error_type` is accepted only when it is an identifier-shaped token of at
  most 64 characters; anything else is reported as `Error` or `object`.
- When the session cannot be re-read before setting the title, the title is
  left for a later retry instead of being written blind.
- Tests: the in-flight test waits for the held title request to reach the
  server before the second turn, and the five-attempt test waits for all
  five failure events before asserting.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 packages/opencode/src/session/prompt.ts       | 41 ++++++++++++-------
 .../opencode/test/session/title-retry.test.ts |  5 ++-
 2 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index c5fe56d8e0..cfd5fceb09 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -4878,10 +4878,13 @@ NOTE: At any point in time through this workflow you should feel free to ask the
       const code = o?.statusCode ?? o?.lastError?.statusCode
       return typeof code === "number" ? code : undefined
     }
-    if (err instanceof Error) return { name: err.name, message: err.message, status: statusOf(err) }
+    // The name becomes a telemetry dimension: an identifier-shaped token or nothing.
+    const safeName = (value: unknown, fallback: string) =>
+      typeof value === "string" && /^[A-Za-z0-9_.:-]{1,64}$/.test(value) ? value : fallback
+    if (err instanceof Error) return { name: safeName(err.name, "Error"), message: err.message, status: statusOf(err) }
     if (err && typeof err === "object") {
       const o = err as Record<string, unknown>
-      const name = typeof o.name === "string" ? o.name : typeof o.type === "string" ? o.type : "object"
+      const name = safeName(o.name, safeName(o.type, "object"))
       let message = typeof o.message === "string" ? o.message : ""
       if (!message) {
         try {
@@ -4989,12 +4992,27 @@ NOTE: At any point in time through this workflow you should feel free to ask the
     } finally {
       titleInFlight.delete(input.session.id)
     }
-    if (failure !== undefined || text.trim().length === 0) {
-      const err = failure ?? new Error("the model returned no text")
+    const cleaned = text
+      .replace(/<think>[\s\S]*?<\/think>\s*/g, "")
+      .split("\n")
+      .map((line: string) => line.trim())
+      .find((line: string) => line.length > 0)
+    // An answer with no usable line (empty, or thinking only) is a failed attempt too, so it is
+    // reported rather than silently using up one of the five.
+    if (failure !== undefined || !cleaned) {
+      const err = failure ?? new Error(text.trim() ? "the model returned no title line" : "the model returned no text")
       const described = describeTitleError(err)
       const providerID = model?.providerID ?? input.providerID
       const modelID = model?.id ?? input.modelID
-      log.error("failed to generate title", { error: err, attempt, providerID, modelID })
+      // Name, message and status only: a provider error object can carry the request body.
+      log.error("failed to generate title", {
+        errorType: described.name,
+        message: described.message.slice(0, 500),
+        status: described.status,
+        attempt,
+        providerID,
+        modelID,
+      })
       Telemetry.track({
         type: "title_generation_failed",
         timestamp: Date.now(),
@@ -5008,19 +5026,12 @@ NOTE: At any point in time through this workflow you should feel free to ask the
       })
       return
     }
-    // altimate_change end
-    const cleaned = text
-      .replace(/<think>[\s\S]*?<\/think>\s*/g, "")
-      .split("\n")
-      .map((line: string) => line.trim())
-      .find((line: string) => line.length > 0)
-    if (!cleaned) return
 
     const title = cleaned.length > 100 ? cleaned.substring(0, 97) + "..." : cleaned
-    // altimate_change start — the user may have named the session while the request was in flight;
-    // a generated title only ever replaces the placeholder.
+    // The user may have named the session while the request was in flight: a generated title only
+    // ever replaces the placeholder, and when that cannot be checked the title is left for a retry.
     const current = await Session.get(input.session.id).catch(() => undefined)
-    if (current && !Session.isDefaultTitle(current.title)) return
+    if (!current || !Session.isDefaultTitle(current.title)) return
     // altimate_change end
     return Session.setTitle({ sessionID: input.session.id, title })
   }
diff --git a/packages/opencode/test/session/title-retry.test.ts b/packages/opencode/test/session/title-retry.test.ts
index 02c2b8e1a0..b724abb6df 100644
--- a/packages/opencode/test/session/title-retry.test.ts
+++ b/packages/opencode/test/session/title-retry.test.ts
@@ -232,8 +232,9 @@ it.live(
             parts: [{ type: "text", text: `message ${i}` }],
           })
         }
-        // Two requests per turn for the first five turns, one for the sixth.
+        // Two requests per turn for the first five turns, one for the sixth, and all five failures recorded.
         yield* llm.wait(11)
+        for (let i = 0; i < 150 && events.length < 5; i++) yield* Effect.sleep("20 millis")
 
         const titleHits = (yield* llm.hits).filter((hit) => JSON.stringify(hit.body).includes(TITLE_MARKER))
         expect(titleHits).toHaveLength(5)
@@ -308,6 +309,8 @@ it.live(
           agent: "build",
           parts: [{ type: "text", text: "first message" }],
         })
+        // The held title request has reached the server before the second turn starts.
+        yield* llm.wait(2)
         yield* prompt.prompt({
           sessionID: session.id,
           agent: "build",