diff --git a/apps/web/app/api/chat/chat.test.ts b/apps/web/app/api/chat/chat.test.ts
index 46a1b374ff07..4cdeeedd1c4d 100644
--- a/apps/web/app/api/chat/chat.test.ts
+++ b/apps/web/app/api/chat/chat.test.ts
@@ -44,6 +44,10 @@ vi.mock("@/app/api/sessions/shared", () => ({
   getAgentSession: vi.fn(() => undefined),
 }));
 
+vi.mock("@/lib/dench-cloud-settings", () => ({
+  readConfiguredSelectedDenchModel: vi.fn(() => null),
+}));
+
 describe("Chat API routes", () => {
   beforeEach(() => {
     vi.resetModules();
@@ -85,6 +89,9 @@ describe("Chat API routes", () => {
     vi.mock("@/app/api/sessions/shared", () => ({
       getAgentSession: vi.fn(() => undefined),
     }));
+    vi.mock("@/lib/dench-cloud-settings", () => ({
+      readConfiguredSelectedDenchModel: vi.fn(() => null),
+    }));
   });
 
   afterEach(() => {
@@ -179,6 +186,36 @@ describe("Chat API routes", () => {
       );
     });
 
+    it("passes the configured selected model into startRun when no override is provided", async () => {
+      const { startRun, hasActiveRun, subscribeToRun } = await import("@/lib/active-runs");
+      const { readConfiguredSelectedDenchModel } = await import("@/lib/dench-cloud-settings");
+      vi.mocked(hasActiveRun).mockReturnValue(false);
+      vi.mocked(subscribeToRun).mockReturnValue(() => {});
+      vi.mocked(readConfiguredSelectedDenchModel).mockReturnValue("anthropic.claude-sonnet-4-6-v1");
+
+      const { POST } = await import("./route.js");
+      const req = new Request("http://localhost/api/chat", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          messages: [
+            { id: "m1", role: "user", parts: [{ type: "text", text: "hello" }] },
+          ],
+          sessionId: "s1",
+        }),
+      });
+
+      await POST(req);
+
+      expect(startRun).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionId: "s1",
+          sessionModel: "anthropic.claude-sonnet-4-6-v1",
+          modelOverride: undefined,
+        }),
+      );
+    });
+
     it("returns JSON when an unsafe OpenAI switch needs acknowledgement", async () => {
       const { getAgentSession } = await import("@/app/api/sessions/shared");
       const { startRun } = await import("@/lib/active-runs");
diff --git a/apps/web/app/api/chat/route.ts b/apps/web/app/api/chat/route.ts
index ae8506714e0a..e1c9322a08b9 100644
--- a/apps/web/app/api/chat/route.ts
+++ b/apps/web/app/api/chat/route.ts
@@ -31,6 +31,7 @@ import {
 	isLikelyOpenAiModelId,
 	needsOpenAiSwitchAcknowledgement,
 } from "@/lib/chat-models";
+import { readConfiguredSelectedDenchModel } from "@/lib/dench-cloud-settings";
 
 export const runtime = "nodejs";
 
@@ -259,6 +260,8 @@ export async function POST(req: Request) {
 		const gatewayThreadId = sessionMeta?.gatewaySessionId ?? sessionId;
 
 		const imageAttachments = extractImageAttachmentsFromMessage(agentMessage);
+		const sessionModel =
+			normalizedModelOverride ?? readConfiguredSelectedDenchModel() ?? undefined;
 
 		try {
 			startRun({
@@ -267,6 +270,7 @@ export async function POST(req: Request) {
 				agentSessionId: gatewayThreadId,
 				overrideAgentId: effectiveAgentId,
 				modelOverride: normalizedModelOverride,
+				sessionModel,
 				imageAttachments: imageAttachments.length > 0
 					? imageAttachments
 					: undefined,
diff --git a/apps/web/app/api/chat/stop/route.test.ts b/apps/web/app/api/chat/stop/route.test.ts
index b1dbd85e5646..d40732bb3719 100644
--- a/apps/web/app/api/chat/stop/route.test.ts
+++ b/apps/web/app/api/chat/stop/route.test.ts
@@ -110,4 +110,33 @@ describe("POST /api/chat/stop", () => {
     expect(listSubagentsForRequesterSession).not.toHaveBeenCalled();
     expect(json).toEqual({ aborted: true, abortedChildren: 0 });
   });
+
+  it("stops a gateway-backed session when a non-subagent sessionKey is provided", async () => {
+    const { abortRun, getActiveRun } = await import("@/lib/active-runs");
+    const { listSubagentsForRequesterSession } = await import("@/lib/subagent-registry");
+
+    vi.mocked(getActiveRun).mockImplementation(((runKey: string) => {
+      if (runKey === "agent:main:telegram:channel-1") {
+        return { status: "running" };
+      }
+      return undefined;
+    }) as never);
+    vi.mocked(abortRun).mockReturnValue(true);
+
+    const { POST } = await import("./route.js");
+    const req = new Request("http://localhost/api/chat/stop", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sessionKey: "agent:main:telegram:channel-1",
+      }),
+    });
+
+    const res = await POST(req);
+    const json = await res.json();
+
+    expect(abortRun).toHaveBeenCalledWith("agent:main:telegram:channel-1");
+    expect(listSubagentsForRequesterSession).not.toHaveBeenCalled();
+    expect(json).toEqual({ aborted: true, abortedChildren: 0 });
+  });
 });
diff --git a/apps/web/app/api/chat/stop/route.ts b/apps/web/app/api/chat/stop/route.ts
index a19327445d68..756e37621bfa 100644
--- a/apps/web/app/api/chat/stop/route.ts
+++ b/apps/web/app/api/chat/stop/route.ts
@@ -2,7 +2,7 @@
  * POST /api/chat/stop
  *
  * Abort an active agent run. Called by the Stop button.
- * Works for both parent sessions (by sessionId) and subagent sessions (by sessionKey).
+ * Works for parent sessions (by sessionId) and any session-key backed run.
  */
 import { abortRun, getActiveRun } from "@/lib/active-runs";
 import { listSubagentsForRequesterSession } from "@/lib/subagent-registry";
@@ -17,11 +17,15 @@ export async function POST(req: Request) {
 		.json()
 		.catch(() => ({}));
 
-	const isSubagentSession = typeof body.sessionKey === "string" && body.sessionKey.includes(":subagent:");
-	const runKey = isSubagentSession && body.sessionKey ? body.sessionKey : body.sessionId;
+	const sessionKey =
+		typeof body.sessionKey === "string" && body.sessionKey.trim()
+			? body.sessionKey.trim()
+			: undefined;
+	const isSubagentSession = Boolean(sessionKey?.includes(":subagent:"));
+	const runKey = sessionKey ?? body.sessionId;
 
 	if (!runKey) {
-		return new Response("sessionId or subagent sessionKey required", { status: 400 });
+		return new Response("sessionId or sessionKey required", { status: 400 });
 	}
 
 	const run = getActiveRun(runKey);
@@ -30,7 +34,7 @@ export async function POST(req: Request) {
 	const aborted = canAbort ? abortRun(runKey) : false;
 	let abortedChildren = 0;
 
-	if (!isSubagentSession && body.sessionId && body.cascadeChildren) {
+	if (!sessionKey && body.sessionId && body.cascadeChildren) {
 		const fallbackAgentId = resolveActiveAgentId();
 		const requesterSessionKey = resolveSessionKey(body.sessionId, fallbackAgentId);
 		for (const subagent of listSubagentsForRequesterSession(requesterSessionKey)) {
diff --git a/apps/web/app/components/chat-panel.tsx b/apps/web/app/components/chat-panel.tsx
index 2f5bbc4cd08c..a029421dd5ad 100644
--- a/apps/web/app/components/chat-panel.tsx
+++ b/apps/web/app/components/chat-panel.tsx
@@ -27,6 +27,7 @@ import type { ChatPanelRuntimeState } from "@/lib/chat-session-registry";
 import {
 	getStreamActivityLabel,
 	getIncompleteAssistantReplyReason,
+	hasAssistantRunningTool,
 	hasAssistantPostToolText,
 	hasAssistantText,
 	hasAssistantToolActivity,
@@ -737,6 +738,84 @@ export function createStreamParser() {
 	};
 }
 
+const STREAM_ACTIVITY_TIMEOUT_MS = 90_000;
+const STREAM_TIMEOUT_MESSAGE =
+	"Request timed out — no response from agent. Try again or check the gateway.";
+const TOOL_RUNNING_TIMEOUT_MESSAGE =
+	"Tool is still running. Waiting for the gateway to finish...";
+
+function roughJsonLength(value: unknown): number {
+	try {
+		const serialized = JSON.stringify(value);
+		return typeof serialized === "string" ? serialized.length : 0;
+	} catch {
+		return 0;
+	}
+}
+
+function getAssistantActivityMarker(message: UIMessage | null): string {
+	if (!message || message.role !== "assistant") {
+		return "";
+	}
+	const parts = message.parts.map((part, index) => {
+		if (part.type === "text") {
+			return `text:${index}:${part.text.length}`;
+		}
+		if (part.type === "reasoning") {
+			const text = typeof part.text === "string" ? part.text : "";
+			const state = typeof part.state === "string" ? part.state : "";
+			return `reasoning:${index}:${text.length}:${state}`;
+		}
+		if (part.type === "dynamic-tool") {
+			const dynamicToolPart = part as {
+				toolCallId: string;
+				toolName?: string;
+				state?: string;
+				preliminary?: boolean;
+				input?: unknown;
+				output?: unknown;
+			};
+			return [
+				"dynamic-tool",
+				index,
+				dynamicToolPart.toolCallId,
+				dynamicToolPart.toolName ?? "",
+				dynamicToolPart.state ?? "",
+				dynamicToolPart.preliminary === true ? "preliminary" : "final",
+				roughJsonLength(dynamicToolPart.input),
+				roughJsonLength(dynamicToolPart.output),
+			].join(":");
+		}
+		if (part.type === "tool-invocation") {
+			const toolInvocationPart = part as {
+				toolCallId: string;
+				toolName?: string;
+				args?: unknown;
+				result?: unknown;
+				errorText?: unknown;
+			};
+			return [
+				"tool-invocation",
+				index,
+				toolInvocationPart.toolCallId,
+				toolInvocationPart.toolName ?? "",
+				roughJsonLength(toolInvocationPart.args),
+				roughJsonLength(toolInvocationPart.result),
+				typeof toolInvocationPart.errorText === "string"
+					? toolInvocationPart.errorText.length
+					: 0,
+			].join(":");
+		}
+		return `${part.type}:${index}:${roughJsonLength(part)}`;
+	});
+	return `${message.id}:${parts.join("|")}`;
+}
+
+type ActiveRunTarget = {
+	sessionId: string | null;
+	sessionKey: string | null;
+};
+
 /** Imperative handle for parent-driven session control (main page). */
 export type ChatPanelHandle = {
 	loadSession: (sessionId: string) => Promise<void>;
@@ -895,6 +974,12 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 
 		// ── Stream-level error (empty response detection) ──
 		const [streamError, setStreamError] = useState<string | null>(null);
+		const activeRunTargetRef = useRef<ActiveRunTarget>({
+			sessionId: null,
+			sessionKey: null,
+		});
+		const lastAssistantActivityAtRef = useRef<number | null>(null);
+		const lastAssistantActivityMarkerRef = useRef("");
 
 		// Track persisted messages to avoid double-saves
 		const savedMessageIdsRef = useRef<Set<string>>(new Set());
@@ -971,6 +1056,50 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 			status === "submitted" ||
 			isReconnecting;
 
+		const stopActiveRun = useCallback(
+			async (options?: {
+				abortServer?: boolean;
+				cascadeChildren?: boolean;
+				target?: ActiveRunTarget;
+			}) => {
+				reconnectAbortRef.current?.abort();
+				reconnectAbortRef.current = null;
+				setIsReconnecting(false);
+				void stop();
+
+				const target = options?.target ?? activeRunTargetRef.current;
+				if (options?.abortServer && (target.sessionKey || target.sessionId)) {
+					try {
+						const body = target.sessionKey
+							? { sessionKey: target.sessionKey }
+							: {
+								sessionId: target.sessionId,
+								...(options?.cascadeChildren ? { cascadeChildren: true } : {}),
+							};
+						await fetch("/api/chat/stop", {
+							method: "POST",
+							headers: {
+								"Content-Type": "application/json",
+							},
+							body: JSON.stringify(body),
+						});
+					} catch {
+						// Best-effort only; local stream teardown still proceeds.
+					}
+				}
+			},
+			[stop],
+		);
+
+		useEffect(() => {
+			if (!isSubagentMode && !isGatewayMode) {
+				activeRunTargetRef.current = {
+					sessionId: currentSessionId,
+					sessionKey: null,
+				};
+			}
+		}, [currentSessionId, isGatewayMode, isSubagentMode]);
+
 		// Keep cloud catalog + primary model in sync (hero, session switches, and after
 		// completed turns — agent tools may change agents.defaults.model.primary).
 		useEffect(() => {
@@ -1031,30 +1160,66 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 			loadingSession,
 		]);
 
-		// Stream stall detection: if we stay in "submitted" (no first
-		// token received) for too long, surface an error and reset.
-		const stallTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+		// Reset the watchdog whenever the assistant visibly changes: text,
+		// reasoning, or tool input/output updates all count as activity.
 		useEffect(() => {
-			if (stallTimerRef.current) {
-				clearTimeout(stallTimerRef.current);
-				stallTimerRef.current = null;
+			if (!isStreaming) {
+				lastAssistantActivityAtRef.current = null;
+				lastAssistantActivityMarkerRef.current = "";
+				return;
 			}
-			if (status === "submitted") {
-				stallTimerRef.current = setTimeout(() => {
-					stallTimerRef.current = null;
-					if (status === "submitted") {
-						setStreamError("Request timed out — no response from agent. Try again or check the gateway.");
-						void stop();
-					}
-				}, 90_000);
+
+			const lastMessage = messages[messages.length - 1] ?? null;
+			const activityMarker = getAssistantActivityMarker(lastMessage);
+			if (
+				activityMarker &&
+				activityMarker !== lastAssistantActivityMarkerRef.current
+			) {
+				lastAssistantActivityMarkerRef.current = activityMarker;
+				lastAssistantActivityAtRef.current = Date.now();
+				if (
+					streamError === STREAM_TIMEOUT_MESSAGE ||
+					streamError === TOOL_RUNNING_TIMEOUT_MESSAGE
+				) {
+					setStreamError(null);
+				}
 			}
-			return () => {
-				if (stallTimerRef.current) {
-					clearTimeout(stallTimerRef.current);
-					stallTimerRef.current = null;
+
+			if (lastAssistantActivityAtRef.current === null) {
+				lastAssistantActivityAtRef.current = Date.now();
+				if (streamError) {
+					setStreamError(null);
+				}
+			}
+
+			const intervalId = setInterval(() => {
+				const lastActivityAt = lastAssistantActivityAtRef.current;
+				if (lastActivityAt === null) {
+					return;
+				}
+				if (Date.now() - lastActivityAt < STREAM_ACTIVITY_TIMEOUT_MS) {
+					return;
 				}
+				if (hasAssistantRunningTool(lastMessage)) {
+					if (streamError !== TOOL_RUNNING_TIMEOUT_MESSAGE) {
+						setStreamError(TOOL_RUNNING_TIMEOUT_MESSAGE);
+					}
+					lastAssistantActivityAtRef.current = Date.now();
+					return;
+				}
+				if (streamError !== STREAM_TIMEOUT_MESSAGE) {
+					setStreamError(STREAM_TIMEOUT_MESSAGE);
+				}
+				void stopActiveRun({
+					abortServer: true,
+					cascadeChildren: true,
+				});
+			}, 1_000);
+
+			return () => {
+				clearInterval(intervalId);
 			};
-		}, [status, stop]);
+		}, [isStreaming, messages, stopActiveRun, streamError]);
 
 		// Auto-scroll to bottom on new messages, but only when the user
 		// is already near the bottom.  If the user scrolls up during
@@ -1281,6 +1446,11 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 			}
 			let cancelled = false;
 
+			void stopActiveRun({
+				abortServer: true,
+				cascadeChildren: true,
+			});
+			activeRunTargetRef.current = { sessionId: null, sessionKey: null };
 			sessionIdRef.current = null;
 			setCurrentSessionId(null);
 			onActiveSessionChange?.(null);
@@ -1302,6 +1472,10 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 						: undefined) ?? sessions[0];
 					setCurrentSessionId(target.id);
 					sessionIdRef.current = target.id;
+					activeRunTargetRef.current = {
+						sessionId: target.id,
+						sessionKey: null,
+					};
 					onActiveSessionChange?.(target.id);
 					isFirstFileMessageRef.current = false;
 
@@ -1372,7 +1546,7 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 				cancelled = true;
 			};
 			// eslint-disable-next-line react-hooks/exhaustive-deps -- stable setters
-		}, [filePath, attemptReconnect]);
+		}, [filePath, attemptReconnect, isSubagentMode, onActiveSessionChange, setMessages, stopActiveRun]);
 
 		// ── Non-file panel: auto-restore session on mount or URL change ──
 		const initialSessionHandled = useRef(false);
@@ -1395,8 +1569,14 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 			if (!subagentSessionKey || !subagentTask) {return;}
 			let cancelled = false;
 
-			reconnectAbortRef.current?.abort();
-			void stop();
+			void stopActiveRun({
+				abortServer: true,
+				cascadeChildren: true,
+			});
+			activeRunTargetRef.current = {
+				sessionId: null,
+				sessionKey: subagentSessionKey,
+			};
 			savedMessageIdsRef.current.clear();
 			setQueuedMessages([]);
 
@@ -1467,15 +1647,21 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 				reconnectAbortRef.current?.abort();
 			};
 			// eslint-disable-next-line react-hooks/exhaustive-deps -- stable setters
-		}, [subagentSessionKey, subagentTask, attemptReconnect]);
+		}, [subagentSessionKey, subagentTask, attemptReconnect, stopActiveRun]);
 
 		// ── Gateway session mode: load transcript + reconnect to active stream ──
 		useEffect(() => {
 			if (!gatewaySessionKey || !gatewaySessionId) return;
 			let cancelled = false;
 
-			reconnectAbortRef.current?.abort();
-			void stop();
+			void stopActiveRun({
+				abortServer: true,
+				cascadeChildren: true,
+			});
+			activeRunTargetRef.current = {
+				sessionId: null,
+				sessionKey: gatewaySessionKey,
+			};
 			savedMessageIdsRef.current.clear();
 			setQueuedMessages([]);
 			setLoadingSession(true);
@@ -1518,7 +1704,7 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 				reconnectAbortRef.current?.abort();
 			};
 			// eslint-disable-next-line react-hooks/exhaustive-deps
-		}, [gatewaySessionKey, gatewaySessionId, attemptReconnect]);
+		}, [gatewaySessionKey, gatewaySessionId, attemptReconnect, stopActiveRun]);
 
 		// ── Poll for subagent spawns during active streaming ──
 		const [hasRunningSubagents, setHasRunningSubagents] = useState(false);
@@ -1652,9 +1838,6 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 					}
 				}, 50);
 			}
-			if (status === "submitted") {
-				setStreamError(null);
-			}
 			return () => {
 				if (emptyStreamTimerRef.current) {
 					clearTimeout(emptyStreamTimerRef.current);
@@ -1745,6 +1928,10 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 					sessionId = await createSession(title);
 					setCurrentSessionId(sessionId);
 					sessionIdRef.current = sessionId;
+					activeRunTargetRef.current = {
+						sessionId,
+						sessionKey: null,
+					};
 					onActiveSessionChange?.(sessionId);
 					onSessionsChange?.();
 
@@ -1790,7 +1977,12 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 						role: "user" as const,
 						parts: [{ type: "text" as const, text: messageText }] as UIMessage["parts"],
 					};
-					setMessages((prev) => [...prev, userMsg]);
+					const nextMessages = [...messages, userMsg];
+					activeRunTargetRef.current = {
+						sessionId: null,
+						sessionKey: gatewaySessionKey,
+					};
+					setMessages(nextMessages);
 
 					try {
 						const res = await fetch("/api/gateway/chat", {
@@ -1799,7 +1991,9 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 							body: JSON.stringify({ sessionKey: gatewaySessionKey, message: messageText }),
 						});
 						if (res.ok && res.body) {
-							await attemptReconnect(gatewaySessionKey, [], { sessionKey: gatewaySessionKey });
+							await attemptReconnect(gatewaySessionKey, nextMessages, {
+								sessionKey: gatewaySessionKey,
+							});
 						}
 					} catch { /* ignore */ }
 				} else {
@@ -1819,6 +2013,7 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 				onSessionsChange,
 				filePath,
 				fileContext,
+				messages,
 				sendMessage,
 				gatewaySessionKey,
 				attemptReconnect,
@@ -1857,13 +2052,19 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 					return;
 				}
 
-			// Stop any active stream/reconnection for the old session.
-			reconnectAbortRef.current?.abort();
-			void stop();
+				// Stop any active stream/reconnection for the old session.
+				await stopActiveRun({
+					abortServer: true,
+					cascadeChildren: true,
+				});
 
 				setLoadingSession(true);
 				setCurrentSessionId(sessionId);
 				sessionIdRef.current = sessionId;
+				activeRunTargetRef.current = {
+					sessionId,
+					sessionKey: null,
+				};
 				onActiveSessionChange?.(sessionId);
 				savedMessageIdsRef.current.clear();
 				isFirstFileMessageRef.current = false;
@@ -1944,15 +2145,17 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 				currentSessionId,
 				setMessages,
 				onActiveSessionChange,
-				stop,
+				stopActiveRun,
 				attemptReconnect,
 			],
 		);
 
 		const handleNewSession = useCallback(() => {
-			reconnectAbortRef.current?.abort();
-			void stop();
-			setIsReconnecting(false);
+			void stopActiveRun({
+				abortServer: true,
+				cascadeChildren: true,
+			});
+			activeRunTargetRef.current = { sessionId: null, sessionKey: null };
 			setCurrentSessionId(null);
 			sessionIdRef.current = null;
 			onActiveSessionChange?.(null);
@@ -1965,7 +2168,7 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 			requestAnimationFrame(() => {
 				editorRef.current?.focus();
 			});
-		}, [setMessages, onActiveSessionChange, stop]);
+		}, [onActiveSessionChange, setMessages, stopActiveRun]);
 
 		// Keep the ref in sync so handleEditorSubmit can call it
 		handleNewSessionRef.current = handleNewSession;
@@ -1983,6 +2186,10 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 					const sessionId = await createSession(title);
 					setCurrentSessionId(sessionId);
 					sessionIdRef.current = sessionId;
+					activeRunTargetRef.current = {
+						sessionId,
+						sessionKey: null,
+					};
 					onActiveSessionChange?.(sessionId);
 					onSessionsChange?.();
 					userScrolledAwayRef.current = false;
@@ -1997,35 +2204,11 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 
 		// ── Stop handler (aborts server-side run + client-side stream) ──
 		const handleStop = useCallback(async () => {
-			// Abort reconnection stream if active (immediate visual feedback).
-			reconnectAbortRef.current?.abort();
-			setIsReconnecting(false);
-
-			// Read from refs to avoid stale closures — sessionIdRef is updated
-			// synchronously in handleEditorSubmit, so it's always current even
-			// if React hasn't re-rendered with the new state yet.
-			const sk = subagentSessionKeyRef.current;
-			const sid = sessionIdRef.current;
-			const stopKey = sk || sid;
-			if (stopKey) {
-				try {
-					await fetch("/api/chat/stop", {
-						method: "POST",
-						headers: {
-							"Content-Type": "application/json",
-						},
-						body: JSON.stringify(
-							sk
-								? { sessionKey: sk }
-								: { sessionId: sid },
-						),
-					});
-				} catch { /* ignore */ }
-			}
-
-			// Stop the useChat transport stream (transitions status → "ready").
-			void stop();
-		}, [stop]);
+			await stopActiveRun({
+				abortServer: true,
+				cascadeChildren: true,
+			});
+		}, [stopActiveRun]);
 
 		// ── Queue handlers ──
 
@@ -2659,13 +2842,13 @@ export const ChatPanel = forwardRef<ChatPanelHandle, ChatPanelProps>(
 
 				{/* Scroll to bottom button */}
 				{showScrollButton && !showHeroState && (
-					<div className="flex justify-center pointer-events-none" style={{ marginTop: -80, marginBottom: 4, position: "relative", zIndex: 20 }}>
+					<div className="flex justify-center pointer-events-none" style={{ marginTop: -44, position: "relative", zIndex: 20 }}>
 						<button
 							type="button"
 							onClick={scrollToBottom}
-							className="pointer-events-auto w-8 h-8 rounded-full flex items-center justify-center shadow-md border backdrop-blur-xl transition-colors"
+							className="pointer-events-auto w-8 h-8 rounded-full flex items-center justify-center shadow-md border transition-opacity hover:opacity-80"
 							style={{
-								background: "color-mix(in srgb, var(--color-surface) 70%, transparent)",
+								background: "var(--color-surface)",
 								borderColor: "var(--color-border)",
 								color: "var(--color-text-muted)",
 							}}
diff --git a/apps/web/app/components/chat-stream-status.ts b/apps/web/app/components/chat-stream-status.ts
index 7d7a3de94f22..55c75477314f 100644
--- a/apps/web/app/components/chat-stream-status.ts
+++ b/apps/web/app/components/chat-stream-status.ts
@@ -244,6 +244,13 @@ function getRunningToolLabel(parts: UIMessage["parts"]): string | null {
 	return null;
 }
 
+export function hasAssistantRunningTool(message: UIMessage | null): boolean {
+	return Boolean(
+		message?.role === "assistant" &&
+		getRunningToolLabel(message.parts),
+	);
+}
+
 export function getStreamActivityLabel({
 	loadingSession,
 	isReconnecting,
diff --git a/apps/web/lib/active-runs.test.ts b/apps/web/lib/active-runs.test.ts
index 0e2ccdbd048a..eaf7c397f254 100644
--- a/apps/web/lib/active-runs.test.ts
+++ b/apps/web/lib/active-runs.test.ts
@@ -308,6 +308,7 @@ describe("active-runs", () => {
 				sessionId,
 				message: "hello",
 				agentSessionId: sessionId,
+				sessionModel: "anthropic.claude-sonnet-4-6-v1",
 			});
 
 			subscribeToRun(
@@ -378,6 +379,7 @@ describe("active-runs", () => {
 				sessionId,
 				message: "hello",
 				agentSessionId: sessionId,
+				sessionModel: "anthropic.claude-sonnet-4-6-v1",
 			});
 
 			subscribeToRun(
@@ -401,6 +403,115 @@ describe("active-runs", () => {
 			).toBe(true);
 		});
 
+		it("retries a zero-token Claude empty upstream response on gpt-5.4", async () => {
+			const firstChild = createMockChild();
+			const secondChild = createMockChild();
+			const { spawnAgentProcess } = await import("./agent-runner.js");
+			const fs = await import("node:fs");
+			vi.mocked(spawnAgentProcess)
+				.mockReturnValueOnce(firstChild as unknown as ChildProcess)
+				.mockReturnValueOnce(secondChild as unknown as ChildProcess);
+			const initialSpawnCallCount = vi.mocked(spawnAgentProcess).mock.calls.length;
+
+			const { startRun, subscribeToRun } = await import("./active-runs.js");
+
+			const sessionId = "s-empty-upstream-retry";
+			const sessionKey = `agent:main:web:${sessionId}`;
+			const transcriptSessionId = "transcript-empty-retry";
+			const sessionsJsonPath = "/tmp/mock-state/agents/main/sessions/sessions.json";
+			const transcriptPath = `/tmp/mock-state/agents/main/sessions/${transcriptSessionId}.jsonl`;
+
+			vi.mocked(fs.existsSync).mockImplementation((path) =>
+				path === sessionsJsonPath || path === transcriptPath,
+			);
+			vi.mocked(fs.readFileSync).mockImplementation((path) => {
+				if (path === sessionsJsonPath) {
+					return JSON.stringify({
+						[sessionKey]: {
+							sessionId: transcriptSessionId,
+							model: "anthropic.claude-sonnet-4-6-v1",
+							modelProvider: "anthropic",
+							contextTokens: 971000,
+						},
+					});
+				}
+				if (path === transcriptPath) {
+					return `${JSON.stringify({
+						type: "message",
+						timestamp: new Date().toISOString(),
+						message: {
+							role: "assistant",
+							content: [],
+							stopReason: "stop",
+							responseId: "resp_empty_retry",
+							timestamp: Date.now(),
+							usage: { totalTokens: 0 },
+						},
+					})}\n`;
+				}
+				return "";
+			});
+
+			const events: SseEvent[] = [];
+
+			startRun({
+				sessionId,
+				message: "hello",
+				agentSessionId: sessionId,
+				sessionModel: "anthropic.claude-sonnet-4-6-v1",
+			});
+
+			subscribeToRun(
+				sessionId,
+				(event) => {
+					if (event) {events.push(event);}
+				},
+				{ replay: false },
+			);
+
+			firstChild.stdout.end();
+			await new Promise((r) => setTimeout(r, 50));
+			firstChild._emit("close", 0);
+
+			await new Promise((r) => setTimeout(r, 50));
+			expect(
+				vi.mocked(spawnAgentProcess).mock.calls.length - initialSpawnCallCount,
+			).toBe(2);
+			expect(vi.mocked(spawnAgentProcess).mock.calls.at(-1)?.[3]).toBe("gpt-5.4");
+			expect(
+				events.some(
+					(e) =>
+						e.type === "reasoning-delta" &&
+						e.delta === "Retrying with GPT-5.4 after Claude empty upstream response...",
+				),
+			).toBe(true);
+
+			secondChild._writeLine({
+				event: "agent",
+				stream: "assistant",
+				sessionKey,
+				data: { delta: "Recovered on retry" },
+			});
+			await new Promise((r) => setTimeout(r, 50));
+
+			secondChild.stdout.end();
+			await new Promise((r) => setTimeout(r, 50));
+			secondChild._emit("close", 0);
+
+			expect(
+				events.some(
+					(e) => e.type === "text-delta" && e.delta === "Recovered on retry",
+				),
+			).toBe(true);
+			expect(
+				events.some(
+					(e) =>
+						e.type === "text-delta" &&
+						e.delta === "[error] Agent finished with an empty upstream response.",
+				),
+			).toBe(false);
+		});
+
 		it("replays buffered events to a late subscriber when the run already completed", async () => {
 			const { child, startRun, subscribeToRun } = await setup();
 
@@ -495,6 +606,188 @@ describe("active-runs", () => {
 			).toBe(false);
 		});
 
+		it("recovers a missing final answer from transcript after tool-visible activity", async () => {
+			const { child, startRun, subscribeToRun } = await setup();
+			const fs = await import("node:fs");
+
+			const sessionId = "s-tool-transcript-recovery";
+			const sessionKey = `agent:main:web:${sessionId}`;
+			const transcriptSessionId = "transcript-tool-recovery";
+			const sessionsJsonPath = "/tmp/mock-state/agents/main/sessions/sessions.json";
+			const transcriptPath = `/tmp/mock-state/agents/main/sessions/${transcriptSessionId}.jsonl`;
+
+			vi.mocked(fs.existsSync).mockImplementation((path) =>
+				path === sessionsJsonPath || path === transcriptPath,
+			);
+			vi.mocked(fs.readFileSync).mockImplementation((path) => {
+				if (path === sessionsJsonPath) {
+					return JSON.stringify({
+						[sessionKey]: { sessionId: transcriptSessionId },
+					});
+				}
+				if (path === transcriptPath) {
+					return `${JSON.stringify({
+						type: "message",
+						timestamp: new Date().toISOString(),
+						message: {
+							role: "assistant",
+							content: [{ type: "text", text: "Recovered tool summary" }],
+							stopReason: "stop",
+							responseId: "resp_tool_recovered",
+							timestamp: Date.now(),
+						},
+					})}\n`;
+				}
+				return "";
+			});
+
+			const events: SseEvent[] = [];
+
+			startRun({
+				sessionId,
+				message: "use a tool",
+				agentSessionId: sessionId,
+			});
+
+			subscribeToRun(
+				sessionId,
+				(event) => {
+					if (event) {events.push(event);}
+				},
+				{ replay: false },
+			);
+
+			child._writeLine({
+				event: "agent",
+				stream: "tool",
+				sessionKey,
+				data: {
+					phase: "start",
+					toolCallId: "tool-2",
+					name: "searchDocs",
+					args: { query: "chat bug" },
+				},
+			});
+			child._writeLine({
+				event: "agent",
+				stream: "tool",
+				sessionKey,
+				data: {
+					phase: "result",
+					toolCallId: "tool-2",
+					name: "searchDocs",
+					result: { text: "found it" },
+				},
+			});
+			await new Promise((r) => setTimeout(r, 50));
+
+			child.stdout.end();
+			await new Promise((r) => setTimeout(r, 50));
+			child._emit("close", 0);
+
+			expect(
+				events.some(
+					(e) => e.type === "text-delta" && e.delta === "Recovered tool summary",
+				),
+			).toBe(true);
+			expect(
+				events.some(
+					(e) =>
+						e.type === "text-delta" &&
+						e.delta === "[error] Agent finished after tool activity without a final answer.",
+				),
+			).toBe(false);
+		});
+
+		it("surfaces a specific error when tool activity ends without a final answer", async () => {
+			const { child, startRun, subscribeToRun } = await setup();
+			const fs = await import("node:fs");
+
+			const sessionId = "s-tool-empty-final";
+			const sessionKey = `agent:main:web:${sessionId}`;
+			const transcriptSessionId = "transcript-tool-empty";
+			const sessionsJsonPath = "/tmp/mock-state/agents/main/sessions/sessions.json";
+			const transcriptPath = `/tmp/mock-state/agents/main/sessions/${transcriptSessionId}.jsonl`;
+
+			vi.mocked(fs.existsSync).mockImplementation((path) =>
+				path === sessionsJsonPath || path === transcriptPath,
+			);
+			vi.mocked(fs.readFileSync).mockImplementation((path) => {
+				if (path === sessionsJsonPath) {
+					return JSON.stringify({
+						[sessionKey]: { sessionId: transcriptSessionId },
+					});
+				}
+				if (path === transcriptPath) {
+					return `${JSON.stringify({
+						type: "message",
+						timestamp: new Date().toISOString(),
+						message: {
+							role: "assistant",
+							content: [],
+							stopReason: "stop",
+							responseId: "resp_tool_empty",
+							timestamp: Date.now(),
+							usage: { totalTokens: 0 },
+						},
+					})}\n`;
+				}
+				return "";
+			});
+
+			const events: SseEvent[] = [];
+
+			startRun({
+				sessionId,
+				message: "use a tool",
+				agentSessionId: sessionId,
+			});
+
+			subscribeToRun(
+				sessionId,
+				(event) => {
+					if (event) {events.push(event);}
+				},
+				{ replay: false },
+			);
+
+			child._writeLine({
+				event: "agent",
+				stream: "tool",
+				sessionKey,
+				data: {
+					phase: "start",
+					toolCallId: "tool-3",
+					name: "searchDocs",
+					args: { query: "chat bug" },
+				},
+			});
+			child._writeLine({
+				event: "agent",
+				stream: "tool",
+				sessionKey,
+				data: {
+					phase: "result",
+					toolCallId: "tool-3",
+					name: "searchDocs",
+					result: { text: "found it" },
+				},
+			});
+			await new Promise((r) => setTimeout(r, 50));
+
+			child.stdout.end();
+			await new Promise((r) => setTimeout(r, 50));
+			child._emit("close", 0);
+
+			expect(
+				events.some(
+					(e) =>
+						e.type === "text-delta" &&
+						e.delta === "[error] Agent finished after tool activity without a final answer.",
+				),
+			).toBe(true);
+		});
+
 		it("streams assistant text events for agent assistant output", async () => {
 			const { child, startRun, subscribeToRun } = await setup();
 
diff --git a/apps/web/lib/active-runs.ts b/apps/web/lib/active-runs.ts
index 3106115af9c4..2bd3622d6d44 100644
--- a/apps/web/lib/active-runs.ts
+++ b/apps/web/lib/active-runs.ts
@@ -112,6 +112,20 @@ export type ActiveRun = {
 	pinnedAgentId?: string;
 	/** Full gateway session key captured at run creation time. */
 	pinnedSessionKey?: string;
+	/** Original user message so a safe empty-upstream retry can respawn the run. */
+	originalMessage?: string;
+	/** Original agent session id used to respawn the run. */
+	originalAgentSessionId?: string;
+	/** Original override agent id used to respawn the run. */
+	originalOverrideAgentId?: string;
+	/** Original model override used to respawn the run. */
+	originalModelOverride?: string;
+	/** Effective model selected when the run started, before any automatic retry logic. */
+	originalSessionModel?: string;
+	/** Original image attachments used to respawn the run. */
+	originalImageAttachments?: ImageAttachment[];
+	/** Number of automatic retries attempted after a provably empty upstream turn. */
+	_emptyUpstreamRetryCount?: number;
 };
 
 // ── Constants ──
@@ -128,6 +142,9 @@ const SUBAGENT_REGISTRY_STALENESS_MS = 15 * 60_000;
 const MAX_FILTER_DROP_LOGS = 8;
 const EMPTY_RESPONSE_EVENT_SAMPLE_LIMIT = 5;
 const TRANSCRIPT_TURN_CLOCK_SKEW_MS = 5_000;
+const MAX_EMPTY_UPSTREAM_RETRIES = 1;
+const CLAUDE_SONNET_EMPTY_MODEL_ID = "anthropic.claude-sonnet-4-6-v1";
+const EMPTY_UPSTREAM_FALLBACK_MODEL_ID = "gpt-5.4";
 
 const SILENT_REPLY_TOKEN = "NO_REPLY";
 
@@ -608,6 +625,23 @@ function sendGatewayAbort(sessionId: string): void {
 	}
 }
 
+function bindAbortControllerToChild(
+	run: ActiveRun,
+	child: AgentProcessHandle,
+): void {
+	const onAbort = () => child.kill("SIGTERM");
+	if (run.abortController.signal.aborted) {
+		child.kill("SIGTERM");
+		return;
+	}
+	run.abortController.signal.addEventListener("abort", onAbort, {
+		once: true,
+	});
+	child.on("close", () =>
+		run.abortController.signal.removeEventListener("abort", onAbort),
+	);
+}
+
 /**
  * Start a new agent run for the given session.
  * Throws if a run is already active for this session.
@@ -619,6 +653,7 @@ export function startRun(params: {
 	/** Use a specific agent ID instead of the workspace default. */
 	overrideAgentId?: string;
 	modelOverride?: string;
+	sessionModel?: string;
 	imageAttachments?: ImageAttachment[];
 }): ActiveRun {
 	const {
@@ -627,6 +662,7 @@ export function startRun(params: {
 		agentSessionId,
 		overrideAgentId,
 		modelOverride,
+		sessionModel,
 		imageAttachments,
 	} = params;
 
@@ -672,22 +708,19 @@ export function startRun(params: {
 		_waitingFinalizeTimer: null,
 		pinnedAgentId: agentId,
 		pinnedSessionKey: sessionKey,
+		originalMessage: message,
+		originalAgentSessionId: agentSessionId,
+		originalOverrideAgentId: overrideAgentId,
+		originalModelOverride: modelOverride,
+		originalSessionModel: sessionModel,
+		originalImageAttachments: imageAttachments,
+		_emptyUpstreamRetryCount: 0,
 	};
 
 	activeRuns.set(sessionId, run);
 
 	// Wire abort signal → child process kill.
-	const onAbort = () => child.kill("SIGTERM");
-	if (abortController.signal.aborted) {
-		child.kill("SIGTERM");
-	} else {
-		abortController.signal.addEventListener("abort", onAbort, {
-			once: true,
-		});
-		child.on("close", () =>
-			abortController.signal.removeEventListener("abort", onAbort),
-		);
-	}
+	bindAbortControllerToChild(run, child);
 
 	wireChildProcess(run);
 	return run;
@@ -777,6 +810,9 @@ type TranscriptAssistantTurn = {
 	messageTimestamp: number | null;
 	textParts: string[];
 	tools: TranscriptToolPart[];
+	contentTypes: string[];
+	rawContentKind: "string" | "array" | "missing" | "other";
+	usageTotalTokens?: number;
 };
 
 function readTranscriptEntriesForSession(
@@ -823,11 +859,25 @@ function readLatestTranscriptAssistantTurn(
 		if (role === "assistant") {
 			const textParts: string[] = [];
 			const tools: TranscriptToolPart[] = [];
+			const rawContent = msg.content;
+			const rawContentKind =
+				typeof rawContent === "string"
+					? "string"
+					: Array.isArray(rawContent)
+						? "array"
+						: rawContent == null
+							? "missing"
+							: "other";
+			const content = Array.isArray(rawContent) ? rawContent : [];
+			const contentTypes: string[] = [];
 			for (const rawPart of content) {
 				const part = asRecord(rawPart);
 				if (!part) {
+					contentTypes.push("non-record");
 					continue;
 				}
+				const partType = typeof part.type === "string" ? part.type : "unknown";
+				contentTypes.push(partType);
 				if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
 					textParts.push(part.text);
 					continue;
@@ -847,6 +897,13 @@ function readLatestTranscriptAssistantTurn(
 					: typeof entry.timestamp === "string"
 						? Date.parse(entry.timestamp)
 						: Number.NaN;
+			const usage = asRecord(msg.usage);
+			const usageTotalTokens =
+				typeof usage?.totalTokens === "number"
+					? usage.totalTokens
+					: typeof usage?.total_tokens === "number"
+						? usage.total_tokens
+						: undefined;
 			latestAssistantTurn = {
 				sessionId: transcript.sessionId,
 				responseId: typeof msg.responseId === "string" ? msg.responseId : undefined,
@@ -854,6 +911,9 @@ function readLatestTranscriptAssistantTurn(
 				messageTimestamp: Number.isFinite(messageTimestamp) ? messageTimestamp : null,
 				textParts,
 				tools,
+				contentTypes,
+				rawContentKind,
+				usageTotalTokens,
 			};
 			continue;
 		}
@@ -1584,6 +1644,7 @@ function wireChildProcess(run: ActiveRun): void {
 	let textStarted = false;
 	let reasoningStarted = false;
 	let everSentResponseActivity = false;
+	let everSentAssistantText = false;
 	let statusReasoningActive = false;
 	let waitingStatusAnnounced = false;
 	let agentErrorReported = false;
@@ -1698,6 +1759,7 @@ function wireChildProcess(run: ActiveRun): void {
 			textStarted = true;
 		}
 		everSentResponseActivity = true;
+		everSentAssistantText = true;
 		emit({ type: "text-delta", id: currentTextId, delta: text });
 		accAppendText(text);
 		closeText();
@@ -1885,6 +1947,7 @@ function wireChildProcess(run: ActiveRun): void {
 					textStarted = true;
 				}
 				everSentResponseActivity = true;
+				everSentAssistantText = true;
 				emit({ type: "text-delta", id: currentTextId, delta: chunk });
 				accAppendText(chunk);
 			}
@@ -1903,6 +1966,7 @@ function wireChildProcess(run: ActiveRun): void {
 							textStarted = true;
 						}
 						everSentResponseActivity = true;
+						everSentAssistantText = true;
 						const md = `\n![media](${url.trim()})\n`;
 						emit({
 							type: "text-delta",
@@ -2051,6 +2115,32 @@ function wireChildProcess(run: ActiveRun): void {
 		if (ev.event === "chat") {
 			const text = extractAssistantTextFromChatPayload(ev.data);
 			if (text) {
+				const emittedFromChat = parentAssistantChunksCurrentTurn === 0;
+				// #region agent log
+				if (process.env.NODE_ENV !== "test") {
+					fetch("http://127.0.0.1:7651/ingest/93e0c293-34f1-4a69-8fce-870fc1b93fcb", {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							"X-Debug-Session-Id": "822d38",
+						},
+						body: JSON.stringify({
+							sessionId: "822d38",
+							runId: run.sessionId,
+							hypothesisId: "H9",
+							location: "apps/web/lib/active-runs.ts:2078",
+							message: emittedFromChat
+								? "chat final text emitted from active run"
+								: "chat final text ignored because assistant chunks already streamed",
+							data: {
+								parentAssistantChunksCurrentTurn,
+								textLength: text.length,
+							},
+							timestamp: Date.now(),
+						}),
+					}).catch(() => {});
+				}
+				// #endregion
 				if (parentAssistantChunksCurrentTurn === 0) {
 					emitAssistantFinalText(text);
 				}
@@ -2229,7 +2319,7 @@ function wireChildProcess(run: ActiveRun): void {
 
 		const exitedClean = code === 0 || code === null;
 		const transcriptBackfill =
-			!everSentResponseActivity && exitedClean
+			!everSentAssistantText && exitedClean
 				? maybeBackfillMissingResponseFromTranscript()
 				: null;
 		const latestTranscriptTurn = transcriptBackfill?.latestAssistantTurn ?? null;
@@ -2248,6 +2338,42 @@ function wireChildProcess(run: ActiveRun): void {
 			if (rawStdoutEventSamples.length > 0) {
 				console.warn("[active-runs] Last child stdout events before empty response", rawStdoutEventSamples);
 			}
+			// #region agent log
+			if (process.env.NODE_ENV !== "test") {
+				fetch("http://127.0.0.1:7651/ingest/93e0c293-34f1-4a69-8fce-870fc1b93fcb", {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						"X-Debug-Session-Id": "822d38",
+					},
+					body: JSON.stringify({
+						sessionId: "822d38",
+						runId: run.sessionId,
+						hypothesisId: "H4",
+						location: "apps/web/lib/active-runs.ts:2241",
+						message: "active run finished without response activity",
+						data: {
+							exitCode: code,
+							exitedClean,
+							elapsed,
+							hasStderr,
+							agentErrorReported,
+							rawStdoutLines: rawStdoutLineCount,
+							droppedSessionEvents: droppedSessionEventCount,
+							transcriptFound: latestTranscriptTurn !== null,
+							transcriptStopReason: latestTranscriptTurn?.stopReason ?? null,
+							transcriptResponseId: latestTranscriptTurn?.responseId ?? null,
+							transcriptTextPartCount: latestTranscriptTurn?.textParts.length ?? 0,
+							transcriptToolCount: latestTranscriptTurn?.tools.length ?? 0,
+							transcriptContentTypes: latestTranscriptTurn?.contentTypes ?? [],
+							transcriptRawContentKind: latestTranscriptTurn?.rawContentKind ?? null,
+							transcriptUsageTotalTokens: latestTranscriptTurn?.usageTotalTokens ?? null,
+						},
+						timestamp: Date.now(),
+					}),
+				}).catch(() => {});
+			}
+			// #endregion
 		}
 
 		if (!everSentResponseActivity && !exitedClean) {
@@ -2264,11 +2390,127 @@ function wireChildProcess(run: ActiveRun): void {
 				transcriptWasCurrentTurn &&
 				latestTranscriptTurn.textParts.length === 0 &&
 				latestTranscriptTurn.tools.length === 0;
+			const transcriptHadZeroUsage =
+				(latestTranscriptTurn?.usageTotalTokens ?? 0) === 0;
+			const sourceModel =
+				run.originalSessionModel ?? run.originalModelOverride;
+			const retryModelOverride =
+				sourceModel === CLAUDE_SONNET_EMPTY_MODEL_ID
+					? EMPTY_UPSTREAM_FALLBACK_MODEL_ID
+					: run.originalModelOverride;
+			const switchingModelsOnRetry =
+				typeof retryModelOverride === "string" &&
+				retryModelOverride !== run.originalModelOverride;
+			const shouldRetryEmptyUpstream =
+				transcriptWasEmpty &&
+				transcriptHadZeroUsage &&
+				!agentErrorReported &&
+				droppedSessionEventCount === 0 &&
+				rawStdoutLineCount <= 2 &&
+				(run._emptyUpstreamRetryCount ?? 0) < MAX_EMPTY_UPSTREAM_RETRIES &&
+				typeof run.originalMessage === "string";
+			if (shouldRetryEmptyUpstream) {
+				run._emptyUpstreamRetryCount = (run._emptyUpstreamRetryCount ?? 0) + 1;
+				openStatusReasoning(
+					switchingModelsOnRetry
+						? "Retrying with GPT-5.4 after Claude empty upstream response..."
+						: "Retrying after empty upstream response...",
+				);
+				// #region agent log
+				if (process.env.NODE_ENV !== "test") {
+					fetch("http://127.0.0.1:7651/ingest/93e0c293-34f1-4a69-8fce-870fc1b93fcb", {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							"X-Debug-Session-Id": "822d38",
+						},
+						body: JSON.stringify({
+							sessionId: "822d38",
+							runId: run.sessionId,
+							hypothesisId: "H10",
+							location: "apps/web/lib/active-runs.ts:2349",
+							message: "retrying clean empty-upstream response",
+							data: {
+								retryCount: run._emptyUpstreamRetryCount,
+								rawStdoutLines: rawStdoutLineCount,
+								droppedSessionEvents: droppedSessionEventCount,
+								transcriptResponseId: latestTranscriptTurn?.responseId ?? null,
+								transcriptUsageTotalTokens: latestTranscriptTurn?.usageTotalTokens ?? null,
+								sourceModel: sourceModel ?? null,
+								retryModelOverride: retryModelOverride ?? null,
+							},
+							timestamp: Date.now(),
+						}),
+					}).catch(() => {});
+				}
+				// #endregion
+				try {
+					const originalMessage = run.originalMessage;
+					if (typeof originalMessage !== "string") {
+						closeReasoning();
+						emitError("Agent finished with an empty upstream response.");
+						return;
+					}
+					const retryChild = spawnAgentProcess(
+						originalMessage,
+						run.originalAgentSessionId,
+						run.originalOverrideAgentId,
+						retryModelOverride,
+						run.originalImageAttachments,
+					);
+					run.childProcess = retryChild;
+					bindAbortControllerToChild(run, retryChild);
+					wireChildProcess(run);
+					return;
+				} catch {
+					closeReasoning();
+				}
+			}
 			emitError(
 				transcriptWasEmpty
 					? "Agent finished with an empty upstream response."
 					: "No response from agent.",
 			);
+		} else if (!everSentAssistantText && exitedClean) {
+			const transcriptWasCurrentTurn =
+				transcriptBackfill?.isCurrentTurn === true && latestTranscriptTurn !== null;
+			const transcriptWasEmpty =
+				transcriptWasCurrentTurn &&
+				latestTranscriptTurn.textParts.length === 0 &&
+				latestTranscriptTurn.tools.length === 0;
+			// #region agent log
+			if (process.env.NODE_ENV !== "test") {
+				fetch("http://127.0.0.1:7651/ingest/93e0c293-34f1-4a69-8fce-870fc1b93fcb", {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						"X-Debug-Session-Id": "822d38",
+					},
+					body: JSON.stringify({
+						sessionId: "822d38",
+						runId: run.sessionId,
+						hypothesisId: "H11",
+						location: "apps/web/lib/active-runs.ts:2361",
+						message: "run ended after tool activity without assistant text",
+						data: {
+							rawStdoutLines: rawStdoutLineCount,
+							droppedSessionEvents: droppedSessionEventCount,
+							transcriptFound: latestTranscriptTurn !== null,
+							transcriptStopReason: latestTranscriptTurn?.stopReason ?? null,
+							transcriptResponseId: latestTranscriptTurn?.responseId ?? null,
+							transcriptTextPartCount: latestTranscriptTurn?.textParts.length ?? 0,
+							transcriptToolCount: latestTranscriptTurn?.tools.length ?? 0,
+						},
+						timestamp: Date.now(),
+					}),
+				}).catch(() => {});
+			}
+			// #endregion
+			emitError(
+				transcriptWasEmpty
+					? "Agent finished after tool activity without a final answer."
+					: "Agent finished after tool activity without a recoverable final answer.",
+			);
 		} else {
 			closeText();
 		}
diff --git a/apps/web/lib/agent-runner.test.ts b/apps/web/lib/agent-runner.test.ts
index bfbb4d08cd75..0f0a91d3e7ec 100644
--- a/apps/web/lib/agent-runner.test.ts
+++ b/apps/web/lib/agent-runner.test.ts
@@ -332,6 +332,14 @@ describe("agent-runner", () => {
 
 		it("keeps stream open across lifecycle error and accepts continuation runId", async () => {
 			const MockWs = installMockWsModule();
+			MockWs.responseOverrides["chat.send"] = (frame) => ({
+				type: "res",
+				id: frame.id,
+				ok: true,
+				payload: {
+					runId: "r-initial",
+				},
+			});
 			const { spawnAgentProcess } = await import("./agent-runner.js");
 
 			const proc = spawnAgentProcess("hello", "sess-lifeerr");
@@ -590,7 +598,7 @@ describe("agent-runner", () => {
 			await waitFor(() => closed, { attempts: 80, delayMs: 10 });
 		});
 
-		it("suppresses chat events once agent events arrive in start mode", async () => {
+		it("forwards final chat text after agent events in start mode", async () => {
 			const MockWs = installMockWsModule();
 			const { spawnAgentProcess } = await import("./agent-runner.js");
 
@@ -627,15 +635,18 @@ describe("agent-runner", () => {
 					state: "final",
 					message: {
 						role: "assistant",
-						content: "should be ignored",
+						content: "should be forwarded",
 					},
 					sessionKey: "agent:main:web:sess-nochat",
 					globalSeq: 2,
 				},
 			});
 
-			await new Promise((resolve) => setTimeout(resolve, 40));
-			expect(stdout).not.toContain("should be ignored");
+			await waitFor(() => stdout.includes("should be forwarded"), {
+				attempts: 80,
+				delayMs: 10,
+			});
+			expect(stdout).toContain("should be forwarded");
 			proc.kill("SIGTERM");
 		});
 
diff --git a/apps/web/lib/agent-runner.ts b/apps/web/lib/agent-runner.ts
index f080955443a3..f51166b0d9cf 100644
--- a/apps/web/lib/agent-runner.ts
+++ b/apps/web/lib/agent-runner.ts
@@ -790,6 +790,14 @@ class GatewayProcessHandle
 	private sessionStarted = false;
 	private filterDropLogCount = 0;
 	private readonly startIdempotencyKey = randomUUID();
+	private debugAgentLifecycleCount = 0;
+	private debugAgentAssistantCount = 0;
+	private debugAgentToolCount = 0;
+	private debugChatFinalCount = 0;
+	private debugSuppressedChatFinalCount = 0;
+	private debugLastAgentStream: string | null = null;
+	private debugLastAgentPhase: string | null = null;
+	private debugCloseReason: string | null = null;
 
 	constructor(private readonly params: SpawnGatewayProcessParams) {
 		super();
@@ -1194,6 +1202,58 @@ class GatewayProcessHandle
 			recoveryActive: Date.now() <= this.lifecycleErrorRecoveryUntil,
 			...context,
 		});
+		// #region agent log
+		if (process.env.NODE_ENV !== "test") {
+			fetch("http://127.0.0.1:7651/ingest/93e0c293-34f1-4a69-8fce-870fc1b93fcb", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"X-Debug-Session-Id": "822d38",
+				},
+				body: JSON.stringify({
+					sessionId: "822d38",
+					runId: this.runId ?? this.params.sessionKey ?? "pending",
+					hypothesisId: "H3",
+					location: "apps/web/lib/agent-runner.ts:1183",
+					message: "gateway event filtered",
+					data: {
+						reason,
+						event: frame.event,
+						stream: stream ?? null,
+						globalSeq: globalSeq ?? null,
+						replayFloorSeq: this.replayFloorSeq,
+						recoveryActive: Date.now() <= this.lifecycleErrorRecoveryUntil,
+						filterDropLogCount: this.filterDropLogCount,
+					},
+					timestamp: Date.now(),
+				}),
+			}).catch(() => {});
+		}
+		// #endregion
+	}
+
+	private shouldAdoptIncomingRunId(params: {
+		incomingRunId: string;
+		eventGlobalSeq?: number;
+		stream?: string;
+		phase?: string;
+	}): boolean {
+		if (!this.runId || params.incomingRunId === this.runId) {
+			return true;
+		}
+		if (Date.now() <= this.lifecycleErrorRecoveryUntil) {
+			return true;
+		}
+		const hasAdvancedGlobalSeq =
+			typeof params.eventGlobalSeq === "number" &&
+			params.eventGlobalSeq > this.lastGlobalSeq;
+		if (!hasAdvancedGlobalSeq || !this.sessionStarted || this.closeScheduled) {
+			return false;
+		}
+		if (params.stream === "lifecycle") {
+			return params.phase !== "start";
+		}
+		return params.stream === "item";
 	}
 
 	private handleGatewayEvent(frame: GatewayEventFrame): void {
@@ -1217,12 +1277,29 @@ class GatewayProcessHandle
 				return;
 			}
 			const runId = typeof payload.runId === "string" ? payload.runId : undefined;
+			const stream =
+				typeof payload.stream === "string" ? payload.stream : undefined;
+			const data = asRecord(payload.data);
+			const phase = data && typeof data.phase === "string" ? data.phase : undefined;
+			const payloadGlobalSeq =
+				typeof payload.globalSeq === "number" ? payload.globalSeq : undefined;
+			const eventGlobalSeq =
+				payloadGlobalSeq ??
+				(typeof frame.seq === "number" ? frame.seq : undefined);
+			const streamName = stream ?? "";
+			const phaseName = phase ?? "";
 			if (this.runId && runId && runId !== this.runId) {
-				if (Date.now() <= this.lifecycleErrorRecoveryUntil) {
-					// The gateway can recover from lifecycle/error by creating
-					// a continuation run with a new runId under the same session.
-					// During the recovery window, follow that new run so the UI
-					// doesn't miss trailing events before final termination.
+				if (
+					this.shouldAdoptIncomingRunId({
+						incomingRunId: runId,
+						eventGlobalSeq,
+						stream,
+						phase,
+					})
+				) {
+					// The gateway can recover by continuing the same session under
+					// a new runId. Follow the continuation run so the UI keeps
+					// receiving trailing lifecycle and final assistant events.
 					this.runId = runId;
 					this.clearLifecycleErrorCloseTimer();
 				} else {
@@ -1230,11 +1307,6 @@ class GatewayProcessHandle
 					return;
 				}
 			}
-			const payloadGlobalSeq =
-				typeof payload.globalSeq === "number" ? payload.globalSeq : undefined;
-			const eventGlobalSeq =
-				payloadGlobalSeq ??
-				(typeof frame.seq === "number" ? frame.seq : undefined);
 			if (
 				typeof eventGlobalSeq === "number" &&
 				eventGlobalSeq <= this.replayFloorSeq
@@ -1251,12 +1323,25 @@ class GatewayProcessHandle
 			) {
 				this.lastGlobalSeq = eventGlobalSeq;
 			}
+			if (streamName === "lifecycle") {
+				this.debugAgentLifecycleCount += 1;
+			} else if (streamName === "assistant") {
+				this.debugAgentAssistantCount += 1;
+			} else if (streamName === "tool") {
+				this.debugAgentToolCount += 1;
+			}
+			if (streamName) {
+				this.debugLastAgentStream = streamName;
+			}
+			if (phaseName) {
+				this.debugLastAgentPhase = phaseName;
+			}
 
 			const event: AgentEvent = {
 				event: "agent",
 				...(runId ? { runId } : {}),
-				...(typeof payload.stream === "string" ? { stream: payload.stream } : {}),
-				...(asRecord(payload.data) ? { data: payload.data as Record<string, unknown> } : {}),
+				...(stream ? { stream } : {}),
+				...(data ? { data } : {}),
 				...(typeof payload.seq === "number" ? { seq: payload.seq } : {}),
 				...(typeof eventGlobalSeq === "number"
 					? { globalSeq: eventGlobalSeq }
@@ -1267,34 +1352,31 @@ class GatewayProcessHandle
 
 			(this.stdout as PassThrough).write(`${JSON.stringify(event)}\n`);
 
-			const stream = typeof payload.stream === "string" ? payload.stream : "";
-			const data = asRecord(payload.data);
-			const phase = data && typeof data.phase === "string" ? data.phase : "";
 			if (
 				this.params.mode === "start" &&
 				this.params.sessionKey?.includes(":web:") &&
-				stream === "tool" &&
-				phase === "result" &&
+				streamName === "tool" &&
+				phaseName === "result" &&
 				typeof data?.name === "string" &&
 				data.name === "sessions_yield" &&
 				sessionKey === this.params.sessionKey
 			) {
-				this.scheduleClose();
+				this.scheduleClose("sessions_yield_tool_result");
 			}
-			if (!(stream === "lifecycle" && phase === "error")) {
+			if (!(streamName === "lifecycle" && phaseName === "error")) {
 				this.clearLifecycleErrorCloseTimer();
 			}
 			if (
 				this.params.mode === "start" &&
-				stream === "lifecycle" &&
-				phase === "end"
+				streamName === "lifecycle" &&
+				phaseName === "end"
 			) {
-				this.scheduleClose();
+				this.scheduleClose("agent_lifecycle_end");
 			}
 			if (
 				this.params.mode === "start" &&
-				stream === "lifecycle" &&
-				phase === "error"
+				streamName === "lifecycle" &&
+				phaseName === "error"
 			) {
 				this.armLifecycleErrorCloseTimer();
 			}
@@ -1305,27 +1387,105 @@ class GatewayProcessHandle
 			const payload = asRecord(frame.payload) ?? {};
 			const sessionKey =
 				typeof payload.sessionKey === "string" ? payload.sessionKey : undefined;
+			const message = asRecord(payload.message);
+			const messageRole =
+				typeof message?.role === "string" ? message.role : undefined;
+			const rawMessageContent = message?.content;
+			const messageContentKind =
+				typeof rawMessageContent === "string"
+					? "string"
+					: Array.isArray(rawMessageContent)
+						? "array"
+						: rawMessageContent == null
+							? "missing"
+							: "other";
+			const messageTextLength =
+				typeof rawMessageContent === "string"
+					? rawMessageContent.length
+					: Array.isArray(rawMessageContent)
+						? rawMessageContent.reduce((total, part) => {
+							const rec = asRecord(part);
+							if (
+								(rec?.type === "text" || rec?.type === "output_text") &&
+								typeof rec.text === "string"
+							) {
+								return total + rec.text.length;
+							}
+							return total;
+						}, 0)
+						: 0;
+			const messageContentPartTypes =
+				Array.isArray(rawMessageContent)
+					? rawMessageContent.slice(0, 8).map((part) => {
+						const rec = asRecord(part);
+						return typeof rec?.type === "string" ? rec.type : "unknown";
+					})
+					: [];
+			const payloadGlobalSeq =
+				typeof payload.globalSeq === "number" ? payload.globalSeq : undefined;
+			const eventGlobalSeq =
+				payloadGlobalSeq ??
+				(typeof frame.seq === "number" ? frame.seq : undefined);
+			const isFinalAssistantChat =
+				typeof payload.state === "string" &&
+				payload.state === "final" &&
+				messageRole === "assistant";
 			// Forward chat frames in subscribe mode unconditionally.
-			// In start mode, only forward when using chat.send for
-			// slash commands — the gateway returns command responses
-			// as chat events rather than agent events.  Skip if we
-			// already received agent events (agent run started) to
-			// avoid duplicating the assistant text.
+			// In start mode, chat.send can still produce the only
+			// finalized assistant text after tool/lifecycle agent
+			// events. Keep suppressing most chat frames once agent
+			// events arrive, but allow a non-empty final assistant
+			// message through so the caller can decide whether to
+			// dedupe or surface it.
 			const forwardChat =
 				this.params.mode === "subscribe" ||
-				(this.useChatSend && !this.receivedAgentEvent);
+				(
+					this.useChatSend &&
+					(!this.receivedAgentEvent || (isFinalAssistantChat && messageTextLength > 0))
+				);
 			if (!forwardChat) {
+				if (isFinalAssistantChat) {
+					this.debugChatFinalCount += 1;
+					this.debugSuppressedChatFinalCount += 1;
+					// #region agent log
+					if (process.env.NODE_ENV !== "test") {
+						fetch("http://127.0.0.1:7651/ingest/93e0c293-34f1-4a69-8fce-870fc1b93fcb", {
+							method: "POST",
+							headers: {
+								"Content-Type": "application/json",
+								"X-Debug-Session-Id": "822d38",
+							},
+							body: JSON.stringify({
+								sessionId: "822d38",
+								runId: this.runId ?? this.params.sessionKey ?? "pending",
+								hypothesisId: "H1",
+								location: "apps/web/lib/agent-runner.ts:1350",
+								message: "suppressed final chat event after agent events",
+								data: {
+									useChatSend: this.useChatSend,
+									receivedAgentEvent: this.receivedAgentEvent,
+									messageContentKind,
+									messageTextLength,
+									messageContentPartTypes,
+									eventGlobalSeq: eventGlobalSeq ?? null,
+									agentLifecycleCount: this.debugAgentLifecycleCount,
+									agentAssistantCount: this.debugAgentAssistantCount,
+									agentToolCount: this.debugAgentToolCount,
+									lastAgentStream: this.debugLastAgentStream,
+									lastAgentPhase: this.debugLastAgentPhase,
+								},
+								timestamp: Date.now(),
+							}),
+						}).catch(() => {});
+					}
+					// #endregion
+				}
 				return;
 			}
 			if (!this.shouldAcceptSessionEvent(sessionKey)) {
 				this.logFilteredGatewayEvent("session-key-mismatch", frame);
 				return;
 			}
-			const payloadGlobalSeq =
-				typeof payload.globalSeq === "number" ? payload.globalSeq : undefined;
-			const eventGlobalSeq =
-				payloadGlobalSeq ??
-				(typeof frame.seq === "number" ? frame.seq : undefined);
 			if (
 				typeof eventGlobalSeq === "number" &&
 				eventGlobalSeq <= this.replayFloorSeq
@@ -1342,6 +1502,9 @@ class GatewayProcessHandle
 			) {
 				this.lastGlobalSeq = eventGlobalSeq;
 			}
+			if (isFinalAssistantChat) {
+				this.debugChatFinalCount += 1;
+			}
 			const event: AgentEvent = {
 				event: "chat",
 				data: payload,
@@ -1358,7 +1521,7 @@ class GatewayProcessHandle
 				typeof payload.state === "string" &&
 				payload.state === "final"
 			) {
-				this.scheduleClose();
+				this.scheduleClose("chat_final");
 			}
 			return;
 		}
@@ -1408,14 +1571,18 @@ class GatewayProcessHandle
 	}
 
 	private armLifecycleErrorCloseTimer(): void {
+		if (this.lifecycleErrorCloseTimer) {
+			clearTimeout(this.lifecycleErrorCloseTimer);
+			this.lifecycleErrorCloseTimer = null;
+		}
 		this.lifecycleErrorRecoveryUntil = Date.now() + LIFECYCLE_ERROR_RECOVERY_MS;
-		this.clearLifecycleErrorCloseTimer();
 		this.lifecycleErrorCloseTimer = setTimeout(() => {
 			this.lifecycleErrorCloseTimer = null;
+			this.lifecycleErrorRecoveryUntil = 0;
 			if (this.finished) {
 				return;
 			}
-			this.scheduleClose();
+			this.scheduleClose("lifecycle_error_timeout");
 		}, LIFECYCLE_ERROR_RECOVERY_MS);
 	}
 
@@ -1428,11 +1595,43 @@ class GatewayProcessHandle
 		this.lifecycleErrorCloseTimer = null;
 	}
 
-	private scheduleClose(): void {
+	private scheduleClose(reason: string): void {
 		if (this.closeScheduled || this.finished) {
 			return;
 		}
 		this.closeScheduled = true;
+		this.debugCloseReason = reason;
+		// #region agent log
+		if (process.env.NODE_ENV !== "test") {
+			fetch("http://127.0.0.1:7651/ingest/93e0c293-34f1-4a69-8fce-870fc1b93fcb", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"X-Debug-Session-Id": "822d38",
+				},
+				body: JSON.stringify({
+					sessionId: "822d38",
+					runId: this.runId ?? this.params.sessionKey ?? "pending",
+					hypothesisId: "H2",
+					location: "apps/web/lib/agent-runner.ts:1472",
+					message: "gateway child scheduled close",
+					data: {
+						reason,
+						useChatSend: this.useChatSend,
+						agentLifecycleCount: this.debugAgentLifecycleCount,
+						agentAssistantCount: this.debugAgentAssistantCount,
+						agentToolCount: this.debugAgentToolCount,
+						chatFinalCount: this.debugChatFinalCount,
+						suppressedChatFinalCount: this.debugSuppressedChatFinalCount,
+						lastAgentStream: this.debugLastAgentStream,
+						lastAgentPhase: this.debugLastAgentPhase,
+						lastGlobalSeq: this.lastGlobalSeq,
+					},
+					timestamp: Date.now(),
+				}),
+			}).catch(() => {});
+		}
+		// #endregion
 		this.clearReconnectTimer();
 		setTimeout(() => {
 			if (this.finished) {
diff --git a/apps/web/lib/dench-cloud-settings.test.ts b/apps/web/lib/dench-cloud-settings.test.ts
index dd0f67073c32..4e1132b2798a 100644
--- a/apps/web/lib/dench-cloud-settings.test.ts
+++ b/apps/web/lib/dench-cloud-settings.test.ts
@@ -88,7 +88,6 @@ const mocks = vi.hoisted(() => {
       tools: {
         alsoAllow: [
           "composio_search_tools",
-          "composio_resolve_tool",
           "composio_call_tool",
         ],
       },
@@ -132,12 +131,21 @@ vi.mock("./integrations", () => ({
   refreshIntegrationsRuntime: mocks.refreshIntegrationsRuntime,
 }));
 
-import { saveApiKey, saveVoiceId, selectModel } from "./dench-cloud-settings";
+import {
+  readConfiguredSelectedDenchModel,
+  saveApiKey,
+  saveVoiceId,
+  selectModel,
+} from "./dench-cloud-settings";
 
 describe("dench cloud settings", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mocks.state.configText = "{}\n";
+    mocks.readConfiguredDenchCloudSettings.mockReturnValue({
+      gatewayUrl: null,
+      selectedModel: null,
+    });
     mocks.validateDenchCloudApiKey.mockResolvedValue(undefined);
     mocks.fetchDenchCloudCatalog.mockResolvedValue({
       source: "live",
@@ -187,11 +195,19 @@ describe("dench cloud settings", () => {
     );
     expect(written.tools.alsoAllow).toEqual([
       "composio_call_tool",
-      "composio_resolve_tool",
       "composio_search_tools",
     ]);
   });
 
+  it("reads the configured selected Dench model synchronously", () => {
+    mocks.readConfiguredDenchCloudSettings.mockReturnValue({
+      gatewayUrl: "https://gateway.merseoriginals.com",
+      selectedModel: "anthropic.claude-sonnet-4-6-v1",
+    });
+
+    expect(readConfiguredSelectedDenchModel()).toBe("anthropic.claude-sonnet-4-6-v1");
+  });
+
   it("refreshes integrations when switching the primary model to Dench Cloud", async () => {
     mocks.state.configText = JSON.stringify({
       models: {
@@ -212,7 +228,6 @@ describe("dench cloud settings", () => {
     expect(written.mcp.servers.composio.headers.Authorization).toBe("Bearer dc-key");
     expect(written.tools.alsoAllow).toEqual([
       "composio_call_tool",
-      "composio_resolve_tool",
       "composio_search_tools",
     ]);
   });
diff --git a/apps/web/lib/dench-cloud-settings.ts b/apps/web/lib/dench-cloud-settings.ts
index ce7efc95d9dd..daec6b147d46 100644
--- a/apps/web/lib/dench-cloud-settings.ts
+++ b/apps/web/lib/dench-cloud-settings.ts
@@ -87,6 +87,14 @@ function resolvePrimaryModel(config: UnknownRecord): string | null {
   return typeof primary === "string" && primary.trim() ? primary.trim() : null;
 }
 
+export function readConfiguredSelectedDenchModel(): string | null {
+  const config = readConfig();
+  const settings = readConfiguredDenchCloudSettings(config);
+  return typeof settings.selectedModel === "string" && settings.selectedModel.trim()
+    ? settings.selectedModel.trim()
+    : null;
+}
+
 function ensureRecord(parent: UnknownRecord, key: string): UnknownRecord {
   const existing = asRecord(parent[key]);
   if (existing) return existing;