diff --git a/e2e/support/start-mock-trino.ts b/e2e/support/start-mock-trino.ts
index 2610438e..e11b22b7 100644
--- a/e2e/support/start-mock-trino.ts
+++ b/e2e/support/start-mock-trino.ts
@@ -109,6 +109,8 @@ const DEFAULT_RESPONSE = {
 //
 //   FROM paged_table            QUEUED, then 3 pages of 10 rows via GET
 //   FROM finished_paged_table   first response already FINISHED, 1 more page via GET
+//   FROM huge_table             one page of MAX_CLIENT_ROWS + 1 rows (row limit exceeded)
+//   FROM exact_limit_table      exactly MAX_CLIENT_ROWS rows, then an empty trailing page
 //   FAILS_SILENTLY              first response FAILED without an error object
 //   FAILS_LATER                 one page of rows, then FAILED without an error object
 //   HOLD:<id>                   RUNNING until released via POST /__mock/release/<id>
@@ -188,6 +190,52 @@ function startPagedQuery(id: string, sql: string): Page | null {
     });
     return { id, nextUri: nextUri(id, 1), stats: { state: 'QUEUED' } };
   }
+  if (sql.includes('FROM huge_table')) {
+    // First page is empty; the follow-up page exceeds MAX_CLIENT_ROWS.
+    queries.set(id, {
+      sql,
+      pages: [
+        {
+          id,
+          columns: [{ name: 'id', type: 'integer' }],
+          data: Array.from({ length: 10_001 }, (_, i) => [i + 1]),
+          nextUri: nextUri(id, 2),
+          stats: { state: 'RUNNING' }
+        }
+      ]
+    });
+    return {
+      id,
+      columns: [{ name: 'id', type: 'integer' }],
+      data: [],
+      nextUri: nextUri(id, 1),
+      stats: { state: 'RUNNING' }
+    };
+  }
+  if (sql.includes('FROM exact_limit_table')) {
+    // Like Trino for `LIMIT 10000`: the page completing the result still carries a nextUri,
+    // which only leads to an empty FINISHED page.
+    queries.set(id, {
+      sql,
+      pages: [
+        {
+          id,
+          columns: [{ name: 'id', type: 'integer' }],
+          data: Array.from({ length: 10_000 }, (_, i) => [i + 1]),
+          nextUri: nextUri(id, 2),
+          stats: { state: 'FINISHED' }
+        },
+        { id, stats: { state: 'FINISHED' } }
+      ]
+    });
+    return {
+      id,
+      columns: [{ name: 'id', type: 'integer' }],
+      data: [],
+      nextUri: nextUri(id, 1),
+      stats: { state: 'RUNNING' }
+    };
+  }
   if (sql.includes('FROM finished_paged_table')) {
     queries.set(id, { sql, pages: [{ id, data: rows(11, 10), stats: { state: 'FINISHED' } }] });
     return {
diff --git a/e2e/trino/trino.spec.ts b/e2e/trino/trino.spec.ts
index b305cef4..2349e393 100644
--- a/e2e/trino/trino.spec.ts
+++ b/e2e/trino/trino.spec.ts
@@ -36,6 +36,65 @@ test.describe('Trino query editor', () => {
     await expect(table.getByRole('cell', { name: '1' })).toBeVisible();
     await expect(table.getByRole('cell', { name: 'Alice' })).toBeVisible();
     await expect(page.getByText('Rows 1–3 of 3')).toBeVisible();
+    await expect(page.getByText(/^3 rows returned \|/)).toBeVisible();
+  });
+
+  test('hitting the row limit is reported in the status bar', async ({ page }) => {
+    await setTabSql(page, 'SELECT * FROM huge_table');
+    await page.goto('/trino');
+    await waitForHydration(page);
+    await page.locator('.monaco-editor').first().click();
+
+    await page.getByRole('button', { name: 'Run', exact: true }).click();
+    await waitForQueryComplete(page);
+
+    const status = page.locator('[data-query-state="FINISHED"]');
+    await expect(status.getByText('Row limit reached', { exact: true })).toBeVisible();
+    await expect(status.getByText(/^10,001 rows returned \|/)).toBeVisible();
+    await expect(status).not.toContainText('rows processed');
+    await expect(page.getByRole('table', { name: 'Query results' })).toBeVisible();
+    // A single statement's row limit is only reported in the status bar.
+    await expect(page.getByText(/remaining rows not fetched/)).toHaveCount(0);
+  });
+
+  test('a result of exactly the row limit is not reported as truncated', async ({ page }) => {
+    await setTabSql(page, 'SELECT * FROM exact_limit_table');
+    await page.goto('/trino');
+    await waitForHydration(page);
+    await page.locator('.monaco-editor').first().click();
+
+    await page.getByRole('button', { name: 'Run', exact: true }).click();
+    await waitForQueryComplete(page);
+
+    const status = page.locator('[data-query-state="FINISHED"]');
+    await expect(status.getByText('Finished', { exact: true })).toBeVisible();
+    await expect(status.getByText(/^10,000 rows returned \|/)).toBeVisible();
+    await expect(page.getByText('Row limit reached')).toHaveCount(0);
+  });
+
+  test('row limit in a multi-statement script is reported on the affected statement', async ({
+    page
+  }) => {
+    await setTabSql(page, 'SELECT * FROM huge_table; SELECT id, name FROM users');
+    await page.goto('/trino');
+    await waitForHydration(page);
+    await page.locator('.monaco-editor').first().click();
+
+    await page.keyboard.press('Control+Shift+Enter');
+    await expect(page.getByRole('table', { name: 'Query results — Statement 2' })).toBeVisible();
+
+    const panelFor = async (index: number) => {
+      const toggle = page.getByRole('button', { name: `Toggle statement ${index} results` });
+      return page.locator(`[id="${await toggle.getAttribute('aria-controls')}"]`);
+    };
+    const warning = 'Row limit of 10,000 exceeded — remaining rows not fetched.';
+    await expect((await panelFor(1)).getByText(warning)).toBeVisible();
+    await expect((await panelFor(2)).getByText(warning)).toHaveCount(0);
+
+    // The status bar describes the last statement, which completed normally.
+    const status = page.locator('[data-query-state="FINISHED"]');
+    await expect(status.getByText('Finished', { exact: true })).toBeVisible();
+    await expect(status.getByText(/^3 rows returned \|/)).toBeVisible();
   });
 
   test('Ctrl+Enter triggers query execution', async ({ page }) => {
diff --git a/messages/de.json b/messages/de.json
index b7ce2634..01152b28 100644
--- a/messages/de.json
+++ b/messages/de.json
@@ -87,8 +87,11 @@
   "trino_state_finished": "Abgeschlossen",
   "trino_state_failed": "Fehlgeschlagen",
   "trino_state_cancelled": "Abgebrochen",
-  "trino_progress_info": "{rows} Zeilen verarbeitet | {elapsed} s",
-  "trino_row_limit_reached": "Zeilenlimit von {limit} erreicht — Abfrage abgebrochen.",
+  "trino_state_row_limit": "Zeilenlimit erreicht",
+  "trino_progress_info": "{rows} Zeilen abgerufen | {elapsed}",
+  "trino_elapsed_ms": "{value} ms",
+  "trino_elapsed_s": "{value} s",
+  "trino_row_limit_reached": "Zeilenlimit von {limit} überschritten — weitere Zeilen wurden nicht abgerufen.",
   "trino_catalog_browser": "Katalogbrowser",
   "trino_catalog_browser_toggle": "Katalogbrowser ein-/ausblenden",
   "trino_catalog_label": "Katalog",
diff --git a/messages/en.json b/messages/en.json
index d64250a1..02ae08b6 100644
--- a/messages/en.json
+++ b/messages/en.json
@@ -87,8 +87,11 @@
   "trino_state_finished": "Finished",
   "trino_state_failed": "Failed",
   "trino_state_cancelled": "Cancelled",
-  "trino_progress_info": "{rows} rows processed | {elapsed}s",
-  "trino_row_limit_reached": "Row limit of {limit} reached — query cancelled.",
+  "trino_state_row_limit": "Row limit reached",
+  "trino_progress_info": "{rows} rows returned | {elapsed}",
+  "trino_elapsed_ms": "{value} ms",
+  "trino_elapsed_s": "{value} s",
+  "trino_row_limit_reached": "Row limit of {limit} exceeded — remaining rows not fetched.",
   "trino_catalog_browser": "Catalog browser",
   "trino_catalog_browser_toggle": "Toggle catalog browser",
   "trino_catalog_label": "Catalog",
diff --git a/src/lib/components/trino/StatementResult.svelte b/src/lib/components/trino/StatementResult.svelte
index a24b804f..fe76213d 100644
--- a/src/lib/components/trino/StatementResult.svelte
+++ b/src/lib/components/trino/StatementResult.svelte
@@ -1,10 +1,11 @@
 <script lang="ts">
   import { browser } from '$app/environment';
   import * as m from '$lib/paraglide/messages.js';
+  import { getLocale } from '$lib/paraglide/runtime.js';
   import IconExpandMore from 'virtual:icons/material-symbols/expand-more';
   import IconOpenInNew from 'virtual:icons/material-symbols/open-in-new';
   import IconDownload from 'virtual:icons/material-symbols/download';
-  import type { QuerySnapshot } from '$lib/types/query';
+  import { MAX_CLIENT_ROWS, type QuerySnapshot } from '$lib/types/query';
   import { initPageSize, type PageSize } from '$lib/types/pagination.js';
   import Pagination from '$lib/components/Pagination.svelte';
 
@@ -35,10 +36,12 @@
   const rowStart = $derived(currentPage * pageSize + 1);
   const rowEnd = $derived(currentPage * pageSize + displayedRows.length);
   const stmtError = $derived(result.error);
+  const showHeader = $derived(totalStatements > 1);
   const rowLimitWarning = $derived(
-    result.rowLimit !== null ? m.trino_row_limit_reached({ limit: result.rowLimit }) : null
+    showHeader && result.rowLimitReached
+      ? m.trino_row_limit_reached({ limit: MAX_CLIENT_ROWS.toLocaleString(getLocale()) })
+      : null
   );
-  const showHeader = $derived(totalStatements > 1);
 
   const CSV_HEADERS_KEY = 'trino_csv_include_headers';
   let includeHeaders = $state(browser ? localStorage.getItem(CSV_HEADERS_KEY) === 'true' : false);
@@ -203,6 +206,9 @@
           ">{stmtError}</pre>
       </div>
     {:else if result.state === 'FINISHED' && result.columns.length > 0}
+      {#if rowLimitWarning}
+        <p class="text-warning text-xs">{rowLimitWarning}</p>
+      {/if}
       <div class="overflow-x-auto">
         <table
           class="table-zebra table-sm table"
@@ -234,9 +240,6 @@
           </tbody>
         </table>
       </div>
-      {#if rowLimitWarning}
-        <span class="text-warning mt-1 block text-xs">{rowLimitWarning}</span>
-      {/if}
       <div class="pt-2">
         <Pagination
           bind:pageSize
diff --git a/src/lib/server/trino/queries.test.ts b/src/lib/server/trino/queries.test.ts
index 78335144..ebcbbe04 100644
--- a/src/lib/server/trino/queries.test.ts
+++ b/src/lib/server/trino/queries.test.ts
@@ -134,16 +134,14 @@ describe('toQueryProgress', () => {
   it('returns zeroed progress without stats', () => {
     expect(q.toQueryProgress(undefined)).toEqual({
       progressPercentage: 0,
-      processedRows: 0,
       elapsedTimeMillis: 0
     });
   });
 
   it('defaults missing stat fields to 0', () => {
-    expect(q.toQueryProgress({ state: 'RUNNING', processedRows: 42 })).toEqual({
+    expect(q.toQueryProgress({ state: 'RUNNING', elapsedTimeMillis: 42 })).toEqual({
       progressPercentage: 0,
-      processedRows: 42,
-      elapsedTimeMillis: 0
+      elapsedTimeMillis: 42
     });
   });
 });
@@ -217,7 +215,7 @@ describe('startScript', () => {
       id: 'q1',
       columns: [{ name: 'n', type: 'bigint' }],
       data: [[7]],
-      stats: { state: 'FINISHED', processedRows: 1 }
+      stats: { state: 'FINISHED', elapsedTimeMillis: 1 }
     });
 
     await q.startScript(trinoClient(), USER, TAB, ['SELECT 7'], OPTS);
@@ -229,7 +227,7 @@ describe('startScript', () => {
       state: 'FINISHED',
       columns: [{ name: 'n', type: 'bigint' }],
       rows: [[7]],
-      progress: { processedRows: 1 }
+      progress: { elapsedTimeMillis: 1 }
     });
   });
 
diff --git a/src/lib/server/trino/queries.ts b/src/lib/server/trino/queries.ts
index 04cf9892..6161be8c 100644
--- a/src/lib/server/trino/queries.ts
+++ b/src/lib/server/trino/queries.ts
@@ -29,7 +29,7 @@ export interface TrinoQuery {
   columns: Column[];
   rows: unknown[][];
   error: string | null;
-  rowLimit: number | null;
+  rowLimitReached: boolean;
   sql: string;
   startedAt: number;
   nextUri: string | undefined;
@@ -52,7 +52,6 @@ export function toQueryProgress(stats: TrinoQueryStats | undefined): QueryProgre
   if (!stats) return INITIAL_PROGRESS;
   return {
     progressPercentage: stats.progressPercentage ?? 0,
-    processedRows: stats.processedRows ?? 0,
     elapsedTimeMillis: stats.elapsedTimeMillis ?? 0
   };
 }
@@ -154,8 +153,9 @@ function buildSnapshot(
     progress: query.progress,
     columns: lightweight ? [] : query.columns,
     rows: lightweight ? [] : query.rows,
+    rowCount: query.rows.length,
     error: query.error,
-    rowLimit: query.rowLimit,
+    rowLimitReached: query.rowLimitReached,
     sql: query.sql,
     startedAt: query.startedAt
   };
@@ -207,7 +207,7 @@ async function submitStatement(
     columns: submitResult.columns ?? [],
     rows: submitResult.data ?? [],
     error: null,
-    rowLimit: null,
+    rowLimitReached: false,
     sql,
     startedAt: Date.now(),
     nextUri: submitResult.nextUri,
diff --git a/src/lib/server/trino/result-collector.test.ts b/src/lib/server/trino/result-collector.test.ts
index 5c471400..bdee9d7f 100644
--- a/src/lib/server/trino/result-collector.test.ts
+++ b/src/lib/server/trino/result-collector.test.ts
@@ -25,7 +25,7 @@ function makeQuery(client: Partial<TrinoQuery['client']>): TrinoQuery {
     columns: [],
     rows: [],
     error: null,
-    rowLimit: null,
+    rowLimitReached: false,
     sql: 'SELECT * FROM big',
     startedAt: 0,
     nextUri: 'http://trino/next-1',
@@ -56,10 +56,11 @@ describe('collectResults row limit', () => {
 
     expect(cancelViaUri).toHaveBeenCalledWith('http://trino/next-3', 'alice');
     expect(cancel).not.toHaveBeenCalled();
-    expect(query.rowLimit).toBe(MAX_CLIENT_ROWS);
+    expect(query.rowLimitReached).toBe(true);
     expect(query.error).toBeNull();
     expect(query.state).toBe('FINISHED');
-    expect(query.rows.length).toBeGreaterThanOrEqual(MAX_CLIENT_ROWS);
+    // Rows from the crossing page are kept, not truncated.
+    expect(query.rows.length).toBe(2 * page().length);
   });
 
   it('falls back to cancel(queryId) when the crossing page has no nextUri', async () => {
@@ -77,10 +78,81 @@ describe('collectResults row limit', () => {
 
     expect(cancelViaUri).not.toHaveBeenCalled();
     expect(cancel).toHaveBeenCalledWith('q1', 'alice');
-    expect(query.rowLimit).toBe(MAX_CLIENT_ROWS);
+    expect(query.rows.length).toBe(MAX_CLIENT_ROWS + 1);
+    expect(query.rowLimitReached).toBe(true);
     expect(query.error).toBeNull();
     expect(query.state).toBe('FINISHED');
   });
+
+  it('does not flag a result of exactly MAX_CLIENT_ROWS without further pages', async () => {
+    const cancelViaUri = vi.fn(async () => {});
+    const cancel = vi.fn(async () => {});
+    const poll = vi.fn(async () => ({
+      id: 'q1',
+      data: Array.from({ length: MAX_CLIENT_ROWS }, () => [1]),
+      nextUri: undefined,
+      stats: { state: 'FINISHED' }
+    }));
+
+    const query = makeQuery({ poll, cancelViaUri, cancel });
+    await collectResults(query);
+
+    expect(cancelViaUri).not.toHaveBeenCalled();
+    expect(cancel).not.toHaveBeenCalled();
+    expect(query.rowLimitReached).toBe(false);
+    expect(query.rows.length).toBe(MAX_CLIENT_ROWS);
+    expect(query.state).toBe('FINISHED');
+  });
+
+  it('does not flag exactly MAX_CLIENT_ROWS followed by an empty trailing page', async () => {
+    // Trino sends a nextUri on the page completing e.g. `LIMIT 10000`, even when FINISHED.
+    const cancelViaUri = vi.fn(async () => {});
+    const cancel = vi.fn(async () => {});
+    const poll = vi
+      .fn()
+      .mockResolvedValueOnce({
+        id: 'q1',
+        data: Array.from({ length: MAX_CLIENT_ROWS }, () => [1]),
+        nextUri: 'http://trino/next-2',
+        stats: { state: 'FINISHED' }
+      })
+      .mockResolvedValueOnce({ id: 'q1', stats: { state: 'FINISHED' } });
+
+    const query = makeQuery({ poll, cancelViaUri, cancel });
+    await collectResults(query);
+
+    expect(poll).toHaveBeenCalledTimes(2);
+    expect(cancelViaUri).not.toHaveBeenCalled();
+    expect(cancel).not.toHaveBeenCalled();
+    expect(query.rowLimitReached).toBe(false);
+    expect(query.rows.length).toBe(MAX_CLIENT_ROWS);
+    expect(query.state).toBe('FINISHED');
+  });
+
+  it('flags exactly MAX_CLIENT_ROWS once the next page delivers more rows', async () => {
+    const cancelViaUri = vi.fn(async () => {});
+    const poll = vi
+      .fn()
+      .mockResolvedValueOnce({
+        id: 'q1',
+        data: Array.from({ length: MAX_CLIENT_ROWS }, () => [1]),
+        nextUri: 'http://trino/next-2',
+        stats: { state: 'RUNNING' }
+      })
+      .mockResolvedValueOnce({
+        id: 'q1',
+        data: [[1], [1]],
+        nextUri: 'http://trino/next-3',
+        stats: { state: 'RUNNING' }
+      });
+
+    const query = makeQuery({ poll, cancelViaUri, cancel: vi.fn(async () => {}) });
+    await collectResults(query);
+
+    expect(cancelViaUri).toHaveBeenCalledWith('http://trino/next-3', 'alice');
+    expect(query.rowLimitReached).toBe(true);
+    expect(query.rows.length).toBe(MAX_CLIENT_ROWS + 2);
+  });
 });
 
 describe('collectResults failure', () => {
diff --git a/src/lib/server/trino/result-collector.ts b/src/lib/server/trino/result-collector.ts
index 82a15b1b..e319d0b0 100644
--- a/src/lib/server/trino/result-collector.ts
+++ b/src/lib/server/trino/result-collector.ts
@@ -67,9 +67,15 @@ export async function collectResults(query: TrinoQuery): Promise<void> {
       return;
     }
 
-    // Row limit check.
-    if (query.rows.length >= MAX_CLIENT_ROWS) {
-      query.rowLimit = MAX_CLIENT_ROWS;
+    // Row limit check. Only flag once Trino actually delivers a row beyond the limit: a trailing
+    // nextUri after exactly MAX_CLIENT_ROWS does not mean more rows follow (e.g. `LIMIT 10000`).
+    // Rows already received on the crossing page are kept rather than truncated.
+    if (query.rows.length > MAX_CLIENT_ROWS) {
+      query.rowLimitReached = true;
+      log.debug(
+        { trino_query_id: query.trinoQueryId, row_count: query.rows.length },
+        'row limit reached, cancelling query'
+      );
       try {
         if (result.nextUri) {
           await query.client.cancelViaUri(result.nextUri, query.trinoUser);
diff --git a/src/lib/types/query.ts b/src/lib/types/query.ts
index 0bf3aa55..c8a203ab 100644
--- a/src/lib/types/query.ts
+++ b/src/lib/types/query.ts
@@ -2,7 +2,6 @@ export const MAX_CLIENT_ROWS = 10_000;
 
 export const INITIAL_PROGRESS: QueryProgress = {
   progressPercentage: 0,
-  processedRows: 0,
   elapsedTimeMillis: 0
 };
 
@@ -24,7 +23,6 @@ export type QueryState =
 
 export interface QueryProgress {
   progressPercentage: number;
-  processedRows: number;
   elapsedTimeMillis: number;
 }
 
@@ -40,9 +38,11 @@ export interface QuerySnapshot {
   progress: QueryProgress;
   columns: Column[];
   rows: unknown[][];
+  /** Rows fetched so far. Populated even in lightweight snapshots, where `rows` is empty. */
+  rowCount: number;
   error: string | null;
-  /** Set to the row limit when the result was truncated at MAX_CLIENT_ROWS. */
-  rowLimit: number | null;
+  /** Fetching stopped and the query was cancelled because more than MAX_CLIENT_ROWS rows arrived. */
+  rowLimitReached: boolean;
   sql: string;
   startedAt: number;
 }
diff --git a/src/routes/(app)/trino/+page.svelte b/src/routes/(app)/trino/+page.svelte
index 33969467..c2debd90 100644
--- a/src/routes/(app)/trino/+page.svelte
+++ b/src/routes/(app)/trino/+page.svelte
@@ -230,6 +230,7 @@
   });
 
   const stateLabel = $derived.by(() => {
+    if (runner.state === 'FINISHED' && runner.rowLimitReached) return m.trino_state_row_limit();
     const stateMap: Record<string, () => string> = {
       SUBMITTING: m.trino_state_submitting,
       QUEUED: m.trino_state_queued,
@@ -244,6 +245,7 @@
   });
 
   const stateBadgeClass = $derived.by(() => {
+    if (runner.state === 'FINISHED' && runner.rowLimitReached) return 'badge-warning';
     switch (runner.state) {
       case 'QUEUED':
       case 'PLANNING':
@@ -263,6 +265,23 @@
     }
   });
 
+  const progressInfo = $derived.by(() => {
+    const { elapsedTimeMillis } = runner.progress;
+    if (runner.rowCount === 0 && elapsedTimeMillis === 0) return null;
+    const locale = getLocale();
+    const rows = runner.rowCount.toLocaleString(locale);
+    const elapsed =
+      elapsedTimeMillis < 1000
+        ? m.trino_elapsed_ms({ value: elapsedTimeMillis.toLocaleString(locale) })
+        : m.trino_elapsed_s({
+            value: (elapsedTimeMillis / 1000).toLocaleString(locale, {
+              minimumFractionDigits: 1,
+              maximumFractionDigits: 1
+            })
+          });
+    return m.trino_progress_info({ rows, elapsed });
+  });
+
   const charLimitReached = $derived(sql.length >= MAX_SQL_LENGTH);
 
   const execOptions = $derived({
@@ -682,7 +701,10 @@
             </span>
           {/snippet}
 
-          <div class="dropdown dropdown-end">
+          <!-- Only the chevron sits inside the focus-driven dropdown, so focusing the run
+               button doesn't open the menu. The wrapper is the positioning box so the menu
+               spans both buttons. -->
+          <div class="relative">
             <div class="join">
               <button
                 type="button"
@@ -692,8 +714,21 @@
                 onclick={handleRun}
               >
                 {#if isActive}
-                  <span class="loading loading-xs loading-spinner"></span>
-                  {m.trino_running()}
+                  <span
+                    class="
+                      grid
+                      *:[grid-area:1/1]
+                    "
+                  >
+                    <!-- Invisible sizer keeps the idle state's two-line height -->
+                    <span class="invisible" aria-hidden="true">
+                      {@render runOption(m.trino_running(), runShortcutLabel)}
+                    </span>
+                    <span class="flex items-center gap-1 self-center text-xs font-semibold">
+                      <span class="loading loading-xs loading-spinner"></span>
+                      {m.trino_running()}
+                    </span>
+                  </span>
                 {:else}
                   <span
                     class="
@@ -715,49 +750,51 @@
                   </span>
                 {/if}
               </button>
-              <button
-                type="button"
-                class="
-                  btn join-item border-l-primary-content/20 btn-primary
-                  tooltip tooltip-bottom z-150 self-stretch border-l px-2 before:z-200
-                "
-                data-tip={m.trino_run_mode_select()}
-                class:pointer-events-none={isActive}
-                aria-haspopup="true"
-                aria-label={m.trino_run_mode_select()}
-              >
-                <IconExpandMore class="size-3" aria-hidden="true" />
-              </button>
-            </div>
-            <div
-              class="
-                dropdown-content rounded-box bg-primary text-primary-content z-10 mt-1 flex
-                w-full flex-col gap-1 p-1.5 shadow-lg
-              "
-            >
-              <button
-                type="button"
-                class="
-                  rounded-field hover:bg-primary-content/20 cursor-pointer px-3 py-1.5
-                  text-left
-                  {runMode === 'cursor' ? 'bg-primary-content/15' : ''}"
-                onclick={() => selectRunMode('cursor')}
-              >
-                {@render runOption(m.trino_run_at_cursor(), 'Ctrl+↵')}
-              </button>
-              <button
-                type="button"
-                class="
-                  rounded-field hover:bg-primary-content/20 cursor-pointer px-3 py-1.5
-                  text-left
-                  {runMode === 'all' ? 'bg-primary-content/15' : ''}"
-                onclick={() => selectRunMode('all')}
-              >
-                {@render runOption(
-                  hasSelection ? m.trino_run_selected() : m.trino_run_all(),
-                  'Ctrl+Shift+↵'
-                )}
-              </button>
+              <div class="dropdown dropdown-end static -ms-px flex">
+                <button
+                  type="button"
+                  class="
+                    btn join-item border-l-primary-content/20 btn-primary
+                    tooltip tooltip-bottom z-150 h-full border-l px-2 before:z-200
+                  "
+                  data-tip={m.trino_run_mode_select()}
+                  class:pointer-events-none={isActive}
+                  aria-haspopup="true"
+                  aria-label={m.trino_run_mode_select()}
+                >
+                  <IconExpandMore class="size-3" aria-hidden="true" />
+                </button>
+                <div
+                  class="
+                    dropdown-content rounded-box bg-primary text-primary-content top-full z-10 mt-1
+                    flex w-full flex-col gap-1 p-1.5 shadow-lg
+                  "
+                >
+                  <button
+                    type="button"
+                    class="
+                      rounded-field hover:bg-primary-content/20 cursor-pointer px-3 py-1.5
+                      text-left
+                      {runMode === 'cursor' ? 'bg-primary-content/15' : ''}"
+                    onclick={() => selectRunMode('cursor')}
+                  >
+                    {@render runOption(m.trino_run_at_cursor(), 'Ctrl+↵')}
+                  </button>
+                  <button
+                    type="button"
+                    class="
+                      rounded-field hover:bg-primary-content/20 cursor-pointer px-3 py-1.5
+                      text-left
+                      {runMode === 'all' ? 'bg-primary-content/15' : ''}"
+                    onclick={() => selectRunMode('all')}
+                  >
+                    {@render runOption(
+                      hasSelection ? m.trino_run_selected() : m.trino_run_all(),
+                      'Ctrl+Shift+↵'
+                    )}
+                  </button>
+                </div>
+              </div>
             </div>
           </div>
         </div>
@@ -820,13 +857,8 @@
               max="100"
             ></progress>
           {/if}
-          {#if runner.progress.processedRows > 0 || runner.progress.elapsedTimeMillis > 0}
-            <span class="text-base-content/60 text-xs">
-              {m.trino_progress_info({
-                rows: runner.progress.processedRows.toLocaleString(getLocale()),
-                elapsed: (runner.progress.elapsedTimeMillis / 1000).toFixed(1)
-              })}
-            </span>
+          {#if progressInfo}
+            <span class="text-base-content/60 text-xs">{progressInfo}</span>
           {/if}
           {#if runner.currentTrinoQueryUrl}
             <a
diff --git a/src/routes/(app)/trino/query-runner.svelte.ts b/src/routes/(app)/trino/query-runner.svelte.ts
index b18a68b3..7c485d56 100644
--- a/src/routes/(app)/trino/query-runner.svelte.ts
+++ b/src/routes/(app)/trino/query-runner.svelte.ts
@@ -13,6 +13,8 @@ import * as m from '$lib/paraglide/messages.js';
 export interface QueryRunner {
   readonly state: QueryState;
   readonly progress: QueryProgress;
+  readonly rowCount: number;
+  readonly rowLimitReached: boolean;
   readonly results: QuerySnapshot[];
   readonly scriptProgress: ScriptProgress | null;
   readonly currentTrinoQueryUrl: string | null;
@@ -36,6 +38,8 @@ function createQueryRunner(tabId: string): QueryRunner {
   // Reactive state exposed to the UI for the live progress indicator.
   let state = $state<QueryState>('IDLE');
   let progress = $state<QueryProgress>(INITIAL_PROGRESS);
+  let rowCount = $state(0);
+  let rowLimitReached = $state(false);
 
   // All query results. Uses $state.raw to avoid proxying large row arrays.
   let results = $state.raw<QuerySnapshot[]>([]);
@@ -50,11 +54,15 @@ function createQueryRunner(tabId: string): QueryRunner {
   function applySnapshot(snapshot: QuerySnapshot) {
     state = snapshot.state;
     progress = snapshot.progress;
+    rowCount = snapshot.rowCount;
+    rowLimitReached = snapshot.rowLimitReached;
   }
 
   function reset() {
     state = 'IDLE';
     progress = INITIAL_PROGRESS;
+    rowCount = 0;
+    rowLimitReached = false;
     results = [];
     scriptProgress = null;
     currentTrinoQueryUrl = null;
@@ -270,6 +278,12 @@ function createQueryRunner(tabId: string): QueryRunner {
     get progress() {
       return progress;
     },
+    get rowCount() {
+      return rowCount;
+    },
+    get rowLimitReached() {
+      return rowLimitReached;
+    },
     get results() {
       return results;
     },