diff --git a/.claude/memory/2026-04-02-group-by-dropdown-design.md b/.claude/memory/2026-04-02-group-by-dropdown-design.md
new file mode 100644
index 000000000..03edf72f0
--- /dev/null
+++ b/.claude/memory/2026-04-02-group-by-dropdown-design.md
@@ -0,0 +1,85 @@
+# Group By Dropdown Design
+
+**Date:** 2026-04-02
+**Feature:** Replace GROUP BY checkbox grid with native multi-select dropdown
+
+## Context
+
+The aggregate panel's GROUP BY section currently renders a flat grid of checkboxes (one per column), injected by `buildGroupBySection()`. This design scales poorly for tables with many columns and lacks a clear affordance for multi-selection.
+
+## Goal
+
+Replace the checkbox grid with a native `<select multiple>` element. Selection alone is required — column ordering is not.
+
+## Design
+
+### HTML (`static/index.html`)
+
+Replace the `#agg_group_by_grid` div with a `<select multiple>` and a hint label inside the existing `.agg-section`:
+
+```html
+<div class="agg-section">
+  <div class="agg-section-header">GROUP BY</div>
+  <select id="agg_group_by_select" multiple class="form-control agg-group-by-select"></select>
+  <div class="agg-group-by-hint">Hold Ctrl / Cmd to select multiple columns</div>
+</div>
+```
+
+### JS (`static/js/app.js`)
+
+**`buildGroupBySection()`** — populate `<option>` elements instead of checkbox labels:
+
+```js
+function buildGroupBySection() {
+  var sel = $("#agg_group_by_select");
+  sel.empty();
+  $("#pagination select.column option").each(function() {
+    var val = $(this).val();
+    if (!val) return;
+    sel.append($("<option>", { value: val, text: val }));
+  });
+}
+```
+
+**`buildGroupByClause()`** — read `.val()` on the multi-select (returns array or null):
+
+```js
+function buildGroupByClause() {
+  var cols = $("#agg_group_by_select").val() || [];
+  if (cols.length === 0) return null;
+  return "GROUP BY " + cols.map(function(c) { return '"' + c + '"'; }).join(", ");
+}
+```
+
+**`buildAggregateSelectClause()`** — iterate `.val()` instead of `.agg-group-col:checked`:
+
+```js
+var cols = $("#agg_group_by_select").val() || [];
+cols.forEach(function(c) { parts.push('"' + c + '"'); });
+```
+
+**`resetAggregate()`** — deselect all: `$("#agg_group_by_select").val([]);`
+
+### CSS (`static/css/app.css`)
+
+Remove `.agg-group-by-grid` and `.agg-group-by-grid label` rules. Add:
+
+```css
+.agg-group-by-select {
+  height: 90px;
+  font-size: 12px;
+}
+.agg-group-by-hint {
+  font-size: 11px;
+  color: #aaa;
+  margin-top: 3px;
+}
+```
+
+## Scope
+
+- 4 JS functions modified: `buildGroupBySection`, `buildGroupByClause`, `buildAggregateSelectClause`, `resetAggregate`
+- 1 HTML block replaced: `#agg_group_by_grid` → `#agg_group_by_select`
+- 2 CSS rules removed, 2 added
+- No changes to `buildAggregateQuery`, HAVING logic, or aggregate expression logic
+- No new dependencies
diff --git a/.claude/memory/2026-04-02-group-by-dropdown-plan.md b/.claude/memory/2026-04-02-group-by-dropdown-plan.md
new file mode 100644
index 000000000..3e8916a8e
--- /dev/null
+++ b/.claude/memory/2026-04-02-group-by-dropdown-plan.md
@@ -0,0 +1,287 @@
+# Group By Dropdown Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace the GROUP BY checkbox grid in the aggregate panel with a native `<select multiple>` dropdown.
+
+**Architecture:** Three files change in concert — HTML swaps the container element, JS updates four functions to read from the select instead of checkboxes, CSS removes the old grid rules and adds two new rules for the select and hint. No new dependencies; no other logic is touched.
+
+**Tech Stack:** jQuery, Bootstrap 3, plain HTML/CSS. No JS test framework exists for the frontend — verification is via Go build success and manual browser inspection.
+
+---
+
+### Task 1: Replace GROUP BY HTML
+
+**Files:**
+- Modify: `static/index.html:156-158`
+
+- [ ] **Step 1: Replace the checkbox grid div with a `<select multiple>` and hint**
+
+In `static/index.html`, replace lines 156-158:
+
+```html
+            <div id="agg_group_by_grid" class="agg-group-by-grid">
+              <!-- Group-by checkboxes injected by buildGroupBySection() -->
+            </div>
+```
+
+with:
+
+```html
+            <select id="agg_group_by_select" multiple class="form-control agg-group-by-select"></select>
+            <div class="agg-group-by-hint">Hold Ctrl / Cmd to select multiple columns</div>
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/index.html
+git commit -S -m "feat: replace GROUP BY checkbox grid with multi-select element"
+```
+
+---
+
+### Task 2: Update CSS
+
+**Files:**
+- Modify: `static/css/app.css:1140-1154`
+
+- [ ] **Step 1: Remove old grid rules and add new select rules**
+
+In `static/css/app.css`, replace lines 1140-1154:
+
+```css
+.agg-group-by-grid {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px 16px;
+}
+
+.agg-group-by-grid label {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  font-size: 12px;
+  font-weight: normal;
+  margin: 0;
+  cursor: pointer;
+}
+```
+
+with:
+
+```css
+.agg-group-by-select {
+  height: 90px;
+  font-size: 12px;
+}
+
+.agg-group-by-hint {
+  font-size: 11px;
+  color: #aaa;
+  margin-top: 3px;
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/css/app.css
+git commit -S -m "feat: swap GROUP BY grid CSS for multi-select styles"
+```
+
+---
+
+### Task 3: Update `buildGroupBySection()`
+
+**Files:**
+- Modify: `static/js/app.js:1181-1192`
+
+- [ ] **Step 1: Rewrite to populate `<option>` elements**
+
+In `static/js/app.js`, replace lines 1181-1192:
+
+```js
+function buildGroupBySection() {
+  var grid = $("#agg_group_by_grid");
+  grid.empty();
+  $("#pagination select.column option").each(function() {
+    var val = $(this).val();
+    if (!val) return;
+    var label = $("<label>");
+    var cb = $("<input>", { type: "checkbox", class: "agg-group-col", value: val });
+    label.append(cb).append(" " + val);
+    grid.append(label);
+  });
+}
+```
+
+with:
+
+```js
+function buildGroupBySection() {
+  var sel = $("#agg_group_by_select");
+  sel.empty();
+  $("#pagination select.column option").each(function() {
+    var val = $(this).val();
+    if (!val) return;
+    sel.append($("<option>", { value: val, text: val }));
+  });
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: rewrite buildGroupBySection to populate select options"
+```
+
+---
+
+### Task 4: Update `buildGroupByClause()`
+
+**Files:**
+- Modify: `static/js/app.js:1321-1328`
+
+- [ ] **Step 1: Read from multi-select `.val()` instead of checked checkboxes**
+
+In `static/js/app.js`, replace lines 1321-1328:
+
+```js
+function buildGroupByClause() {
+  var cols = [];
+  $(".agg-group-col:checked").each(function() {
+    cols.push('"' + $(this).val() + '"');
+  });
+  if (cols.length === 0) return null;
+  return "GROUP BY " + cols.join(", ");
+}
+```
+
+with:
+
+```js
+function buildGroupByClause() {
+  var cols = $("#agg_group_by_select").val() || [];
+  if (cols.length === 0) return null;
+  return "GROUP BY " + cols.map(function(c) { return '"' + c + '"'; }).join(", ");
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: update buildGroupByClause to read from multi-select"
+```
+
+---
+
+### Task 5: Update `buildAggregateSelectClause()`
+
+**Files:**
+- Modify: `static/js/app.js:1298-1302`
+
+- [ ] **Step 1: Replace `.agg-group-col:checked` iteration with `.val()` array**
+
+In `static/js/app.js`, replace lines 1298-1302:
+
+```js
+function buildAggregateSelectClause() {
+  var parts = [];
+  $(".agg-group-col:checked").each(function() {
+    parts.push('"' + $(this).val() + '"');
+  });
+```
+
+with:
+
+```js
+function buildAggregateSelectClause() {
+  var parts = [];
+  var cols = $("#agg_group_by_select").val() || [];
+  cols.forEach(function(c) { parts.push('"' + c + '"'); });
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: update buildAggregateSelectClause to read from multi-select"
+```
+
+---
+
+### Task 6: Update `resetAggregate()`
+
+**Files:**
+- Modify: `static/js/app.js:1493`
+
+- [ ] **Step 1: Replace `buildGroupBySection()` call with deselect-all**
+
+In `static/js/app.js`, replace line 1493:
+
+```js
+  buildGroupBySection();
+```
+
+with:
+
+```js
+  $("#agg_group_by_select").val([]);
+```
+
+The full function after the change:
+
+```js
+function resetAggregate() {
+  aggregateActive = false;
+  $("#agg_active_badge").hide();
+  $("#agg_group_by_select").val([]);
+  $("#agg_expr_rows").empty();
+  $("#agg_having_rows").empty();
+  $("#aggregate_panel").hide();
+  $("#aggregate-toggle").removeClass("agg-open");
+  $("#pagination").removeClass("agg-panel-open");
+  adjustOutputTop();
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: update resetAggregate to deselect multi-select instead of rebuilding"
+```
+
+---
+
+### Task 7: Build and verify
+
+- [ ] **Step 1: Build the binary**
+
+```bash
+GOROOT=/opt/homebrew/Cellar/go/1.26.1/libexec GOPROXY=https://proxy.golang.org,direct GONOSUMDB='*' GOOS=linux GOARCH=amd64 go build -o ./bin/pgweb_linux_amd64
+```
+
+Expected: exits 0, no output.
+
+- [ ] **Step 2: Run Go tests**
+
+```bash
+GOROOT=/opt/homebrew/Cellar/go/1.26.1/libexec go test ./... 2>&1 | grep -v "^?"
+```
+
+Expected: all packages pass except `pkg/client` (requires a live PostgreSQL connection — pre-existing infrastructure failure, not related to this change).
+
+- [ ] **Step 3: Manual smoke check**
+
+Start the server locally and open a table:
+1. Click **Aggregate** button — GROUP BY section shows a `<select>` populated with column names
+2. Select one column (single-click) → click **Apply** → results group correctly
+3. Select multiple columns (Ctrl+click) → click **Apply** → GROUP BY clause includes all selected columns
+4. Click **Show Query** → SQL reflects selected columns in GROUP BY
+5. Click **Clear** → select has no selection, aggregate mode deactivates
+
+- [ ] **Step 4: Invoke `superpowers:finishing-a-development-branch`**
diff --git a/.claude/memory/2026-04-02-having-row-remove-design.md b/.claude/memory/2026-04-02-having-row-remove-design.md
new file mode 100644
index 000000000..3f88289a5
--- /dev/null
+++ b/.claude/memory/2026-04-02-having-row-remove-design.md
@@ -0,0 +1,53 @@
+---
+name: HAVING Row Remove Button Design
+description: Design for adding a remove button to all HAVING rows in the aggregate panel, including the first row
+type: project
+---
+
+# HAVING Row Remove Button Design
+
+**Date:** 2026-04-02
+**Feature:** Allow removal of any HAVING row, including the first one
+
+## Problem
+
+`buildHavingRow(isFirst)` only appends the remove button when `!isFirst` (line 1278). The first HAVING row added via `+Add` never receives a remove button, making it impossible to remove without using the "Clear" button (which resets the entire aggregate panel).
+
+## Design
+
+### Change 1: `buildHavingRow()` — `static/js/app.js:1278-1280`
+
+Remove the `if (!isFirst)` guard so every row gets a remove button:
+
+```js
+// Remove this guard:
+// if (!isFirst) {
+row.append('<button type="button" class="btn btn-default btn-xs adv-remove-row"><i class="fa fa-minus"></i></button>');
+// }
+```
+
+### Change 2: `.adv-remove-row` handler — `static/js/app.js:2307-2309`
+
+After removing the row, if it was the first child, promote the new first row to show the "WHERE" label instead of AND/OR conjunction buttons:
+
+```js
+$("#agg_having_rows").on("click", ".adv-remove-row", function() {
+  var row = $(this).closest(".adv-search-row");
+  var wasFirst = row.is(":first-child");
+  row.remove();
+  if (wasFirst) {
+    var newFirst = $("#agg_having_rows .adv-search-row").first();
+    if (newFirst.length) {
+      newFirst.find(".adv-row-conj").replaceWith(
+        '<div class="adv-row-conj adv-row-conj-first"><span>WHERE</span></div>'
+      );
+    }
+  }
+});
+```
+
+## Scope
+
+- 2 changes, 1 file: `static/js/app.js`
+- No HTML, CSS, or other changes needed
+- Consistent with `buildAggregateRow()` which always includes a remove button
diff --git a/.claude/memory/2026-04-02-having-row-remove-plan.md b/.claude/memory/2026-04-02-having-row-remove-plan.md
new file mode 100644
index 000000000..2b52ad2c2
--- /dev/null
+++ b/.claude/memory/2026-04-02-having-row-remove-plan.md
@@ -0,0 +1,121 @@
+# HAVING Row Remove Button Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a remove (−) button to every HAVING row in the aggregate panel, including the first row, and correctly promote the new first row's display when the original first row is deleted.
+
+**Architecture:** Two surgical edits to `static/js/app.js` — remove the `isFirst` guard in `buildHavingRow()` so all rows get a remove button, and extend the existing `.adv-remove-row` click handler for `#agg_having_rows` to repair the first-row conjunction display after deletion. No HTML or CSS changes needed.
+
+**Tech Stack:** jQuery, Bootstrap 3, plain JS. No frontend test framework — verification is via Go build success and manual browser inspection.
+
+---
+
+### Task 1: Add remove button to all HAVING rows
+
+**Files:**
+- Modify: `static/js/app.js:1278-1280`
+
+- [ ] **Step 1: Apply the change**
+
+In `static/js/app.js`, find `buildHavingRow`. The end of the function currently reads:
+
+```js
+  row.append(exprSelect).append(opSelect).append(valInput);
+
+  if (!isFirst) {
+    row.append('<button type="button" class="btn btn-default btn-xs adv-remove-row"><i class="fa fa-minus"></i></button>');
+  }
+
+  return row;
+```
+
+Replace with:
+
+```js
+  row.append(exprSelect).append(opSelect).append(valInput);
+
+  row.append('<button type="button" class="btn btn-default btn-xs adv-remove-row"><i class="fa fa-minus"></i></button>');
+
+  return row;
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: add remove button to first HAVING row"
+```
+
+---
+
+### Task 2: Fix first-row display after first-row deletion
+
+**Files:**
+- Modify: `static/js/app.js:2307-2309`
+
+- [ ] **Step 1: Apply the change**
+
+In `static/js/app.js`, find the `#agg_having_rows` remove handler. It currently reads:
+
+```js
+  $("#agg_having_rows").on("click", ".adv-remove-row", function() {
+    $(this).closest(".adv-search-row").remove();
+  });
+```
+
+Replace with:
+
+```js
+  $("#agg_having_rows").on("click", ".adv-remove-row", function() {
+    var row = $(this).closest(".adv-search-row");
+    var wasFirst = row.is(":first-child");
+    row.remove();
+    if (wasFirst) {
+      var newFirst = $("#agg_having_rows .adv-search-row").first();
+      if (newFirst.length) {
+        newFirst.find(".adv-row-conj").replaceWith(
+          '<div class="adv-row-conj adv-row-conj-first"><span>WHERE</span></div>'
+        );
+      }
+    }
+  });
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "fix: promote new first HAVING row after first-row deletion"
+```
+
+---
+
+### Task 3: Build and verify
+
+- [ ] **Step 1: Build**
+
+```bash
+GOROOT=/opt/homebrew/Cellar/go/1.26.1/libexec GOPROXY=https://proxy.golang.org,direct GONOSUMDB='*' GOOS=linux GOARCH=amd64 go build -o ./bin/pgweb_linux_amd64
+```
+
+Expected: exits 0, no output.
+
+- [ ] **Step 2: Run Go tests**
+
+```bash
+GOROOT=/opt/homebrew/Cellar/go/1.26.1/libexec go test ./... 2>&1 | grep -v "^?"
+```
+
+Expected: all packages pass except `pkg/client` (requires live PostgreSQL — pre-existing).
+
+- [ ] **Step 3: Manual smoke check**
+
+1. Open Aggregate panel on any table
+2. Click **HAVING +Add** → first row appears with a `−` button
+3. Click `−` on the first row → row is removed, panel is empty again
+4. Click **HAVING +Add** twice → two rows appear, both with `−` buttons
+5. Click `−` on the first row → second row becomes first; its label changes to "WHERE" (no AND/OR buttons)
+6. Click `−` on that row → panel is empty
+7. Add two rows, remove the second (non-first) row → first row unchanged, second removed
+
+- [ ] **Step 4: Invoke `superpowers:finishing-a-development-branch`**
diff --git a/.claude/memory/MEMORY.md b/.claude/memory/MEMORY.md
new file mode 100644
index 000000000..2a3de0566
--- /dev/null
+++ b/.claude/memory/MEMORY.md
@@ -0,0 +1,19 @@
+# Memory Index
+
+- [Aggregate Panel Implementation State](project_aggregate_panel.md) — feature/aggregate-panel branch: 10 commits done, 5 final fixes applied but uncommitted; next step is build+commit then finishing-a-development-branch
+- Always use following build command:
+
+```bash
+GOROOT=/opt/homebrew/Cellar/go/1.26.2/libexec \
+GOPROXY=https://proxy.golang.org,direct \
+GONOSUMDB='*' \
+GOOS=linux GOARCH=amd64 \
+go build -o ./bin/pgweb_linux_amd64
+```
+
+>Output: `bin/pgweb_linux_amd64` (~28MB, ELF 64-bit, statically linked)
+
+- local branch stays local and not to be pushed to remote. Directive is set via .git/hooks/pre-push
+
+- [Query Tab Button Bug](bug_query_tab_buttons.md) — Run Query button blocked by #output overlay after switching from Rows tab; fixed in showQueryPanel()
+
diff --git a/.claude/memory/advanced_search.md b/.claude/memory/advanced_search.md
new file mode 100644
index 000000000..10bcdeabd
--- /dev/null
+++ b/.claude/memory/advanced_search.md
@@ -0,0 +1,83 @@
+# Advanced Search Feature
+
+## Status: Implemented and working (v5)
+
+## What was built
+Multi-condition advanced search panel for the Rows tab. Accessible via an "Advanced" toggle button next to the existing Apply/× buttons.
+
+### Features (v1)
+- Multiple filter conditions (unlimited rows)
+- "Advanced Filter Active" badge in pagination row when active
+- Right-click "Filter Rows By Value" appends a pre-filled row when panel is open
+- Resets on table switch and basic × reset button
+- `#output` top offset recalculated when panel opens/closes
+
+### Features added in v2
+- **Per-row AND/OR connector pills** — each row after the first has AND/OR buttons; first row shows "WHERE" label; enables `(A) AND (B) OR (C)` style expressions
+- **Show Query button** — toggles a `<pre>` box showing the full `SELECT * FROM "schema"."table" WHERE ...;` with a Copy button (reuses `copyToClipboard()`)
+- **Expanded operator set** (18 operators, grouped with `<optgroup>`):
+  - Comparison: `=`, `<>`, `<`, `>`, `<=`, `>=`
+  - List: `IN` (comma-sep → `IN ('a','b')`), `NOT IN`
+  - Null: `IS NULL`, `IS NOT NULL`
+  - Range: `BETWEEN` (From/To inputs), `NOT BETWEEN`
+  - Pattern: Contains, Not contains, Has prefix, Has suffix + case-insensitive variants (ILIKE)
+  - Regex: Matches regex (`~`), Matches regex case insensitive (`~*`)
+- **`getOpInputType(op)`** helper: returns `"none" | "single" | "list" | "range"` — controls which input variant is shown
+- **`buildFullQuery()`** — builds full SELECT string using `getCurrentObject().name`
+
+## Files changed
+- `static/index.html` — Advanced button, `#advanced_search_panel`, `#adv_search_active_badge`, Show Query button, `#adv_query_display`
+- `static/css/app.css` — appended styles for panel, connector pills, range inputs, query display box
+- `static/js/app.js` — see key functions below
+
+## Key JS functions (app.js)
+- `var advancedSearchActive = false` — global flag
+- `escapeSqlLiteral(val)` — doubles single-quotes (also applied to simple filter)
+- `getOpInputType(op)` — returns input variant type for an operator
+- `buildAdvancedSearchRow(isFirst)` — builds a condition row; `isFirst=true` → WHERE label, no pill
+- `buildAdvancedWhereClause()` — iterates rows, reads `data-row-conj` per row, builds SQL
+- `buildFullQuery()` — wraps WHERE clause in full SELECT statement
+- `applyAdvancedSearch()` — stores WHERE in panel `.data("where")`, sets flag, reloads
+- `resetAdvancedSearch()` — clears flag/badge, empties rows, adds `buildAdvancedSearchRow(true)`
+- `adjustOutputTop()` — sets `#output` CSS top to `#pagination` outerHeight
+- `updateAdvRowInputs(row, op)` — switches visible input variant for a row; uses `.css("display","flex")` for range span (not `.toggle()` which would give `block`)
+- `bindAdvancedOpHandlers()` — delegated `change` handler on `.adv-op`; calls `updateAdvRowInputs()`
+
+## Bug fix (v5): LIST, RANGE, NULL operators not working
+- **Root cause 1**: `.adv-val-range` shown via `.toggle(true)` renders as `display:block`, breaking the flex From/To layout — fixed by using `.css("display","flex")` in new `updateAdvRowInputs()` helper
+- **Root cause 2**: `buildAdvancedWhereClause()` read from `.adv-val-list` / `.adv-val-from/to` but if user typed in the always-visible `.adv-val` fallback was missing — added fallback: LIST reads `.adv-val` if `.adv-val-list` is empty; RANGE parses `"val1, val2"` or `"val1 and val2"` from `.adv-val` if From/To are empty
+- Extracted `updateAdvRowInputs(row, op)` from inline `change` handler for reuse
+
+## Bug fix (v4b): first row showed unnecessary − delete button
+- `buildAdvancedSearchRow(isFirst)` now only appends the remove button when `isFirst=false`
+
+## Added in v4: regex operators
+- `"regex": "~ 'DATA'"` and `"iregex": "~* 'DATA'"` added to `filterOptions`
+- Two new options appended to the Pattern `<optgroup>` in `buildAdvancedSearchRow()`
+- No other changes needed — `getOpInputType()` returns `"single"` by default, `buildAdvancedWhereClause()` handles it unchanged
+
+## Bug fix (v3): advanced panel obscuring table rows
+- **Root cause**: `.with-pagination #output { top: 50px !important }` in `app.css` — the `!important` beat jQuery's inline style set by `adjustOutputTop()`
+- **Fix 1**: removed `!important` from that CSS rule so JS inline style wins
+- **Fix 2**: added `adjustOutputTop()` call immediately after `$("#body").prop("class", "with-pagination")` in `showTableContent()` — so offset is recalculated on every table load, not just on panel open/close
+
+## Key JS edits (app.js)
+- `showTableContent()` — advanced takes precedence over simple filter when `advancedSearchActive`; calls `adjustOutputTop()` after setting `with-pagination` class
+- `buildTableFilters()` — syncs columns into existing advanced rows; passes `isFirst=true`
+- Objects click handler — calls `resetAdvancedSearch()` on table switch
+- `reset-filters` button — calls `resetAdvancedSearch()`
+- `filter_by_value` context menu — appends pre-filled row when panel visible
+
+## No backend changes needed
+The existing `where` param on `GET /api/tables/:table/rows` accepts raw SQL.
+`TableRows()` in `pkg/client/client.go` appends `WHERE <opts.Where>` directly.
+
+## Build command (GOROOT is broken in this environment)
+```bash
+GOROOT=/opt/homebrew/Cellar/go/1.25.7_1/libexec \
+GOPROXY=https://proxy.golang.org,direct \
+GONOSUMDB='*' \
+GOOS=linux GOARCH=amd64 \
+go build -o ./bin/pgweb_linux_amd64
+```
+Output: `bin/pgweb_linux_amd64` (~28MB, ELF 64-bit, statically linked)
diff --git a/.claude/memory/bug_query_tab_buttons.md b/.claude/memory/bug_query_tab_buttons.md
new file mode 100644
index 000000000..2a12a2e6c
--- /dev/null
+++ b/.claude/memory/bug_query_tab_buttons.md
@@ -0,0 +1,22 @@
+---
+name: bug-query-tab-buttons
+description: Run Query / Explain Query buttons unclickable after switching from Rows tab — root cause and fix
+metadata:
+  type: project
+---
+
+## Bug: Query tab buttons blocked after using Rows tab
+
+**Symptom:** After using the Rows tab (especially with Advanced or Aggregate filters), switching to the Query tab leaves the Run Query and Explain Query buttons unclickable — cursor stays as arrow, clicks don't register. Refreshing the page restores them.
+
+**Root cause:** `adjustOutputTop()` (called by `showTableContent`) sets `#output` top CSS to the pagination panel height (e.g. 150px) so results clear the filter UI on the Rows tab. When switching to the Query tab, `showQueryPanel()` shows `#input` but never resets `#output` top. With `#output` positioned too high (position: absolute within #body), it overlaps and invisibly intercepts all mouse events on the `.actions` buttons inside `#input`.
+
+**Fix:** One line added to `showQueryPanel()` in `static/js/app.js`:
+```javascript
+$("#output").css("top", $("#input").height() + "px");
+```
+This resets `#output` top to align with the bottom of `#input` when entering the Query tab.
+
+**Why:** `adjustOutputTop()` is only called for Rows tab layout; no corresponding reset existed for Query tab. The `#output` div (overflow:auto, position:absolute) silently covered the button bar.
+
+**How to apply:** When debugging future UI event issues (cursor, click failures) on the Query tab after Rows tab use — check `#output` top CSS first.
diff --git a/.claude/memory/project_aggregate_panel.md b/.claude/memory/project_aggregate_panel.md
new file mode 100644
index 000000000..51bd1fd02
--- /dev/null
+++ b/.claude/memory/project_aggregate_panel.md
@@ -0,0 +1,31 @@
+---
+name: Aggregate Panel Implementation State
+description: Current implementation state of the GROUP BY / aggregate query builder feature for pgweb — branch, commits, what is done, and status
+type: project
+---
+
+Feature is complete and merged into `main`.
+
+**Branch:** merged and deleted
+**Base branch:** `main` (local), also tracked as `origin/local`
+
+## All committed work (on main)
+
+```
+5c8f30a  fix: repair Show Query toggle, move query display outside panels, add adjustOutputTop to resetAggregate
+ddab2df  fix: address final review issues — HAVING escaping, sort/edit guards, panel cleanup
+dc31cae  fix: update stale buildFullQuery comment to reflect aggregate delegation
+71aeb8e  feat: wire aggregate mode into showTableContent, buildFullQuery, table-switch, reset-filters
+e507a6b  feat: add applyAggregate, resetAggregate, and button event handlers
+5b129e8  feat: add aggregate query composition functions
+f2d06d5  feat: add HAVING helpers and event handlers
+261af06  feat: add buildAggregateRow and aggregate expression event handlers
+75fc8f2  feat: add aggregateActive flag, buildGroupBySection, toggle handler
+a59a5f7  feat: add aggregate panel CSS styles
+98c489f  feat: add aggregate panel HTML skeleton
+ee7516b  chore: add .worktrees/ to .gitignore
+```
+
+## Status: DONE
+
+All 5 final review fixes verified in ddab2df. Merged to main 2026-04-02.
diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index 73572edfe..7bf165bca 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -6,7 +6,8 @@
       "Bash(git checkout:*)",
       "Bash(go test:*)",
       "Bash(go build:*)",
-      "Bash(make:*)"
+      "Bash(make:*)",
+      "Bash(go env:*)"
     ]
   }
 }
diff --git a/.gitignore b/.gitignore
index c3d720a9f..a9f11a2d6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,6 @@ pgweb
 bin
 tmp/
 cover.out
+docs/**
+.worktrees/
+
diff --git a/docs/superpowers/plans/2026-04-02-order-by-limit.md b/docs/superpowers/plans/2026-04-02-order-by-limit.md
new file mode 100644
index 000000000..55493d267
--- /dev/null
+++ b/docs/superpowers/plans/2026-04-02-order-by-limit.md
@@ -0,0 +1,704 @@
+# ORDER BY + LIMIT Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add multi-column ORDER BY sections and explicit LIMIT inputs to both the Advanced search panel and Aggregate panel, switching Advanced to client-side SQL generation for consistency.
+
+**Architecture:** Both panels build their full SQL queries client-side. A shared `buildOrderByClause(containerSelector)` helper reads ORDER BY rows from the DOM. `buildAdvancedQuery()` mirrors `buildAggregateQuery()` and replaces the `getTableRows()` path in `showTableContent()` when `advancedSearchActive` is true.
+
+**Tech Stack:** jQuery, Bootstrap 3, vanilla JS, no backend changes.
+
+---
+
+## File Map
+
+| File | Changes |
+|---|---|
+| `static/index.html` | Add `#adv_order_rows` section + `#adv-limit-input` to Advanced panel; add `#agg_order_rows` section + `#agg-limit-input` to Aggregate panel |
+| `static/js/app.js` | Add `buildOrderByRow()`, `buildOrderByClause()`, `updateAdvOrderByColumns()`, `updateAggOrderByColumns()`, `buildAdvancedQuery()`; update `buildAggregateQuery()`, `showTableContent()`, `buildFullQuery()`, `resetAdvancedSearch()`, `resetAggregate()`, `applyAdvancedSearch()`; add event handlers |
+| `static/css/app.css` | Add `.order-by-row`, `.order-by-col`, `.order-by-dir`, `.panel-limit-wrap` styles |
+
+---
+
+## Task 1: Add ORDER BY HTML sections to both panels
+
+**Files:**
+- Modify: `static/index.html`
+
+- [ ] **Step 1: Add ORDER BY section + LIMIT to Advanced panel**
+
+In `static/index.html`, replace the Advanced panel footer:
+
+```html
+<!-- BEFORE -->
+        <div class="adv-search-footer">
+            <button type="button" class="btn btn-default btn-xs" id="adv-add-condition"><i class="fa fa-plus"></i> Add Condition</button>
+            <button type="button" class="btn btn-primary btn-sm" id="adv-apply">Apply</button>
+            <button type="button" class="btn btn-default btn-sm" id="adv-reset"><i class="fa fa-times"></i> Clear</button>
+            <button type="button" class="btn btn-default btn-sm" id="adv-show-query"><i class="fa fa-code"></i> Show Query</button>
+          </div>
+```
+
+```html
+<!-- AFTER -->
+        <div class="agg-section" id="adv-order-section">
+            <div class="agg-section-header">
+              ORDER BY
+              <button type="button" class="btn btn-default btn-xs" id="adv-add-order"><i class="fa fa-plus"></i> Add</button>
+            </div>
+            <div id="adv_order_rows"></div>
+          </div>
+          <div class="adv-search-footer">
+            <button type="button" class="btn btn-default btn-xs" id="adv-add-condition"><i class="fa fa-plus"></i> Add Condition</button>
+            <button type="button" class="btn btn-primary btn-sm" id="adv-apply">Apply</button>
+            <button type="button" class="btn btn-default btn-sm" id="adv-reset"><i class="fa fa-times"></i> Clear</button>
+            <button type="button" class="btn btn-default btn-sm" id="adv-show-query"><i class="fa fa-code"></i> Show Query</button>
+            <span class="panel-limit-wrap">LIMIT <input type="text" id="adv-limit-input" class="form-control panel-limit-input" placeholder="default" /></span>
+          </div>
+```
+
+- [ ] **Step 2: Add ORDER BY section + LIMIT to Aggregate panel**
+
+In `static/index.html`, replace the Aggregate panel footer:
+
+```html
+<!-- BEFORE -->
+          <div class="adv-search-footer">
+            <button type="button" class="btn btn-primary btn-sm" id="agg-apply">Apply</button>
+            <button type="button" class="btn btn-default btn-sm" id="agg-reset"><i class="fa fa-times"></i> Clear</button>
+            <button type="button" class="btn btn-default btn-sm" id="agg-show-query"><i class="fa fa-code"></i> Show Query</button>
+          </div>
+```
+
+```html
+<!-- AFTER -->
+          <div class="agg-section" id="agg-order-section">
+            <div class="agg-section-header">
+              ORDER BY
+              <button type="button" class="btn btn-default btn-xs" id="agg-add-order"><i class="fa fa-plus"></i> Add</button>
+            </div>
+            <div id="agg_order_rows"></div>
+          </div>
+          <div class="adv-search-footer">
+            <button type="button" class="btn btn-primary btn-sm" id="agg-apply">Apply</button>
+            <button type="button" class="btn btn-default btn-sm" id="agg-reset"><i class="fa fa-times"></i> Clear</button>
+            <button type="button" class="btn btn-default btn-sm" id="agg-show-query"><i class="fa fa-code"></i> Show Query</button>
+            <span class="panel-limit-wrap">LIMIT <input type="text" id="agg-limit-input" class="form-control panel-limit-input" placeholder="default" /></span>
+          </div>
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add static/index.html
+git commit -S -m "feat: add ORDER BY sections and LIMIT inputs to Advanced and Aggregate panels (HTML)"
+```
+
+---
+
+## Task 2: Add CSS for ORDER BY rows and LIMIT inputs
+
+**Files:**
+- Modify: `static/css/app.css`
+
+- [ ] **Step 1: Add styles**
+
+Append after the `.agg-col-hidden` rule in `static/css/app.css`:
+
+```css
+.order-by-row {
+  display: flex;
+  align-items: center;
+  margin-bottom: 4px;
+  gap: 6px;
+}
+
+.order-by-row .order-by-col {
+  flex: 1 1 auto;
+  min-width: 0;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.order-by-row .order-by-dir {
+  width: 70px;
+  flex-shrink: 0;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.panel-limit-wrap {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  font-size: 12px;
+  color: #555;
+  margin-left: 6px;
+}
+
+.panel-limit-input {
+  width: 70px;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+  display: inline-block;
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/css/app.css
+git commit -S -m "feat: add CSS for ORDER BY rows and LIMIT inputs"
+```
+
+---
+
+## Task 3: Add ORDER BY JS helpers
+
+**Files:**
+- Modify: `static/js/app.js` (after `updateHavingAliasDropdowns`, around line 1330)
+
+- [ ] **Step 1: Add `buildOrderByRow`, `buildOrderByClause`, `updateAdvOrderByColumns`, `updateAggOrderByColumns`**
+
+Insert after the closing `}` of `updateHavingAliasDropdowns()`:
+
+```javascript
+// Build a single ORDER BY row element. colHtml is the innerHTML for the column <select>.
+function buildOrderByRow(colHtml) {
+  var colSelect = $('<select class="order-by-col form-control"></select>').html(
+    colHtml || '<option value="">Select column</option>'
+  );
+  var dirSelect = $('<select class="order-by-dir form-control"></select>').append(
+    $('<option value="ASC">ASC</option>'),
+    $('<option value="DESC">DESC</option>')
+  );
+  var removeBtn = $('<button type="button" class="btn btn-default btn-xs order-by-remove"><i class="fa fa-minus"></i></button>');
+  return $('<div class="order-by-row"></div>').append(colSelect, dirSelect, removeBtn);
+}
+
+// Returns "ORDER BY \"col1\" ASC, \"col2\" DESC" or null if no valid rows.
+// containerSelector: CSS selector for the element containing .order-by-row elements.
+function buildOrderByClause(containerSelector) {
+  var parts = [];
+  $(containerSelector + " .order-by-row").each(function() {
+    var col = $(this).find(".order-by-col").val() || "";
+    var dir = $(this).find(".order-by-dir").val() || "ASC";
+    if (!col) return;
+    parts.push('"' + col + '" ' + dir);
+  });
+  if (parts.length === 0) return null;
+  return "ORDER BY " + parts.join(", ");
+}
+
+// Sync column options into existing Advanced ORDER BY rows when the table column list changes.
+function updateAdvOrderByColumns() {
+  var colHtml = $("#pagination select.column").html() || '<option value="">Select column</option>';
+  $("#adv_order_rows .order-by-row .order-by-col").each(function() {
+    var prev = $(this).val();
+    $(this).html(colHtml);
+    $(this).val(prev);
+  });
+}
+
+// Rebuild Aggregate ORDER BY column dropdowns: GROUP BY selected cols + aggregate aliases.
+function updateAggOrderByColumns() {
+  var options = [];
+  var gbCols = $("#agg_group_by_select").val() || [];
+  gbCols.forEach(function(c) { options.push(c); });
+  getAggregateAliases().forEach(function(a) { options.push(a); });
+
+  $("#agg_order_rows .order-by-row").each(function() {
+    var sel  = $(this).find(".order-by-col");
+    var prev = sel.val();
+    sel.empty();
+    if (options.length === 0) {
+      sel.append('<option value=""></option>');
+    } else {
+      options.forEach(function(o) {
+        sel.append($('<option></option>').val(o).text(o));
+      });
+    }
+    if (prev && options.indexOf(prev) !== -1) sel.val(prev);
+  });
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: add buildOrderByRow, buildOrderByClause, updateAdvOrderByColumns, updateAggOrderByColumns"
+```
+
+---
+
+## Task 4: Update `buildAggregateQuery` to include ORDER BY and panel LIMIT
+
+**Files:**
+- Modify: `static/js/app.js` (`buildAggregateQuery`, around line 1410)
+
+- [ ] **Step 1: Replace `buildAggregateQuery`**
+
+Replace the current function body:
+
+```javascript
+// BEFORE (lines ~1410-1441):
+function buildAggregateQuery() {
+  var obj   = getCurrentObject();
+  var parts = obj.name.split(".");
+  var tableRef;
+  if (parts.length === 2) {
+    tableRef = '"' + parts[0] + '"."' + parts[1] + '"';
+  } else {
+    tableRef = '"' + parts[0] + '"';
+  }
+
+  var selectClause = buildAggregateSelectClause();
+  var groupBy      = buildGroupByClause();
+  if (!groupBy) return null;
+
+  var sql = "SELECT " + selectClause + " FROM " + tableRef;
+
+  if (advancedSearchActive) {
+    var where = $("#advanced_search_panel").data("where");
+    if (where) sql += " WHERE " + where;
+  }
+
+  sql += " " + groupBy;
+
+  var having = buildHavingClause();
+  if (having) sql += " " + having;
+
+  sql += " LIMIT " + getRowsLimit();
+  var offset = getPaginationOffset();
+  if (offset > 0) sql += " OFFSET " + offset;
+
+  return sql;
+}
+```
+
+```javascript
+// AFTER:
+function buildAggregateQuery() {
+  var obj   = getCurrentObject();
+  var parts = obj.name.split(".");
+  var tableRef;
+  if (parts.length === 2) {
+    tableRef = '"' + parts[0] + '"."' + parts[1] + '"';
+  } else {
+    tableRef = '"' + parts[0] + '"';
+  }
+
+  var selectClause = buildAggregateSelectClause();
+  var groupBy      = buildGroupByClause();
+  if (!groupBy) return null;
+
+  var sql = "SELECT " + selectClause + " FROM " + tableRef;
+
+  if (advancedSearchActive) {
+    var where = $("#advanced_search_panel").data("where");
+    if (where) sql += " WHERE " + where;
+  }
+
+  sql += " " + groupBy;
+
+  var having = buildHavingClause();
+  if (having) sql += " " + having;
+
+  var orderBy = buildOrderByClause("#agg_order_rows");
+  if (orderBy) sql += " " + orderBy;
+
+  var limitVal = parseInt($("#agg-limit-input").val(), 10);
+  sql += " LIMIT " + (limitVal > 0 ? limitVal : getRowsLimit());
+
+  var offset = getPaginationOffset();
+  if (offset > 0) sql += " OFFSET " + offset;
+
+  return sql;
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: inject ORDER BY and panel LIMIT into buildAggregateQuery"
+```
+
+---
+
+## Task 5: Add `buildAdvancedQuery` and switch `showTableContent` to use it
+
+**Files:**
+- Modify: `static/js/app.js`
+
+- [ ] **Step 1: Add `buildAdvancedQuery` after `applyAdvancedSearch`**
+
+Insert after the closing `}` of `applyAdvancedSearch()` (around line 1496):
+
+```javascript
+// Build the full SELECT query for Advanced search mode using stored WHERE state
+// and current ORDER BY rows + LIMIT input from the panel DOM.
+function buildAdvancedQuery() {
+  var obj   = getCurrentObject();
+  var parts = obj.name.split(".");
+  var tableRef = parts.length === 2
+    ? '"' + parts[0] + '"."' + parts[1] + '"'
+    : '"' + parts[0] + '"';
+
+  var sql = "SELECT * FROM " + tableRef;
+
+  var where = $("#advanced_search_panel").data("where");
+  if (where) sql += " WHERE " + where;
+
+  var orderBy = buildOrderByClause("#adv_order_rows");
+  if (orderBy) sql += " " + orderBy;
+
+  var limitVal = parseInt($("#adv-limit-input").val(), 10);
+  sql += " LIMIT " + (limitVal > 0 ? limitVal : getRowsLimit());
+
+  var offset = getPaginationOffset();
+  if (offset > 0) sql += " OFFSET " + offset;
+
+  return sql;
+}
+```
+
+- [ ] **Step 2: Replace the `advancedSearchActive` branch in `showTableContent`**
+
+In `showTableContent`, replace:
+
+```javascript
+  // Advanced search takes precedence over the simple filter
+  if (advancedSearchActive) {
+    var advWhere = $("#advanced_search_panel").data("where");
+    if (advWhere) opts["where"] = advWhere;
+  } else {
+```
+
+```javascript
+  if (advancedSearchActive) {
+    var advQuery = buildAdvancedQuery();
+    executeQuery(advQuery, function(data) {
+      $("#input").hide();
+      $("#body").prop("class", "with-pagination");
+      adjustOutputTop();
+      buildTable(data);
+      setCurrentTab("table_content");
+      updatePaginator(data.pagination);
+      $("#results").data("mode", "browse").data("table", name);
+    });
+    return;
+  }
+
+  // Simple filter (no advanced search active)
+  {
+```
+
+Also change the closing `}` of the else-block (which was `}`) to `}` — the wrapping braces now close the new block. Specifically: the old code had:
+
+```javascript
+  } else {
+    var filter = { ... };
+    if (filter.column && filter.op) {
+      opts["where"] = where;
+    }
+  }
+
+  getTableRows(name, opts, ...);
+```
+
+After the change, the `else` becomes a bare block and `getTableRows` is still called for the non-advanced path:
+
+```javascript
+  } else {
+    var filter = {
+      column: $(".filters select.column").val(),
+      op:     $(".filters select.filter").val(),
+      input:  $(".filters input").val()
+    };
+
+    if (filter.column && filter.op) {
+      var where = [
+        '"' + filter.column + '"',
+        filterOptions[filter.op].replace("DATA", escapeSqlLiteral(filter.input))
+      ].join(" ");
+
+      opts["where"] = where;
+    }
+  }
+
+  getTableRows(name, opts, function(data) { ... });
+```
+
+This block is unchanged — only the `advancedSearchActive` branch is replaced with the early return.
+
+- [ ] **Step 3: Update `buildFullQuery` to include ORDER BY + LIMIT for the Advanced preview**
+
+Replace `buildFullQuery`:
+
+```javascript
+// BEFORE:
+function buildFullQuery() {
+  if (aggregateActive) {
+    var aggQ = buildAggregateQuery();
+    return aggQ ? aggQ + ";" : null;
+  }
+  var where = buildAdvancedWhereClause();
+  if (!where) return null;
+  var table = getCurrentObject().name;
+  var nameParts = table.split(".");
+  var sql;
+  if (nameParts.length === 2) {
+    sql = 'SELECT * FROM "' + nameParts[0] + '"."' + nameParts[1] + '"';
+  } else {
+    sql = 'SELECT * FROM "' + table + '"';
+  }
+  return sql + " WHERE " + where + ";";
+}
+```
+
+```javascript
+// AFTER:
+function buildFullQuery() {
+  if (aggregateActive) {
+    var aggQ = buildAggregateQuery();
+    return aggQ ? aggQ + ";" : null;
+  }
+  // Advanced: build from DOM (WHERE from current row state, not stored state,
+  // so the preview reflects unsaved edits too).
+  var where = buildAdvancedWhereClause();
+  if (!where) return null;
+  var table = getCurrentObject().name;
+  var nameParts = table.split(".");
+  var tableRef = nameParts.length === 2
+    ? '"' + nameParts[0] + '"."' + nameParts[1] + '"'
+    : '"' + table + '"';
+  var sql = "SELECT * FROM " + tableRef + " WHERE " + where;
+  var orderBy = buildOrderByClause("#adv_order_rows");
+  if (orderBy) sql += " " + orderBy;
+  var limitVal = parseInt($("#adv-limit-input").val(), 10);
+  sql += " LIMIT " + (limitVal > 0 ? limitVal : getRowsLimit());
+  return sql + ";";
+}
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: add buildAdvancedQuery and switch showTableContent to client-side SQL for advanced mode"
+```
+
+---
+
+## Task 6: Update reset functions and add event handlers
+
+**Files:**
+- Modify: `static/js/app.js`
+
+- [ ] **Step 1: Update `resetAdvancedSearch` to clear ORDER BY rows and LIMIT**
+
+Replace:
+
+```javascript
+function resetAdvancedSearch() {
+  advancedSearchActive = false;
+  $("#advanced_search_panel").data("where", null);
+  $("#adv_search_active_badge").hide();
+  $("#advanced-search-toggle").removeClass("adv-open");
+
+  $("#adv_search_rows").empty();
+  $("#adv_search_rows").append(buildAdvancedSearchRow(true));
+}
+```
+
+```javascript
+function resetAdvancedSearch() {
+  advancedSearchActive = false;
+  $("#advanced_search_panel").data("where", null);
+  $("#adv_search_active_badge").hide();
+  $("#advanced-search-toggle").removeClass("adv-open");
+
+  $("#adv_search_rows").empty();
+  $("#adv_search_rows").append(buildAdvancedSearchRow(true));
+  $("#adv_order_rows").empty();
+  $("#adv-limit-input").val("");
+}
+```
+
+- [ ] **Step 2: Update `resetAggregate` to clear ORDER BY rows and LIMIT**
+
+Replace:
+
+```javascript
+function resetAggregate() {
+  aggregateActive = false;
+  $("#agg_active_badge").hide();
+  $("#agg_group_by_select").val([]);
+  $("#agg_expr_rows").empty();
+  $("#agg_having_rows").empty();
+  $("#aggregate_panel").hide();
+  $("#aggregate-toggle").removeClass("agg-open");
+  $("#pagination").removeClass("agg-panel-open");
+```
+
+```javascript
+function resetAggregate() {
+  aggregateActive = false;
+  $("#agg_active_badge").hide();
+  $("#agg_group_by_select").val([]);
+  $("#agg_expr_rows").empty();
+  $("#agg_having_rows").empty();
+  $("#agg_order_rows").empty();
+  $("#agg-limit-input").val("");
+  $("#aggregate_panel").hide();
+  $("#aggregate-toggle").removeClass("agg-open");
+  $("#pagination").removeClass("agg-panel-open");
+```
+
+- [ ] **Step 3: Add Advanced ORDER BY event handlers**
+
+After the `#adv-add-condition` click handler, add:
+
+```javascript
+  // Add ORDER BY row to Advanced panel
+  $("#adv-add-order").on("click", function() {
+    var colHtml = $("#pagination select.column").html() || '<option value="">Select column</option>';
+    $("#adv_order_rows").append(buildOrderByRow(colHtml));
+    adjustOutputTop();
+  });
+
+  // Remove ORDER BY row from Advanced panel
+  $("#adv_order_rows").on("click", ".order-by-remove", function() {
+    $(this).closest(".order-by-row").remove();
+    adjustOutputTop();
+  });
+```
+
+- [ ] **Step 4: Add Aggregate ORDER BY event handlers and wire column sync**
+
+After the `#agg-add-having` click handler, add:
+
+```javascript
+  // Add ORDER BY row to Aggregate panel
+  $("#agg-add-order").on("click", function() {
+    var options = [];
+    var gbCols = $("#agg_group_by_select").val() || [];
+    gbCols.forEach(function(c) { options.push(c); });
+    getAggregateAliases().forEach(function(a) { options.push(a); });
+    var colHtml = options.map(function(o) {
+      return '<option value="' + o + '">' + o + '</option>';
+    }).join("") || '<option value="">Select column</option>';
+    $("#agg_order_rows").append(buildOrderByRow(colHtml));
+  });
+
+  // Remove ORDER BY row from Aggregate panel
+  $("#agg_order_rows").on("click", ".order-by-remove", function() {
+    $(this).closest(".order-by-row").remove();
+  });
+```
+
+- [ ] **Step 5: Call `updateAggOrderByColumns` wherever `updateHavingAliasDropdowns` is called**
+
+Find all three call sites of `updateHavingAliasDropdowns()` and add `updateAggOrderByColumns()` immediately after each:
+
+```javascript
+// Site 1 — agg-fn change handler
+    updateHavingAliasDropdowns();
+    updateAggOrderByColumns();
+
+// Site 2 — agg-alias input handler
+    updateHavingAliasDropdowns();
+    updateAggOrderByColumns();
+
+// Site 3 — agg-remove-row click handler
+    updateHavingAliasDropdowns();
+    updateAggOrderByColumns();
+```
+
+- [ ] **Step 6: Call `updateAdvOrderByColumns` wherever `#adv_search_rows .adv-col` columns are synced**
+
+Find the block around line 1101 that syncs `.adv-col` dropdowns and add the call after it:
+
+```javascript
+    // Sync columns into any existing advanced search rows
+    var colHtml = $("#pagination select.column").html();
+    $("#adv_search_rows .adv-col").each(function() {
+      var prev = $(this).val();
+      $(this).html(colHtml);
+      $(this).val(prev);
+    });
+    updateAdvOrderByColumns();   // ← add this line
+```
+
+Also call `updateAggOrderByColumns()` wherever `buildGroupBySection()` is called (GROUP BY selection changes affect the ORDER BY column list):
+
+```javascript
+    buildGroupBySection();
+    updateAggOrderByColumns();   // ← add after every buildGroupBySection() call
+```
+
+Find all `buildGroupBySection()` call sites and add the line after each.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add static/js/app.js
+git commit -S -m "feat: wire ORDER BY event handlers, reset functions, and column sync for Advanced and Aggregate"
+```
+
+---
+
+## Task 7: Build and verify
+
+- [ ] **Step 1: Build**
+
+```bash
+GOROOT=/opt/homebrew/Cellar/go/1.26.1/libexec \
+GOPROXY=https://proxy.golang.org,direct \
+GONOSUMDB='*' \
+GOOS=linux GOARCH=amd64 \
+go build -o ./bin/pgweb_linux_amd64
+```
+
+Expected: exits 0, `bin/pgweb_linux_amd64` updated.
+
+- [ ] **Step 2: Manual smoke-test checklist**
+
+Start the server and open a table's Rows tab. Verify:
+
+**Advanced panel:**
+1. Click `+ Add` in ORDER BY section → row appears with column dropdown + ASC/DESC
+2. Select a column, set DESC, click Apply → query runs; click Show Query → `ORDER BY "col" DESC` appears in SQL
+3. Add a second ORDER BY row → `ORDER BY "col1" DESC, "col2" ASC` in SQL
+4. Set LIMIT to `5` → `LIMIT 5` appears in SQL and only 5 rows return
+5. Click Clear → ORDER BY rows gone, LIMIT input empty
+6. Changing table reloads columns into ORDER BY dropdowns correctly
+
+**Aggregate panel:**
+1. Select GROUP BY columns, add aggregate expression
+2. Click `+ Add` in ORDER BY section → dropdown contains GROUP BY cols + aggregate aliases
+3. Set `count DESC`, click Apply → `ORDER BY "count" DESC` in generated SQL (Show Query)
+4. Set LIMIT to `3` → `LIMIT 3` in SQL
+5. Click Clear → ORDER BY rows gone, LIMIT empty
+6. Adding/removing/renaming aggregate expressions updates ORDER BY dropdowns
+
+- [ ] **Step 3: Commit (if any fixups were needed)**
+
+```bash
+git add static/js/app.js static/css/app.css static/index.html
+git commit -S -m "fix: ORDER BY + LIMIT post-smoke-test fixups"
+```
+
+---
+
+## Self-Review Notes
+
+- **Spec coverage:** ORDER BY for both panels ✓ | Multi-column ✓ | LIMIT override ✓ | Advanced switches to client-side SQL ✓ | Show Query reflects new clauses ✓ | Resets clear new state ✓ | Column sync on table change ✓
+- **No placeholders:** All steps include exact code
+- **Type consistency:** `buildOrderByClause` signature `(containerSelector)` used consistently in Tasks 3, 4, 5 | `buildOrderByRow(colHtml)` used consistently in Tasks 3, 6 | `updateAggOrderByColumns()` / `updateAdvOrderByColumns()` zero-arg calls throughout
+- **Edge case noted:** When `advancedSearchActive` is true, column-header click sort is ignored in favour of the panel ORDER BY rows (consistent with aggregate mode behaviour)
diff --git a/docs/superpowers/specs/2026-04-02-order-by-limit-design.md b/docs/superpowers/specs/2026-04-02-order-by-limit-design.md
new file mode 100644
index 000000000..364eaf77e
--- /dev/null
+++ b/docs/superpowers/specs/2026-04-02-order-by-limit-design.md
@@ -0,0 +1,112 @@
+# ORDER BY + LIMIT for Advanced and Aggregate Panels
+
+**Date:** 2026-04-02
+**Status:** Approved
+
+---
+
+## Summary
+
+Add multi-column ORDER BY and an explicit LIMIT input to both the Advanced search panel and the Aggregate panel in the Rows tab. Advanced search switches from the backend `getTableRows()` API to building its query fully client-side (consistent with how Aggregate already works), so ORDER BY appears in Show Query and no backend changes are needed.
+
+---
+
+## Approach
+
+Option A (approved): client-side SQL generation for both panels. No Go backend changes.
+
+---
+
+## UI
+
+### ORDER BY section (both panels)
+
+- Placed below HAVING in Aggregate; below condition rows in Advanced.
+- Section header: `ORDER BY` label + `+ Add` button.
+- Each row:
+  - Column dropdown
+  - Direction toggle: `ASC` / `DESC` (default ASC)
+  - Remove (`−`) button
+- Rows are comma-separated in SQL (no AND/OR conjunction).
+- Column options:
+  - **Advanced:** all table columns (same list as condition column dropdown)
+  - **Aggregate:** GROUP BY columns + aggregate aliases (PostgreSQL allows alias references in ORDER BY of grouped queries)
+
+### LIMIT input (both panels)
+
+- Inline in the panel footer, alongside Apply / Clear / Show Query.
+- Accepts a positive integer; non-numeric or empty falls back to `getRowsLimit()`.
+- Resets to empty on Clear.
+- Included in the generated SQL (visible in Show Query).
+- Does not affect the global paginator rows-per-page setting.
+
+---
+
+## SQL Generation
+
+### Shared helper
+
+```javascript
+// Returns "ORDER BY \"col1\" ASC, \"col2\" DESC" or null.
+function buildOrderByClause(rowsSelector) { ... }
+```
+
+Iterates ORDER BY rows under `rowsSelector`, skips rows with empty column. Returns `null` if no valid rows.
+
+### Aggregate (`buildAggregateQuery`)
+
+Clause order: `SELECT … FROM … WHERE … GROUP BY … HAVING … ORDER BY … LIMIT … OFFSET …`
+
+ORDER BY aliases are legal in PostgreSQL after GROUP BY.
+
+### Advanced — new `buildAdvancedQuery()`
+
+Replaces `getTableRows()` call in `showTableContent()` when `advancedSearchActive` is true.
+
+```sql
+SELECT * FROM "schema"."table"
+[WHERE <where clause>]
+[ORDER BY "col1" ASC, "col2" DESC]
+LIMIT n [OFFSET n]
+```
+
+- `applyAdvancedSearch()` stores ORDER BY rows alongside the WHERE data so pagination reruns pick them up.
+- Column-header click sort is suppressed when `advancedSearchActive` is true and ORDER BY rows are present (mirrors existing aggregate guard).
+- Uses `executeQuery()` instead of `getTableRows()`.
+
+### LIMIT resolution (both panels)
+
+```javascript
+function getPanelLimit(panelSelector) {
+  var v = parseInt($(panelSelector + " .panel-limit-input").val(), 10);
+  return (v > 0) ? v : getRowsLimit();
+}
+```
+
+---
+
+## State & Reset
+
+- ORDER BY rows and LIMIT input are cleared by their respective Clear buttons.
+- Advanced: ORDER BY state stored in `#advanced_search_panel` data (alongside `where`), so `showPaginatedTableContent()` reruns correctly.
+- Aggregate: ORDER BY rows live in `#agg_order_rows` DOM; `buildAggregateQuery()` reads them fresh on every run.
+
+---
+
+## Files Changed
+
+| File | Change |
+|---|---|
+| `static/index.html` | Add ORDER BY sections + LIMIT inputs to both panels |
+| `static/js/app.js` | `buildOrderByClause()`, `buildAdvancedQuery()`, update `buildAggregateQuery()`, update `applyAdvancedSearch()`, update reset handlers |
+| `static/css/app.css` | Style ORDER BY rows (reuse `.adv-search-row` pattern), LIMIT input |
+
+No backend changes required.
+
+---
+
+## Out of Scope
+
+- OFFSET input (global paginator already handles paging)
+- ORDER BY for the simple filter (not a panel)
+- Saving ORDER BY state across table navigation
diff --git a/pkg/api/api.go b/pkg/api/api.go
index ef6507294..2ff1e298f 100644
--- a/pkg/api/api.go
+++ b/pkg/api/api.go
@@ -601,6 +601,7 @@ func GetBookmarks(c *gin.Context) {
 func GetInfo(c *gin.Context) {
 	successResponse(c, gin.H{
 		"app": command.Info,
+		"banner": command.Opts.Banner,
 		"features": gin.H{
 			"session_lock":   command.Opts.LockSession,
 			"query_timeout":  command.Opts.QueryTimeout,
diff --git a/pkg/command/options.go b/pkg/command/options.go
index 02e44a2a7..8ac6365b0 100644
--- a/pkg/command/options.go
+++ b/pkg/command/options.go
@@ -51,6 +51,7 @@ type Options struct {
 	Bookmark                     string `short:"b" long:"bookmark" description:"Bookmark to use for connection. Bookmark files are stored under $HOME/.pgweb/bookmarks/*.toml" default:""`
 	BookmarksDir                 string `long:"bookmarks-dir" description:"Overrides default directory for bookmark files to search" default:""`
 	BookmarksOnly                bool   `long:"bookmarks-only" description:"Allow only connections from bookmarks"`
+	Banner                       string `long:"banner" description:"Message to display on the connection page" default:""`
 	QueriesDir                   string `long:"queries-dir" description:"Overrides default directory for local queries"`
 	DisablePrettyJSON            bool   `long:"no-pretty-json" description:"Disable JSON formatting feature for result export"`
 	DisableSSH                   bool   `long:"no-ssh" description:"Disable database connections via SSH"`
diff --git a/pkg/command/version.go b/pkg/command/version.go
index 143a8194c..b83ca8bc0 100644
--- a/pkg/command/version.go
+++ b/pkg/command/version.go
@@ -8,7 +8,7 @@ import (
 
 const (
 	// Version is the current Pgweb application version
-	Version = "0.17.0"
+	Version = "0.17.0p1"
 )
 
 var (
diff --git a/static/css/app.css b/static/css/app.css
index b3aaebdfe..8595bb7e3 100644
--- a/static/css/app.css
+++ b/static/css/app.css
@@ -15,13 +15,13 @@
   margin: 0px;
   padding: 0px;
   height: 50px;
-  display: block;
+  display: flex;
+  align-items: stretch;
+  overflow: hidden;
 }
 
 #nav ul li {
-  margin: 0px;
-  padding: 0px;
-  float: left;
+  flex-shrink: 0;
   height: 49px;
   line-height: 49px;
   font-size: 13px;
@@ -30,7 +30,6 @@
   font-weight: 500;
   margin: 0 1px;
   cursor: pointer;
-  display: block;
   list-style: none;
   list-style-type: none;
 }
@@ -64,6 +63,25 @@
   border-left: none;
 }
 
+#nav_filter_caution {
+  flex: 1 1 0;
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  cursor: default;
+  pointer-events: none;
+  color: #f5c842;
+  font-size: 12px;
+  font-weight: 400;
+  opacity: 0.85;
+  padding-right: 160px; /* clear the fixed connection-actions buttons */
+}
+
+#nav_filter_caution .fa {
+  margin-right: 5px;
+}
+
 #sidebar {
   position: fixed;
   width: 250px;
@@ -327,6 +345,7 @@
   line-height: 30px;
   height: 30px;
   padding: 0px 13px;
+  cursor: pointer;
   margin: 0px;
   font-size: 13px;
   color: #555;
@@ -615,7 +634,7 @@
 }
 
 .with-pagination #output {
-  top: 50px !important;
+  top: 50px;
 }
 
 .with-pagination #pagination {
@@ -914,3 +933,278 @@
 .ace_autocomplete .ace_active-line {
   background: #eee !important;
 }
+
+/* ------------------------------------------------------------------ */
+/* Advanced Search Panel                                               */
+/* ------------------------------------------------------------------ */
+
+#pagination.adv-search-open {
+  height: auto;
+  min-height: 50px;
+}
+
+#advanced_search_panel {
+  clear: both;
+  padding: 8px 10px 4px 10px;
+  border-top: 1px solid #eee;
+  background: #fafafa;
+}
+
+.adv-search-header {
+  font-size: 12px;
+  margin-bottom: 6px;
+  line-height: 26px;
+}
+
+.adv-match-label {
+  color: #777;
+  margin: 0 6px;
+}
+
+.adv-conjunction-toggle {
+  display: inline-block;
+  vertical-align: middle;
+}
+
+.adv-search-row {
+  display: flex;
+  align-items: center;
+  margin-bottom: 4px;
+  gap: 6px;
+}
+
+.adv-search-row .adv-col {
+  width: 150px;
+  flex-shrink: 0;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.adv-search-row .adv-op {
+  width: 110px;
+  flex-shrink: 0;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.adv-search-row .adv-val {
+  flex: 1;
+  min-width: 80px;
+  max-width: 220px;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.adv-search-row .adv-remove-row {
+  flex-shrink: 0;
+  padding: 2px 7px;
+  height: 28px;
+  line-height: 22px;
+}
+
+.adv-search-footer {
+  margin-top: 6px;
+  padding-bottom: 4px;
+}
+
+.adv-search-footer .btn {
+  margin-right: 6px;
+}
+
+#advanced-search-toggle.adv-open {
+  background: #f0e8ff;
+  border-color: #79589f;
+  color: #79589f;
+}
+
+#adv_search_active_badge {
+  font-size: 11px;
+  margin-right: 6px;
+  vertical-align: middle;
+  background-color: #79589f;
+}
+
+/* Per-row AND/OR connector pill */
+.adv-row-conj {
+  display: flex;
+  align-items: center;
+  flex-shrink: 0;
+  width: 72px;
+  gap: 2px;
+}
+
+.adv-row-conj-first {
+  justify-content: flex-end;
+}
+
+.adv-row-conj-first span {
+  font-size: 11px;
+  color: #999;
+  font-weight: bold;
+  padding-right: 4px;
+}
+
+.adv-conj-btn {
+  font-size: 10px;
+  padding: 1px 5px;
+  border: 1px solid #ccc;
+  background: #fff;
+  color: #777;
+  border-radius: 3px;
+  cursor: pointer;
+  line-height: 16px;
+}
+
+.adv-conj-btn.active {
+  background: #79589f;
+  border-color: #79589f;
+  color: #fff;
+}
+
+/* Range input pair */
+.adv-val-range {
+  display: flex;
+  align-items: center;
+  flex: 1;
+  min-width: 0;
+  gap: 4px;
+}
+
+.adv-val-range .adv-val-from,
+.adv-val-range .adv-val-to {
+  flex: 1;
+  min-width: 60px;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.adv-range-sep {
+  flex-shrink: 0;
+  font-size: 11px;
+  color: #999;
+}
+
+/* Query preview box */
+#adv_query_display {
+  margin-top: 6px;
+  padding: 6px 8px;
+  background: #f5f5f5;
+  border: 1px solid #e0e0e0;
+  border-radius: 3px;
+}
+
+#adv_query_display pre {
+  margin: 0 0 6px 0;
+  font-size: 11px;
+  white-space: pre-wrap;
+  word-break: break-all;
+  color: #333;
+  max-height: 80px;
+  overflow-y: auto;
+}
+
+/* ── Aggregate panel ───────────────────────────────────────────── */
+
+#pagination.agg-panel-open {
+  height: auto;
+  min-height: 50px;
+}
+
+#aggregate_panel {
+  clear: both;
+  padding: 8px 10px 4px 10px;
+  border-top: 1px solid #eee;
+  background: #fafafa;
+}
+
+#aggregate-toggle.agg-open {
+  background: #f0e8ff;
+  border-color: #79589f;
+  color: #79589f;
+}
+
+#agg_active_badge {
+  font-size: 11px;
+  margin-right: 6px;
+  vertical-align: middle;
+  background-color: #79589f;
+}
+
+.agg-section {
+  margin-bottom: 10px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid #eee;
+}
+
+.agg-section:last-child {
+  border-bottom: none;
+}
+
+.agg-section-header {
+  font-size: 11px;
+  font-weight: bold;
+  color: #999;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 6px;
+}
+
+.agg-group-by-select {
+  height: 90px;
+  font-size: 12px;
+}
+
+.agg-group-by-hint {
+  font-size: 11px;
+  color: #aaa;
+  margin-top: 3px;
+}
+
+.agg-expr-row {
+  display: flex;
+  align-items: center;
+  margin-bottom: 4px;
+  gap: 6px;
+}
+
+.agg-expr-row .agg-fn {
+  width: 120px;
+  flex-shrink: 0;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.agg-expr-row .agg-col {
+  width: 140px;
+  flex-shrink: 0;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.agg-expr-row .agg-alias {
+  width: 120px;
+  flex-shrink: 0;
+  height: 28px;
+  font-size: 12px;
+  padding: 2px 6px;
+}
+
+.agg-expr-row .agg-remove-row {
+  flex-shrink: 0;
+  padding: 2px 7px;
+  height: 28px;
+  line-height: 22px;
+}
+
+.agg-col-hidden {
+  display: none !important;
+}
diff --git a/static/index.html b/static/index.html
index 71ccaf7c0..c4a96c53a 100644
--- a/static/index.html
+++ b/static/index.html
@@ -32,6 +32,10 @@
         <li id="table_history">History</li>
         <li id="table_activity">Activity</li>
         <li id="table_connection">Connection</li>
+        <li id="nav_filter_caution" class="nav-filter-caution">
+          <i class="fa fa-exclamation-triangle"></i>
+          Advanced &amp; Aggregate filters (Rows tab) may produce unexpected results &mdash; review generated SQL via <em>Show Query</em> before relying on output.
+        </li>
       </ul>
 
       <div class="connection-actions">
@@ -133,13 +137,65 @@
           <input type="text" class="form-control" placeholder="Filter value" id="table_filter_value" />
           <button class="btn btn-primary btn-sm apply-filters" type="submit">Apply</button>
           <button class="btn btn-default btn-sm reset-filters"><i class="fa fa-times"></i></button>
+          <button class="btn btn-default btn-sm" id="advanced-search-toggle" type="button">Advanced <i class="fa fa-caret-down"></i></button>
+          <button class="btn btn-default btn-sm" id="aggregate-toggle" type="button">Aggregate <i class="fa fa-caret-down"></i></button>
         </form>
+        <div id="advanced_search_panel" style="display:none;">
+          <div class="adv-search-header">
+            <span class="adv-match-label">Conditions:</span>
+          </div>
+          <div id="adv_search_rows">
+            <!-- Condition rows injected by buildAdvancedSearchRow() -->
+          </div>
+          <div class="adv-search-footer">
+            <button type="button" class="btn btn-default btn-xs" id="adv-add-condition"><i class="fa fa-plus"></i> Add Condition</button>
+            <button type="button" class="btn btn-primary btn-sm" id="adv-apply">Apply</button>
+            <button type="button" class="btn btn-default btn-sm" id="adv-reset"><i class="fa fa-times"></i> Clear</button>
+            <button type="button" class="btn btn-default btn-sm" id="adv-show-query"><i class="fa fa-code"></i> Show Query</button>
+          </div>
+        </div>
+        <div id="aggregate_panel" style="display:none;">
+          <div class="agg-section">
+            <div class="agg-section-header">GROUP BY</div>
+            <select id="agg_group_by_select" multiple class="form-control agg-group-by-select" aria-label="GROUP BY" aria-describedby="agg-group-by-help"></select>
+            <div class="agg-group-by-hint" id="agg-group-by-help">Hold Ctrl / Cmd to select multiple columns</div>
+          </div>
+          <div class="agg-section">
+            <div class="agg-section-header">
+              AGGREGATES
+              <button type="button" class="btn btn-default btn-xs" id="agg-add-expr"><i class="fa fa-plus"></i> Add</button>
+            </div>
+            <div id="agg_expr_rows">
+              <!-- Aggregate expression rows injected by buildAggregateRow() -->
+            </div>
+          </div>
+          <div class="agg-section">
+            <div class="agg-section-header">
+              HAVING
+              <button type="button" class="btn btn-default btn-xs" id="agg-add-having"><i class="fa fa-plus"></i> Add</button>
+            </div>
+            <div id="agg_having_rows">
+              <!-- Having condition rows injected by buildHavingRow() -->
+            </div>
+          </div>
+          <div class="adv-search-footer">
+            <button type="button" class="btn btn-primary btn-sm" id="agg-apply">Apply</button>
+            <button type="button" class="btn btn-default btn-sm" id="agg-reset"><i class="fa fa-times"></i> Clear</button>
+            <button type="button" class="btn btn-default btn-sm" id="agg-show-query"><i class="fa fa-code"></i> Show Query</button>
+          </div>
+        </div>
+        <div id="adv_query_display" style="display:none;">
+          <pre id="adv_query_text"></pre>
+          <button type="button" class="btn btn-default btn-xs" id="adv-copy-query"><i class="fa fa-copy"></i> Copy</button>
+        </div>
         <div class="btn-group">
           <button type="button" class="btn btn-default btn-sm prev-page" disabled="disabled"><i class="fa fa-angle-left"></i></button>
           <button type="button" class="btn btn-default btn-sm page change-limit" title="Click to change row limit"></button>
           <button type="button" class="btn btn-default btn-sm next-page"><i class="fa fa-angle-right"></i></button>
         </div>
         <div class="current-page" data-page="1" data-pages="1">
+          <span id="adv_search_active_badge" class="label label-primary" style="display:none;">Advanced Filter Active</span>
+          <span id="agg_active_badge" class="label label-primary" style="display:none;">Aggregate Active</span>
           <span id="total_records"></span> rows
         </div>
       </div>
@@ -163,6 +219,7 @@
         <h1>pgweb</h1>
         <div class="version"></div>
         <div class="update alert alert-warning"></div>
+        <div id="banner_message" class="alert alert-info" style="margin-top:10px;display:none"></div>
       </div>
 
       <form role="form" class="form-horizontal" id="connection_form">
diff --git a/static/js/app.js b/static/js/app.js
index d5b26d4ef..30cbe53d8 100644
--- a/static/js/app.js
+++ b/static/js/app.js
@@ -8,20 +8,62 @@ var currentObject       = null;
 var autocompleteObjects = [];
 var inputResizing       = false;
 var inputResizeOffset   = null;
+var advancedSearchActive = false;
+var aggregateActive = false;
 
 var filterOptions = {
-  "equal":      "= 'DATA'",
-  "not_equal":  "!= 'DATA'",
-  "greater":    "> 'DATA'" ,
-  "greater_eq": ">= 'DATA'",
-  "less":       "< 'DATA'",
-  "less_eq":    "<= 'DATA'",
-  "like":       "LIKE 'DATA'",
-  "ilike":      "ILIKE 'DATA'",
-  "null":       "IS NULL",
-  "not_null":   "IS NOT NULL"
+  // Standard comparison (single value) — also used by simple filter
+  "equal":        "= 'DATA'",
+  "not_equal":    "!= 'DATA'",
+  "greater":      "> 'DATA'",
+  "greater_eq":   ">= 'DATA'",
+  "less":         "< 'DATA'",
+  "less_eq":      "<= 'DATA'",
+  "like":         "LIKE 'DATA'",
+  "ilike":        "ILIKE 'DATA'",
+
+  // NULL checks (no value)
+  "null":         "IS NULL",
+  "not_null":     "IS NOT NULL",
+
+  // List operators — comma-separated values → IN (...)
+  "in":           "IN (DATA)",
+  "not_in":       "NOT IN (DATA)",
+
+  // Range operators — two values
+  "between":      "BETWEEN 'DATA1' AND 'DATA2'",
+  "not_between":  "NOT BETWEEN 'DATA1' AND 'DATA2'",
+
+  // Pattern operators
+  "contains":       "LIKE '%DATA%'",
+  "not_contains":   "NOT LIKE '%DATA%'",
+  "icontains":      "ILIKE '%DATA%'",
+  "not_icontains":  "NOT ILIKE '%DATA%'",
+  "starts_with":    "LIKE 'DATA%'",
+  "ends_with":      "LIKE '%DATA'",
+  "istarts_with":   "ILIKE 'DATA%'",
+  "iends_with":     "ILIKE '%DATA'",
+
+  // Regex operators
+  "regex":          "~ 'DATA'",
+  "iregex":         "~* 'DATA'"
 };
 
+// Returns the input type required for an operator: "none" | "single" | "list" | "range"
+function getOpInputType(op) {
+  if (!op || !filterOptions[op]) return "single";
+  if (op === "null" || op === "not_null")           return "none";
+  if (op === "in"   || op === "not_in")             return "list";
+  if (op === "between" || op === "not_between")     return "range";
+  return "single";
+}
+
+// Escape a filter value for inline SQL string literals.
+// Doubles single-quotes to prevent basic SQL injection via filter values.
+function escapeSqlLiteral(val) {
+  return String(val).replace(/'/g, "''");
+}
+
 function getSessionId() {
   var id = sessionStorage.getItem("session_id");
 
@@ -616,6 +658,21 @@ function showTableContent(sortColumn, sortOrder) {
     return;
   }
 
+  if (aggregateActive) {
+    var aggQuery = buildAggregateQuery();
+    if (!aggQuery) { alert("Select at least one column to group by."); return; }
+    executeQuery(aggQuery, function(data) {
+      $("#input").hide();
+      $("#body").prop("class", "with-pagination");
+      adjustOutputTop();
+      buildTable(data);
+      setCurrentTab("table_content");
+      updatePaginator(data.pagination);
+      $("#results").data("mode", "aggregate").data("table", name);
+    });
+    return;
+  }
+
   var opts = {
     limit:       getRowsLimit(),
     offset:      getPaginationOffset(),
@@ -623,25 +680,32 @@ function showTableContent(sortColumn, sortOrder) {
     sort_order:  sortOrder
   };
 
-  var filter = {
-    column: $(".filters select.column").val(),
-    op:     $(".filters select.filter").val(),
-    input:  $(".filters input").val()
-  };
+  // Advanced search takes precedence over the simple filter
+  if (advancedSearchActive) {
+    var advWhere = $("#advanced_search_panel").data("where");
+    if (advWhere) opts["where"] = advWhere;
+  } else {
+    var filter = {
+      column: $(".filters select.column").val(),
+      op:     $(".filters select.filter").val(),
+      input:  $(".filters input").val()
+    };
 
-  // Apply filtering only if column is selected
-  if (filter.column && filter.op) {
-    var where = [
-      '"' + filter.column + '"',
-      filterOptions[filter.op].replace("DATA", filter.input)
-    ].join(" ");
+    // Apply filtering only if column is selected
+    if (filter.column && filter.op) {
+      var where = [
+        '"' + filter.column + '"',
+        filterOptions[filter.op].replace("DATA", escapeSqlLiteral(filter.input))
+      ].join(" ");
 
-    opts["where"] = where;
+      opts["where"] = where;
+    }
   }
 
   getTableRows(name, opts, function(data) {
     $("#input").hide();
     $("#body").prop("class", "with-pagination");
+    adjustOutputTop();
 
     buildTable(data, sortColumn, sortOrder);
     setCurrentTab("table_content");
@@ -755,7 +819,8 @@ function showQueryPanel() {
   editor.focus();
 
   $("#input").show();
-  $("#body").prop("class", "")
+  $("#body").prop("class", "");
+  $("#output").css("top", $("#input").height() + "px");
 }
 
 function showConnectionPanel() {
@@ -874,72 +939,96 @@ function getSubquery(text, cursor) {
 }
 
 function runQuery() {
-  setCurrentTab("table_query");
   showQueryProgressMessage();
+  try {
+    setCurrentTab("table_query");
 
-  var query = getEditorSelection();
-  if (query.length == 0) {
-    hideQueryProgressMessage();
-    return;
-  }
+    var query = getEditorSelection();
+    if (query.length == 0) {
+      hideQueryProgressMessage();
+      return;
+    }
 
-  executeQuery(query, function(data) {
-    buildTable(data);
+    executeQuery(query, function(data) {
+      try {
+        buildTable(data);
 
-    hideQueryProgressMessage();
-    $("#input").show();
-    $("#body").removeClass("full");
-    $("#results").data("mode", "query");
+        $("#input").show();
+        $("#body").removeClass("full");
+        $("#results").data("mode", "query");
 
-    if (query.toLowerCase().indexOf("explain") != -1) {
-      $("#results").addClass("no-crop");
-    }
+        if (query.toLowerCase().indexOf("explain") != -1) {
+          $("#results").addClass("no-crop");
+        }
 
-    // Reload objects list if anything was created/deleted
-    if (query.match(/(create|drop)\s/i)) {
-      loadSchemas();
-    }
-  });
+        // Reload objects list if anything was created/deleted
+        if (query.match(/(create|drop)\s/i)) {
+          loadSchemas();
+        }
+      } finally {
+        hideQueryProgressMessage();
+      }
+    });
+  } catch(e) {
+    hideQueryProgressMessage();
+    throw e;
+  }
 }
 
 function runExplain() {
-  setCurrentTab("table_query");
   showQueryProgressMessage();
+  try {
+    setCurrentTab("table_query");
 
-  var query = getEditorSelection();
-  if (query.length == 0) {
-    hideQueryProgressMessage();
-    return;
-  }
+    var query = getEditorSelection();
+    if (query.length == 0) {
+      hideQueryProgressMessage();
+      return;
+    }
 
-  explainQuery(query, function(data) {
-    buildTable(data);
+    explainQuery(query, function(data) {
+      try {
+        buildTable(data);
 
+        $("#input").show();
+        $("#body").removeClass("full");
+        $("#results").addClass("no-crop");
+      } finally {
+        hideQueryProgressMessage();
+      }
+    });
+  } catch(e) {
     hideQueryProgressMessage();
-    $("#input").show();
-    $("#body").removeClass("full");
-    $("#results").addClass("no-crop");
-  });
+    throw e;
+  }
 }
 
 function runAnalyze() {
-  setCurrentTab("table_query");
   showQueryProgressMessage();
+  try {
+    setCurrentTab("table_query");
 
-  var query = getEditorSelection();
-  if (query.length == 0) {
-    hideQueryProgressMessage();
-    return;
-  }
+    var query = getEditorSelection();
+    if (query.length == 0) {
+      hideQueryProgressMessage();
+      return;
+    }
 
-  analyzeQuery(query, function(data) {
-    buildTable(data);
+    analyzeQuery(query, function(data) {
+      try {
+        buildTable(data);
 
+        $("#input").show();
+        $("#body").removeClass("full");
+        $("#results").addClass("no-crop");
+      } finally {
+        hideQueryProgressMessage();
+      }
+    });
+  } catch(e) {
     hideQueryProgressMessage();
-    $("#input").show();
-    $("#body").removeClass("full");
-    $("#results").addClass("no-crop");
-  });
+    throw e;
+  }
 }
 
 function generateURL(path, params) {
@@ -1023,6 +1112,491 @@ function buildTableFilters(name, type) {
       var el = $("<option/>").attr("value", row[0]).text(row[0]);
       $("#pagination select.column").append(el);
     }
+
+    // Sync columns into any existing advanced search rows
+    var colHtml = $("#pagination select.column").html();
+    $("#adv_search_rows .adv-col").each(function() {
+      var prev = $(this).val();
+      $(this).html(colHtml);
+      $(this).val(prev);
+    });
+
+    // Ensure at least one empty row exists in the panel
+    if ($("#adv_search_rows .adv-search-row").length === 0) {
+      $("#adv_search_rows").append(buildAdvancedSearchRow(true));
+      bindAdvancedOpHandlers();
+    }
+
+    buildGroupBySection();
+  });
+}
+
+// Build a new advanced search condition row element.
+// isFirst=true omits the AND/OR connector pill and shows a "WHERE" label instead.
+function buildAdvancedSearchRow(isFirst) {
+  var colHtml = $("#pagination select.column").html() || "<option value='' selected>Select column</option>";
+
+  var opHtml = [
+    '<option value="">Select filter</option>',
+    '<optgroup label="Comparison">',
+      '<option value="equal">=</option>',
+      '<option value="not_equal">&lt;&gt;</option>',
+      '<option value="less">&lt;</option>',
+      '<option value="greater">&gt;</option>',
+      '<option value="less_eq">&lt;=</option>',
+      '<option value="greater_eq">&gt;=</option>',
+    '</optgroup>',
+    '<optgroup label="List">',
+      '<option value="in">IN</option>',
+      '<option value="not_in">NOT IN</option>',
+    '</optgroup>',
+    '<optgroup label="Null">',
+      '<option value="null">IS NULL</option>',
+      '<option value="not_null">IS NOT NULL</option>',
+    '</optgroup>',
+    '<optgroup label="Range">',
+      '<option value="between">BETWEEN</option>',
+      '<option value="not_between">NOT BETWEEN</option>',
+    '</optgroup>',
+    '<optgroup label="Pattern">',
+      '<option value="contains">Contains</option>',
+      '<option value="not_contains">Not contains</option>',
+      '<option value="icontains">Contains (case insensitive)</option>',
+      '<option value="not_icontains">Not contains (case insensitive)</option>',
+      '<option value="starts_with">Has prefix</option>',
+      '<option value="ends_with">Has suffix</option>',
+      '<option value="istarts_with">Has prefix (case insensitive)</option>',
+      '<option value="iends_with">Has suffix (case insensitive)</option>',
+      '<option value="regex">Matches regex</option>',
+      '<option value="iregex">Matches regex (case insensitive)</option>',
+    '</optgroup>'
+  ].join("");
+
+  var row = $('<div class="adv-search-row" data-row-conj="AND"></div>');
+
+  if (isFirst) {
+    row.append('<div class="adv-row-conj adv-row-conj-first"><span>WHERE</span></div>');
+  } else {
+    row.append(
+      '<div class="adv-row-conj">' +
+        '<button type="button" class="btn btn-xs adv-conj-btn active" data-conj="AND">AND</button>' +
+        '<button type="button" class="btn btn-xs adv-conj-btn" data-conj="OR">OR</button>' +
+      '</div>'
+    );
+  }
+
+  row.append('<select class="adv-col form-control">' + colHtml + '</select>');
+  row.append('<select class="adv-op form-control">'  + opHtml  + '</select>');
+  row.append('<input type="text" class="adv-val form-control" placeholder="Value" />');
+  row.append('<input type="text" class="adv-val-list form-control" placeholder="val1, val2, val3" style="display:none;" />');
+  row.append(
+    '<span class="adv-val-range" style="display:none;">' +
+      '<input type="text" class="adv-val-from form-control" placeholder="From" />' +
+      '<span class="adv-range-sep">and</span>' +
+      '<input type="text" class="adv-val-to form-control" placeholder="To" />' +
+    '</span>'
+  );
+  if (!isFirst) {
+    row.append('<button type="button" class="btn btn-default btn-xs adv-remove-row"><i class="fa fa-minus"></i></button>');
+  }
+
+  return row;
+}
+
+function buildGroupBySection() {
+  var sel = $("#agg_group_by_select");
+  sel.empty();
+  $("#pagination select.column option").each(function() {
+    var val = $(this).val();
+    if (!val) return;
+    sel.append($("<option>", { value: val, text: val }));
+  });
+}
+
+function buildAggregateRow() {
+  var colHtml = $("#pagination select.column").html() || "<option value='' selected>Select column</option>";
+
+  var fnSelect = $('<select class="form-control agg-fn"></select>').append(
+    $('<option value="COUNT(*)">COUNT(*)</option>'),
+    $('<option value="SUM">SUM</option>'),
+    $('<option value="AVG">AVG</option>'),
+    $('<option value="MIN">MIN</option>'),
+    $('<option value="MAX">MAX</option>')
+  );
+
+  var colSelect = $('<select class="form-control agg-col agg-col-hidden"></select>').html(colHtml);
+
+  var aliasInput = $('<input type="text" class="form-control agg-alias" placeholder="alias (optional)" />');
+
+  var removeBtn = $('<button type="button" class="btn btn-default btn-xs agg-remove-row"><i class="fa fa-minus"></i></button>');
+
+  return $('<div class="agg-expr-row"></div>').append(fnSelect, colSelect, aliasInput, removeBtn);
+}
+
+function getAggregateAliases() {
+  var seen = {};
+  var aliases = [];
+  $("#agg_expr_rows .agg-expr-row").each(function() {
+    var fn    = $(this).find(".agg-fn").val() || "";
+    var col   = $(this).find(".agg-col").val() || "";
+    var alias = $.trim($(this).find(".agg-alias").val());
+    if (alias === "") {
+      if (fn === "COUNT(*)") {
+        alias = "count";
+      } else {
+        alias = fn.toLowerCase() + (col ? "_" + col : "");
+      }
+    }
+    var base = alias;
+    var n = 2;
+    while (seen[alias]) {
+      alias = base + "_" + n;
+      n++;
+    }
+    seen[alias] = true;
+    aliases.push(alias);
+  });
+  return aliases;
+}
+
+// Returns an array of {alias, expr} objects where expr is the full aggregate expression
+// (e.g. COUNT(*), SUM("col")) suitable for use in HAVING clauses.
+function getAggregateExprs() {
+  var seen = {};
+  var result = [];
+  $("#agg_expr_rows .agg-expr-row").each(function() {
+    var fn    = $(this).find(".agg-fn").val() || "";
+    var col   = $(this).find(".agg-col").val() || "";
+    var alias = $.trim($(this).find(".agg-alias").val());
+    if (alias === "") {
+      if (fn === "COUNT(*)") {
+        alias = "count";
+      } else {
+        alias = fn.toLowerCase() + (col ? "_" + col : "");
+      }
+    }
+    var base = alias;
+    var n = 2;
+    while (seen[alias]) {
+      alias = base + "_" + n;
+      n++;
+    }
+    seen[alias] = true;
+    var expr = fn === "COUNT(*)" ? "COUNT(*)" : fn + '("' + col + '")';
+    result.push({ alias: alias, expr: expr });
+  });
+  return result;
+}
+
+function buildHavingRow(isFirst) {
+  var row = $('<div class="adv-search-row" data-row-conj="AND"></div>');
+  if (isFirst) {
+    row.append('<div class="adv-row-conj adv-row-conj-first"><span>WHERE</span></div>');
+  } else {
+    row.append(
+      '<div class="adv-row-conj">' +
+        '<button type="button" class="btn btn-xs adv-conj-btn active" data-conj="AND">AND</button>' +
+        '<button type="button" class="btn btn-xs adv-conj-btn" data-conj="OR">OR</button>' +
+      '</div>'
+    );
+  }
+
+  var aggExprs = getAggregateExprs();
+  var exprSelect = $('<select class="having-expr form-control"></select>');
+  if (aggExprs.length === 0) {
+    exprSelect.append('<option value=""></option>');
+  } else {
+    $.each(aggExprs, function(i, e) {
+      exprSelect.append($('<option></option>').val(e.expr).text(e.alias));
+    });
+  }
+
+  var opSelect = $('<select class="having-op form-control"></select>');
+  $.each(["=", "<>", "<", ">", "<=", ">="], function(i, op) {
+    opSelect.append($('<option></option>').val(op).text(op));
+  });
+
+  var valInput = $('<input type="text" class="having-val form-control" placeholder="Value" />');
+
+  row.append(exprSelect).append(opSelect).append(valInput);
+
+  row.append('<button type="button" class="btn btn-default btn-xs adv-remove-row"><i class="fa fa-minus"></i></button>');
+
+  return row;
+}
+
+function updateHavingAliasDropdowns() {
+  var aggExprs = getAggregateExprs();
+  var exprVals = aggExprs.map(function(e) { return e.expr; });
+  $("#agg_having_rows .adv-search-row").each(function() {
+    var sel  = $(this).find(".having-expr");
+    var prev = sel.val();
+    sel.empty();
+    if (aggExprs.length === 0) {
+      sel.append('<option value=""></option>');
+    } else {
+      $.each(aggExprs, function(i, e) {
+        sel.append($('<option></option>').val(e.expr).text(e.alias));
+      });
+    }
+    if (prev && exprVals.indexOf(prev) !== -1) {
+      sel.val(prev);
+    }
+  });
+}
+
+function buildAggregateSelectClause() {
+  var parts = [];
+  var cols = $("#agg_group_by_select").val() || [];
+  cols.forEach(function(c) { parts.push('"' + c + '"'); });
+  var aliases = getAggregateAliases();
+  var i = 0;
+  $("#agg_expr_rows .agg-expr-row").each(function() {
+    var fn    = $(this).find(".agg-fn").val() || "";
+    var col   = $(this).find(".agg-col").val() || "";
+    var alias = aliases[i] || "";
+    i++;
+    var expr;
+    if (fn === "COUNT(*)") {
+      expr = "COUNT(*) AS " + alias;
+    } else {
+      expr = fn + '("' + col + '") AS ' + alias;
+    }
+    parts.push(expr);
+  });
+  return parts.join(", ");
+}
+
+function buildGroupByClause() {
+  var cols = $("#agg_group_by_select").val() || [];
+  if (cols.length === 0) return null;
+  return "GROUP BY " + cols.map(function(c) { return '"' + c + '"'; }).join(", ");
+}
+
+function buildHavingClause() {
+  var parts = [];
+  $("#agg_having_rows .adv-search-row").each(function() {
+    var expr    = $(this).find(".having-expr").val() || "";
+    var op      = $(this).find(".having-op").val()   || "";
+    var val     = $.trim($(this).find(".having-val").val());
+    var rowConj = $(this).data("row-conj") || "AND";
+    if (expr === "" || op === "" || val === "") return;
+    var numVal = parseFloat(val);
+    if (isNaN(numVal)) return;
+    parts.push({ expr: expr + " " + op + " " + String(numVal), conj: rowConj });
+  });
+  if (parts.length === 0) return null;
+  var sql = parts[0].expr;
+  for (var i = 1; i < parts.length; i++) {
+    sql += " " + parts[i].conj + " " + parts[i].expr;
+  }
+  return "HAVING " + sql;
+}
+
+function buildAggregateQuery() {
+  var obj   = getCurrentObject();
+  var parts = obj.name.split(".");
+  var tableRef;
+  if (parts.length === 2) {
+    tableRef = '"' + parts[0] + '"."' + parts[1] + '"';
+  } else {
+    tableRef = '"' + parts[0] + '"';
+  }
+
+  var selectClause = buildAggregateSelectClause();
+  var groupBy      = buildGroupByClause();
+  if (!groupBy) return null;
+
+  var sql = "SELECT " + selectClause + " FROM " + tableRef;
+
+  if (advancedSearchActive) {
+    var where = $("#advanced_search_panel").data("where");
+    if (where) sql += " WHERE " + where;
+  }
+
+  sql += " " + groupBy;
+
+  var having = buildHavingClause();
+  if (having) sql += " " + having;
+
+  sql += " LIMIT " + getRowsLimit();
+  var offset = getPaginationOffset();
+  if (offset > 0) sql += " OFFSET " + offset;
+
+  return sql;
+}
+
+// Build a combined SQL WHERE clause from all advanced search condition rows.
+function buildAdvancedWhereClause() {
+  var parts = []; // array of {expr, conj}
+
+  $("#adv_search_rows .adv-search-row").each(function() {
+    var col       = $(this).find(".adv-col").val();
+    var op        = $(this).find(".adv-op").val();
+    var rowConj   = $(this).data("row-conj") || "AND";
+    var inputType = getOpInputType(op);
+
+    if (!col || !op) return;
+
+    var template = filterOptions[op];
+    if (!template) return;
+
+    var fragment;
+
+    if (inputType === "none") {
+      fragment = '"' + col + '" ' + template;
+
+    } else if (inputType === "list") {
+      // Read from list input; fall back to single input if user typed there
+      var raw = $.trim($(this).find(".adv-val-list").val()) ||
+                $.trim($(this).find(".adv-val").val());
+      if (!raw) return;
+      var items = raw.split(",").map(function(s) {
+        return "'" + escapeSqlLiteral($.trim(s)) + "'";
+      });
+      fragment = '"' + col + '" ' + template.replace("DATA", items.join(", "));
+
+    } else if (inputType === "range") {
+      // Read from range inputs; fall back to parsing single input as "from,to"
+      var from = $.trim($(this).find(".adv-val-from").val());
+      var to   = $.trim($(this).find(".adv-val-to").val());
+      if (!from || !to) {
+        // Try parsing "val1,val2" or "val1 and val2" from single input
+        var single = $.trim($(this).find(".adv-val").val());
+        var rangeParts = single.split(/\s*(?:,|and)\s*/i);
+        if (rangeParts.length === 2) {
+          from = $.trim(rangeParts[0]);
+          to   = $.trim(rangeParts[1]);
+        }
+      }
+      if (!from || !to) return;
+      fragment = '"' + col + '" ' + template
+        .replace("DATA1", escapeSqlLiteral(from))
+        .replace("DATA2", escapeSqlLiteral(to));
+
+    } else {
+      var val = $.trim($(this).find(".adv-val").val());
+      if (!val) return;
+      fragment = '"' + col + '" ' + template.replace("DATA", escapeSqlLiteral(val));
+    }
+
+    parts.push({ expr: "(" + fragment + ")", conj: rowConj });
+  });
+
+  if (parts.length === 0) return null;
+
+  var sql = parts[0].expr;
+  for (var i = 1; i < parts.length; i++) {
+    sql += " " + parts[i].conj + " " + parts[i].expr;
+  }
+  return sql;
+}
+
+// Apply the advanced search conditions and reload table rows.
+function applyAdvancedSearch() {
+  var where = buildAdvancedWhereClause();
+
+  if (where === null) {
+    alert("Please complete at least one filter condition (column and operator are required).");
+    return;
+  }
+
+  $("#advanced_search_panel").data("where", where);
+  advancedSearchActive = true;
+
+  $("#adv_search_active_badge").show();
+  $("#advanced-search-toggle").addClass("adv-open");
+
+  $(".current-page").data("page", 1);
+  showTableContent();
+}
+
+// Clear the advanced search state and reset the panel to one empty row.
+function resetAdvancedSearch() {
+  advancedSearchActive = false;
+  $("#advanced_search_panel").data("where", null);
+  $("#adv_search_active_badge").hide();
+  $("#advanced-search-toggle").removeClass("adv-open");
+
+  $("#adv_search_rows").empty();
+  $("#adv_search_rows").append(buildAdvancedSearchRow(true));
+}
+
+function applyAggregate() {
+  if (buildGroupByClause() === null) {
+    alert("Select at least one column to group by.");
+    return;
+  }
+  aggregateActive = true;
+  $("#agg_active_badge").show();
+  $(".current-page").data("page", 1);
+  showTableContent();
+}
+
+function resetAggregate() {
+  aggregateActive = false;
+  $("#agg_active_badge").hide();
+  $("#agg_group_by_select").val([]);
+  $("#agg_expr_rows").empty();
+  $("#agg_having_rows").empty();
+  $("#aggregate_panel").hide();
+  $("#aggregate-toggle").removeClass("agg-open");
+  $("#pagination").removeClass("agg-panel-open");
+  adjustOutputTop();
+}
+
+// Build the full SELECT query string for the Show Query display. Delegates to
+// buildAggregateQuery() when aggregateActive, otherwise uses advanced search conditions.
+function buildFullQuery() {
+  if (aggregateActive) {
+    var aggQ = buildAggregateQuery();
+    return aggQ ? aggQ + ";" : null;
+  }
+  var where = buildAdvancedWhereClause();
+  if (!where) return null;
+  var table = getCurrentObject().name;
+  var nameParts = table.split(".");
+  var sql;
+  if (nameParts.length === 2) {
+    sql = 'SELECT * FROM "' + nameParts[0] + '"."' + nameParts[1] + '"';
+  } else {
+    sql = 'SELECT * FROM "' + table + '"';
+  }
+  return sql + " WHERE " + where + ";";
+}
+
+// Recalculate #output top offset to account for the advanced panel height.
+function adjustOutputTop() {
+  if ($("#pagination").is(":visible")) {
+    var h = $("#pagination").outerHeight(true);
+    $("#output").css("top", h + "px");
+  }
+}
+
+// Update the visible input controls for an advanced row based on its operator.
+function updateAdvRowInputs(row, op) {
+  var inputType = getOpInputType(op);
+  row.find(".adv-val").toggle(inputType === "single");
+  row.find(".adv-val-list").toggle(inputType === "list");
+  // Use css() for range span so it shows as flex, not block
+  if (inputType === "range") {
+    row.find(".adv-val-range").css("display", "flex");
+  } else {
+    row.find(".adv-val-range").hide();
+  }
+  if (inputType === "none") {
+    row.find(".adv-val, .adv-val-list").val("");
+    row.find(".adv-val-from, .adv-val-to").val("");
+  }
+}
+
+// Bind operator change handlers for advanced rows (delegated, called once).
+function bindAdvancedOpHandlers() {
+  if ($("#adv_search_rows").data("op-handler-bound")) return;
+  $("#adv_search_rows").data("op-handler-bound", true);
+
+  $("#adv_search_rows").on("change", ".adv-op", function() {
+    updateAdvRowInputs($(this).closest(".adv-search-row"), $(this).val());
   });
 }
 
@@ -1270,10 +1844,19 @@ function bindTableHeaderMenu() {
           var colValue = $(context).text();
           var colName  = $("#results_header th").eq(colIdx).data("name");
 
-          $("select.column").val(colName);
-          $("select.filter").val("equal");
-          $("#table_filter_value").val(colValue);
-          $("#rows_filter").submit();
+          if ($("#advanced_search_panel").is(":visible")) {
+            var newRow = buildAdvancedSearchRow();
+            newRow.find(".adv-col").val(colName);
+            newRow.find(".adv-op").val("equal");
+            newRow.find(".adv-val").val(colValue);
+            $("#adv_search_rows").append(newRow);
+          } else {
+            $("select.column").val(colName);
+            $("select.filter").val("equal");
+            $("#table_filter_value").val(colValue);
+            $("#rows_filter").submit();
+          }
+          break;
       }
     }
   });
@@ -1505,8 +2088,11 @@ function bindContentModalEvents() {
 
   $(window).on("click", function(e) {
     // Automatically hide the modal on any click outside of the modal window
-    if (e.target && !contentModal.contains(e.target)) {
+    if (e.target && !contentModal.contains(e.target) && $("#content_modal").is(":visible")) {
       $("#content_modal").hide();
+      if (editor && $("#table_query").hasClass("selected")) {
+        editor.focus();
+      }
     }
   });
 
@@ -1522,6 +2108,7 @@ function bindContentModalEvents() {
   });
 
   $("#results").on("dblclick", "td > div", function() {
+    if (aggregateActive) return;
     var value = unescapeHtml($(this).html());
     if (!value) return;
 
@@ -1594,6 +2181,8 @@ $(document).ready(function() {
     $(this).addClass("active");
     $(".current-page").data("page", 1);
     $(".filters select, .filters input").val("");
+    resetAdvancedSearch();
+    resetAggregate();
 
     if (currentObject.type == "function") {
       sessionStorage.setItem("tab", "table_structure");
@@ -1629,6 +2218,7 @@ $(document).ready(function() {
   })
 
   $("#results").on("click", "th", function(e) {
+    if (aggregateActive) return;
     if (!$("#table_content").hasClass("selected")) return;
 
     var sortColumn = $(this).data("name");
@@ -1681,9 +2271,191 @@ $(document).ready(function() {
 
   $("button.reset-filters").on("click", function() {
     $(".filters select, .filters input").val("");
+    resetAdvancedSearch();
+    resetAggregate();
     showTableContent();
   });
 
+  // ---- Advanced Search ------------------------------------------------
+
+  // Toggle the advanced search panel open/closed
+  $("#advanced-search-toggle").on("click", function() {
+    var panel = $("#advanced_search_panel");
+    if (panel.is(":visible")) {
+      panel.slideUp(150, function() {
+        $("#pagination").removeClass("adv-search-open");
+        adjustOutputTop();
+      });
+      $(this).find("i").removeClass("fa-caret-up").addClass("fa-caret-down");
+    } else {
+      if ($("#adv_search_rows .adv-search-row").length === 0) {
+        $("#adv_search_rows").append(buildAdvancedSearchRow(true));
+        bindAdvancedOpHandlers();
+      }
+      panel.slideDown(150, function() {
+        $("#pagination").addClass("adv-search-open");
+        adjustOutputTop();
+      });
+      $(this).find("i").removeClass("fa-caret-down").addClass("fa-caret-up");
+    }
+  });
+
+  // ---- Aggregate Panel ------------------------------------------------
+
+  // Toggle the aggregate panel open/closed
+  $("#aggregate-toggle").on("click", function() {
+    var panel = $("#aggregate_panel");
+    if (panel.is(":visible")) {
+      panel.hide();
+      $("#aggregate-toggle").removeClass("agg-open");
+      $("#pagination").removeClass("agg-panel-open");
+    } else {
+      buildGroupBySection();
+      panel.show();
+      $("#aggregate-toggle").addClass("agg-open");
+      $("#pagination").addClass("agg-panel-open");
+    }
+    adjustOutputTop();
+  });
+
+  $("#agg_expr_rows").on("change", ".agg-fn", function() {
+    var colSelect = $(this).siblings(".agg-col");
+    if ($(this).val() === "COUNT(*)") {
+      colSelect.addClass("agg-col-hidden");
+    } else {
+      colSelect.removeClass("agg-col-hidden");
+    }
+    updateHavingAliasDropdowns();
+  });
+
+  $("#agg_expr_rows").on("input", ".agg-alias", function() {
+    updateHavingAliasDropdowns();
+  });
+
+  $("#agg_expr_rows").on("click", ".agg-remove-row", function() {
+    $(this).closest(".agg-expr-row").remove();
+    updateHavingAliasDropdowns();
+  });
+
+  $("#agg-add-expr").on("click", function() {
+    $("#agg_expr_rows").append(buildAggregateRow());
+  });
+
+  $("#agg_having_rows").on("click", ".adv-conj-btn", function() {
+    var btn = $(this);
+    btn.closest(".adv-row-conj").find(".adv-conj-btn").removeClass("active");
+    btn.addClass("active");
+    btn.closest(".adv-search-row").data("row-conj", btn.data("conj"));
+  });
+
+  $("#agg_having_rows").on("click", ".adv-remove-row", function() {
+    var row = $(this).closest(".adv-search-row");
+    var wasFirst = row.is(":first-child");
+    row.remove();
+    if (wasFirst) {
+      var newFirst = $("#agg_having_rows .adv-search-row").first();
+      if (newFirst.length) {
+        newFirst.find(".adv-row-conj").replaceWith(
+          '<div class="adv-row-conj adv-row-conj-first"><span>WHERE</span></div>'
+        );
+      }
+    }
+  });
+
+  $("#agg-add-having").on("click", function() {
+    var isFirst = $("#agg_having_rows").children().length === 0;
+    $("#agg_having_rows").append(buildHavingRow(isFirst));
+  });
+
+  $("#agg-apply").on("click", function() {
+    applyAggregate();
+  });
+
+  $("#agg-reset").on("click", function() {
+    resetAggregate();
+    showTableContent();
+  });
+
+  $("#agg-show-query").on("click", function() {
+    var display = $("#adv_query_display");
+    if (display.is(":visible")) {
+      display.slideUp(100, adjustOutputTop);
+      return;
+    }
+    display.find("#adv_query_text").text("");
+    var q = buildAggregateQuery();
+    if (!q) {
+      alert("Select at least one column to group by.");
+      adjustOutputTop();
+      return;
+    }
+    $("#adv_query_text").text(q + ";");
+    display.slideDown(100, adjustOutputTop);
+  });
+
+  // Add a new condition row
+  $("#adv-add-condition").on("click", function() {
+    var newRow = buildAdvancedSearchRow(false);
+    $("#adv_search_rows").append(newRow);
+    newRow.find(".adv-col").focus();
+    adjustOutputTop();
+  });
+
+  // Remove a condition row (clear instead of remove if it's the last row)
+  $("#adv_search_rows").on("click", ".adv-remove-row", function() {
+    var rows = $("#adv_search_rows .adv-search-row");
+    if (rows.length <= 1) {
+      $(this).closest(".adv-search-row").find("select").val("");
+      $(this).closest(".adv-search-row").find("input").val("").show();
+    } else {
+      $(this).closest(".adv-search-row").remove();
+    }
+    adjustOutputTop();
+  });
+
+  // Toggle per-row AND/OR connector
+  $("#adv_search_rows").on("click", ".adv-conj-btn", function() {
+    $(this).closest(".adv-row-conj").find(".adv-conj-btn").removeClass("active");
+    $(this).addClass("active");
+    $(this).closest(".adv-search-row").data("row-conj", $(this).data("conj"));
+  });
+
+  // Apply advanced search
+  $("#adv-apply").on("click", function() {
+    applyAdvancedSearch();
+  });
+
+  // Clear advanced search (keep panel open)
+  $("#adv-reset").on("click", function() {
+    resetAdvancedSearch();
+    $("#adv_query_display").hide();
+    showTableContent();
+  });
+
+  // Show/hide the raw SQL query preview
+  $("#adv-show-query").on("click", function() {
+    var display = $("#adv_query_display");
+    if (display.is(":visible")) {
+      display.slideUp(100, adjustOutputTop);
+      $(this).find("i").removeClass("fa-chevron-up").addClass("fa-code");
+      return;
+    }
+    display.find("#adv_query_text").text("");
+    var sql = buildFullQuery();
+    if (!sql) {
+      alert("No valid conditions to preview. Fill in at least one complete condition.");
+      return;
+    }
+    $("#adv_query_text").text(sql);
+    display.slideDown(100, adjustOutputTop);
+    $(this).find("i").removeClass("fa-code").addClass("fa-chevron-up");
+  });
+
+  // Copy raw query to clipboard
+  $("#adv-copy-query").on("click", function() {
+    copyToClipboard($("#adv_query_text").text());
+  });
+
   // Automatically prefill the filter if it's not set yet
   $("select.column").on("change", function() {
     if ($("select.filter").val() == "") {
@@ -1887,6 +2659,9 @@ $(document).ready(function() {
 
     appInfo = resp.app;
     appFeatures = resp.features;
+    if (resp.banner) {
+      $("#banner_message").text(resp.banner).show();
+    }
 
     getConnection(function(resp) {
       if (resp.error) {