fix(dashboard-agent): never let the chat title hold a turn open

The generated chat name is best-effort, but the await that collects it is the
last gate before a turn completes and the provider request behind it has no
deadline of its own. A request that stalled rather than failed hung the whole
turn after the model's final word: nothing streamed, nothing was saved, and the
run sat there until it was killed. The name now has a deadline; a late one still
lands on the row.

Author: kathiekiwi

internal-packages/dashboard-agent/src/dashboard-agent.test.ts

@@ -24,6 +24,7 @@ import {
   dashboardAgentEvalTriggerKey,
   dashboardAgentModelKey,
   dashboardAgentStoreKey,
+  dashboardAgentTitleDeadlineKey,
   dashboardAgentToolsKey,
   DEFAULT_CI_EVAL_SAMPLE_RATE,
   DEFAULT_EVAL_SAMPLE_RATE,
@@ -110,6 +111,33 @@ describe("dashboardAgent (mock harness)", () => {
     ]);
   });
 
+  // A provider request that stalls instead of failing has no deadline of its own, so
+  // the await that collects the title used to hang the whole turn after the model's
+  // final word: nothing streamed, nothing persisted, and the run never ended.
+  it("settles the turn when the title generation never comes back (regression)", async () => {
+    const { store, calls } = fakeStore();
+    const model = new MockLanguageModelV3({
+      doStream: async () => ({ stream: simulateReadableStream({ chunks: textStep("answered") }) }),
+      doGenerate: (() => new Promise(() => {})) as never,
+    });
+    harness = mockChatAgent(dashboardAgent, {
+      chatId: "chat_title_stalled",
+      clientData: CLIENT_DATA,
+      setupLocals: ({ set }) => {
+        set(dashboardAgentStoreKey, store);
+        set(dashboardAgentModelKey, model);
+        set(dashboardAgentTitleDeadlineKey, 30);
+      },
+    });
+
+    const turn = await harness.sendMessage(userMessage("why do my orders fail?"));
+
+    expect(collectText(turn.chunks)).toBe("answered");
+    await new Promise((r) => setTimeout(r, 30));
+    expect(calls.persistTurn).toHaveLength(1);
+    expect(calls.setChatTitleIfDefault).toHaveLength(0);
+  }, 10_000);
+
   describe("which turn names the chat", () => {
     const user = (id: string) => ({ id, role: "user" });
     const assistant = (id: string) => ({ id, role: "assistant" });

internal-packages/dashboard-agent/src/dashboard-agent.ts

@@ -283,6 +283,37 @@ function cleanTitle(raw: string): string {
  */
 const pendingTitles = new Map<string, Promise<void>>();
 
+/**
+ * How long the turn's settle may wait for that name.
+ *
+ * The title is best-effort — a failure only costs the generated name — but the await
+ * that collects it is the last gate before the turn completes. A provider request
+ * that stalls rather than fails has no deadline of its own, so without this the
+ * whole turn hangs after the model's final word: nothing streams, nothing persists,
+ * and the run sits there until it is killed. 15s is set against the run's own
+ * `idleTimeoutInSeconds: 60`, so a stalled name delays the client's settle by a
+ * fraction of it rather than outliving the turn.
+ */
+export const TITLE_DEADLINE_MS = 15_000;
+
+// Test-only override, so a regression test needn't wait the real deadline.
+export const dashboardAgentTitleDeadlineKey = locals.create<number>(
+  "dashboard-agent.titleDeadlineMs"
+);
+
+/** The promise, or nothing, once the deadline passes. */
+async function withinTitleDeadline(pending: Promise<void>): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<void>((resolve) => {
+    timer = setTimeout(resolve, locals.get(dashboardAgentTitleDeadlineKey) ?? TITLE_DEADLINE_MS);
+  });
+  try {
+    await Promise.race([pending, deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 /**
  * Whether this turn is the one that names the chat. Counted in user messages, not in
  * transcript length: a head-started turn arrives with the warm first step already in
@@ -440,7 +471,7 @@ export const dashboardAgent = chat.agent({
     const pending = pendingTitles.get(chatId);
     if (!pending) return;
     pendingTitles.delete(chatId);
-    await pending;
+    await withinTitleDeadline(pending);
   },
 
   onTurnComplete: async ({