diff --git a/Cargo.lock b/Cargo.lock
index 051ab3a..caf6f48 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2236,6 +2236,7 @@ dependencies = [
  "chrono",
  "directories",
  "duckdb",
+ "getrandom 0.3.4",
  "gpui-component-shell",
  "gpui-kit",
  "gpui-shell",
diff --git a/Cargo.toml b/Cargo.toml
index b5ac9f9..85bc955 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,11 +36,12 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 ureq = { version = "3", default-features = false, features = ["rustls"] }
 hmac = "0.12"
 sha2 = "0.10"
-quick-xml = { version = "0.36", features = ["serialize"] }
-unicode-width = "0.2"
+getrandom = "0.3"
 # Map tiles: the same `image` GPUI decodes with, only the formats tile
 # servers send.
 image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }
+quick-xml = { version = "0.36", features = ["serialize"] }
+unicode-width = "0.2"
 
 [dev-dependencies]
 rust_xlsxwriter = "0.99"
diff --git a/README.md b/README.md
index ed6133e..64e1037 100644
--- a/README.md
+++ b/README.md
@@ -43,7 +43,15 @@ ducklocal query --sql "SELECT * FROM 'sales.csv'" --limit 20
 ducklocal query --database warehouse.duckdb --sql "SHOW TABLES"
 ```
 
-Results are structured JSON, with explicit truncation and precision-preserving value encodings; `--format md` prints the same values as a Markdown table for a document to quote. File databases default to read-only; writes require `--read-write`. Read-only is not a filesystem/network sandbox: `COPY` can still write files.
+Results are structured JSON, with explicit truncation and precision-preserving value encodings; `--format md` prints the same values as a Markdown table for a document to quote. File databases default to read-only; writes require `--read-write`. Read-only is not a filesystem/network sandbox: `COPY` can still write files. An error is JSON too, and carries a `hint` when there is an obvious next step — the flag that was meant, `--read-write` for a refused write, `ducklocal schema` for a table that does not exist.
+
+`ducklocal schema` maps what there is to query in one call — every file under the PATHs, or a database's tables and views, with their columns and the SQL that reads each. A large catalog comes back as a summary sized for a prompt, and `--stats` gives one relation's exact per-column statistics:
+
+```bash
+ducklocal schema ./data/
+ducklocal schema --database warehouse.duckdb --table orders
+ducklocal schema sales.csv --stats        # nulls, distinct, min/max, median, day coverage
+```
 
 An analysis app can be exported as one standalone HTML file — the statements its `query()` calls issued, with their results — for sharing with someone who does not have DuckLocal:
 
@@ -51,7 +59,7 @@ An analysis app can be exported as one standalone HTML file — the statements i
 ducklocal export --html examples/analysis_app
 ```
 
-A dashboard can also be declared as data: a `.dash` file of query and plot blocks, opened as a tab like an app, editable right there in the GUI. `ducklocal check` validates a spec without a window, and `ducklocal lsp` gives any LSP-capable editor the same diagnostics, completion, hover and go-to-definition:
+A dashboard can also be declared as data: a `.dash` file of query and plot blocks, opened as a tab like an app, editable right there in the GUI. A `filter` block makes a bar chart or a table clickable: the value picked there narrows every query that reads it as `$name` — cross-filtering, with the picking plot itself left whole. `ducklocal check` validates a spec without a window, and `ducklocal lsp` gives any LSP-capable editor the same diagnostics, completion, hover and go-to-definition:
 
 ```bash
 ducklocal dashboard.dash                  # open as a dashboard tab
@@ -59,6 +67,16 @@ ducklocal check dashboard.dash            # validate; JSON diagnostics, exit 2 o
 ducklocal lsp                             # language server over stdio, for editors
 ```
 
+When the work is for a person to see, `ducklocal open` hands it to the window that is already running — starting one if none is — as a tab in front. It runs in the window's own session, so they can carry on from it:
+
+```bash
+ducklocal open --title "Revenue" --run --sql "SELECT channel, sum(amount) FROM 'orders.csv' GROUP BY 1"
+ducklocal open dashboard.dash             # a dashboard tab; data files and folders attach
+ducklocal open --no-launch --sql-file q.sql   # exit 1, kind not_running, if no window is up
+```
+
+The other direction works too: `ducklocal open --state` reports what the running window shows — its tabs, each query's SQL and result, each dashboard's picked filters — so an agent can carry on from where the person left off.
+
 See the [CLI guide](https://ducklocal.app/docs/cli) for conversion, stdin, output, app export, and safety details.
 
 The [official agent skill](skills/ducklocal/SKILL.md) teaches schema-first exploration, SQL analysis, and verified file conversion. Copy it into your target project's supported skills directory; for example, from this checkout:
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 9565a9a..ff0cb2f 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -43,7 +43,15 @@ ducklocal query --sql "SELECT * FROM 'sales.csv'" --limit 20
 ducklocal query --database warehouse.duckdb --sql "SHOW TABLES"
 ```
 
-结果为结构化 JSON，显式标记截断并保留数值精度；`--format md` 把同样的值输出为 Markdown 表格，便于写进文档引用。文件数据库默认只读，写入需 `--read-write`；只读不是文件系统/网络沙箱，`COPY` 仍可写文件。
+结果为结构化 JSON，显式标记截断并保留数值精度；`--format md` 把同样的值输出为 Markdown 表格，便于写进文档引用。文件数据库默认只读，写入需 `--read-write`；只读不是文件系统/网络沙箱，`COPY` 仍可写文件。出错时同样输出 JSON；有明确下一步时会带 `hint`，比如拼错的参数本来是哪个、写入被拒时加 `--read-write`、表不存在时先跑 `ducklocal schema`。
+
+`ducklocal schema` 一次列出所有可查询的东西：PATH 下的每个文件，或数据库的表和视图，连同列和读取它的 SQL。目录很大时返回适合放进提示词的摘要；`--stats` 给出单个关系精确的逐列统计：
+
+```bash
+ducklocal schema ./data/
+ducklocal schema --database warehouse.duckdb --table orders
+ducklocal schema sales.csv --stats        # 空值、去重数、最值、中位数、日期覆盖
+```
 
 分析应用可以导出为一个独立 HTML 文件——应用 `query()` 发出的语句及其结果——方便发给没有 DuckLocal 的人：
 
@@ -51,7 +59,7 @@ ducklocal query --database warehouse.duckdb --sql "SHOW TABLES"
 ducklocal export --html examples/analysis_app
 ```
 
-dashboard 也可以声明为数据：一个由 query 和 plot block 组成的 `.dash` 文件，像应用一样以标签页打开，并可直接在 GUI 里编辑。`ducklocal check` 无窗口校验规格文件，`ducklocal lsp` 则把同样的诊断、补全、悬停和跳转定义提供给任何支持 LSP 的编辑器：
+dashboard 也可以声明为数据：一个由 query 和 plot block 组成的 `.dash` 文件，像应用一样以标签页打开，并可直接在 GUI 里编辑。`filter` block 让柱状图或表格可以点选：选中的值会筛选所有以 `$name` 引用它的查询，也就是交叉筛选，做选择的那张图本身保持不变。`ducklocal check` 无窗口校验规格文件，`ducklocal lsp` 则把同样的诊断、补全、悬停和跳转定义提供给任何支持 LSP 的编辑器：
 
 ```bash
 ducklocal dashboard.dash                  # 以 dashboard 标签页打开
@@ -59,6 +67,16 @@ ducklocal check dashboard.dash            # 校验；JSON 诊断，有错误时
 ducklocal lsp                             # 面向编辑器的语言服务器（stdio）
 ```
 
+如果结果是给人看的，`ducklocal open` 会把它交给已经在运行的窗口（没有就先启动一个），作为前台的新标签页打开。它在窗口自己的会话里运行，人可以直接接着改：
+
+```bash
+ducklocal open --title "Revenue" --run --sql "SELECT channel, sum(amount) FROM 'orders.csv' GROUP BY 1"
+ducklocal open dashboard.dash             # 打开为 dashboard 标签页；数据文件和文件夹会被挂载
+ducklocal open --no-launch --sql-file q.sql   # 没有窗口时退出码 1，kind 为 not_running
+```
+
+反方向也可以：`ducklocal open --state` 报告正在运行的窗口里显示的内容，包括各个标签页、每个查询的 SQL 和结果、每个 dashboard 当前选中的筛选。这样 agent 可以从人停下的地方接着做。
+
 转换、stdin、输出编码、应用导出和安全说明见 [CLI 指南](https://ducklocal.app/docs/zh/cli)。
 
 [官方 agent skill](skills/ducklocal/SKILL.md) 教 AI 先查 schema，再进行 SQL 分析及验证格式转换。复制到目标项目支持的 skill 目录即可，例如在本仓库执行：
diff --git a/examples/analysis_app/dashboard.dash b/examples/analysis_app/dashboard.dash
index a82ff52..5350889 100644
--- a/examples/analysis_app/dashboard.dash
+++ b/examples/analysis_app/dashboard.dash
@@ -1,5 +1,5 @@
 // The analysis_app panel's data as a dashboard spec: same orders.csv,
-// declared rather than scripted. Check it from the repository root:
+// declared rather than scripted. Check it from anywhere:
 //
 //   ducklocal check examples/analysis_app/dashboard.dash
 //
@@ -7,13 +7,26 @@
 //
 //   ducklocal examples/analysis_app/dashboard.dash
 //
-// Paths in SQL are relative to the working directory, like every other
-// ducklocal command.
+// The source's path is relative to this file, so the spec and its data move
+// together; the queries read it by name.
+
+source "orders" {
+  path = "orders.csv"
+}
+
+query "totals" {
+  sql = <<SQL
+    SELECT sum(revenue) AS revenue, sum(orders) AS orders,
+           count(DISTINCT channel) AS channels
+    FROM orders
+    WHERE $channel
+  SQL
+}
 
 query "revenue_by_channel" {
   sql = <<SQL
     SELECT channel, sum(revenue) AS revenue
-    FROM 'examples/analysis_app/orders.csv'
+    FROM orders
     GROUP BY channel
     ORDER BY revenue DESC
   SQL
@@ -22,18 +35,41 @@ query "revenue_by_channel" {
 query "daily_orders" {
   sql = <<SQL
     SELECT date, sum(orders) AS orders
-    FROM 'examples/analysis_app/orders.csv'
+    FROM orders
+    WHERE $channel
     GROUP BY date
     ORDER BY date
   SQL
 }
 
+plot "revenue_total" {
+  type  = "card"
+  query = query.totals
+  value = revenue
+  title = "Revenue"
+}
+
+plot "orders_total" {
+  type  = "card"
+  query = query.totals
+  value = orders
+  title = "Orders"
+}
+
+plot "channels" {
+  type  = "card"
+  query = query.totals
+  value = channels
+  title = "Channels"
+}
+
 plot "revenue" {
   type  = "bar"
   query = query.revenue_by_channel
   x     = channel
   y     = revenue
   title = "Revenue by channel"
+  width = 6
 }
 
 plot "orders" {
@@ -42,4 +78,12 @@ plot "orders" {
   x     = date
   y     = orders
   title = "Orders per day"
+  width = 6
+}
+
+// A click on a revenue bar narrows the cards and the daily orders to that
+// channel; the bar chart itself stays whole, so another bar can be picked.
+// Nothing picked, `$channel` is TRUE.
+filter "channel" {
+  plot = plot.revenue
 }
diff --git a/skills/ducklocal/SKILL.md b/skills/ducklocal/SKILL.md
index ee99bbf..614cb45 100644
--- a/skills/ducklocal/SKILL.md
+++ b/skills/ducklocal/SKILL.md
@@ -10,10 +10,10 @@ Use the real DuckLocal executable, not GUI automation or a replacement Python sc
 ## Workflow
 
 1. Check `ducklocal --help` and `ducklocal --version`. If not on PATH, check a user-provided binary or `/Applications/DuckLocal.app/Contents/MacOS/ducklocal`; a source checkout can use `./target/debug/ducklocal` after an authorized build. If DuckLocal is installed but the command is missing, the user can add it from the app: **Command line & AI… → Install command** (the robot button in the title bar, or the DuckLocal menu). If absent or too old, report that clearly and ask the caller to provide/install a compatible binary. Never pretend a query ran.
-2. Confirm input paths exist, then inspect schema with `ducklocal query --sql "DESCRIBE SELECT * FROM 'sales.csv'"`. Do not guess column names or types.
-3. Preview a bounded sample: `ducklocal query --sql "SELECT * FROM 'sales.csv'" --limit 20`. When the answer involves presenting a column rather than only computing one — a chart, an axis, a formatted number, a time series — run `ducklocal profile 'sales.csv'` as well: `missing_days` says whether the series is continuous, `max_over_median` whether a linear scale works, and `decimals` how many digits the number really has. A sample shows none of these.
+2. Confirm input paths exist, then inspect schema. `ducklocal schema ./data/` (files, folders, globs) or `ducklocal schema --database warehouse.duckdb` lists every relation with its columns in one call, and gives each a `from` — the SQL that reads it; a large catalog comes back as a summary, then `--table NAME` gives one relation whole. For a single file, `ducklocal query --sql "DESCRIBE SELECT * FROM 'sales.csv'"` works too. Do not guess column names or types.
+3. Preview a bounded sample: `ducklocal query --sql "SELECT * FROM 'sales.csv'" --limit 20`. When the answer involves presenting a column rather than only computing one — a chart, an axis, a formatted number, a time series — run `ducklocal schema 'sales.csv' --stats` as well: `missing_days` says whether the series is continuous, `max_over_median` whether a linear scale works, and `decimals` how many digits the number really has. A sample shows none of these.
 4. Write one SQL statement using observed names. Compute complete aggregates in SQL, not by adding up sample rows. Read [the CLI reference](references/cli.md) for options, encodings, escaping, database access, and conversion examples.
-5. Check the process exit code before parsing stdout. On success, parse the single JSON object and inspect `truncated`; `row_count` is only the returned row count. A truncated preview is not a complete result or a full-data statistic. When a person or a document will read the result, `--format md` prints the same values as a Markdown table (see the reference); JSON remains the form to parse.
+5. Check the process exit code before parsing stdout. An error's JSON may carry a `hint` — the next step in this CLI's terms (a flag to add, a command to run); act on it before rephrasing the SQL. On success, parse the single JSON object and inspect `truncated`; `row_count` is only the returned row count. A truncated preview is not a complete result or a full-data statistic. When a person or a document will read the result, `--format md` prints the same values as a Markdown table (see the reference); JSON remains the form to parse.
 6. Answer from actual returned values, naming the input, query, and relevant completeness limits. For conversions, query the output back to verify schema and counts/aggregates. Do not treat file existence alone as proof.
 
 To write or edit an analysis app (rather than only export one), see [Authoring an app](#authoring-an-app) below. For a dashboard of standard plots with no custom layout, a `.dash` spec is the simpler artifact — see [Authoring a dashboard spec](#authoring-a-dashboard-spec).
@@ -23,10 +23,14 @@ To write or edit an analysis app (rather than only export one), see [Authoring a
 A `.dash` file declares a dashboard as blocks — easier to write and diff than an app script, and validated without opening a window:
 
 ```hcl
+source "orders" {
+  path = "orders.csv"
+}
+
 query "revenue" {
   sql = <<SQL
     SELECT channel, sum(amount) AS total
-    FROM read_csv_auto('orders.csv')
+    FROM orders
     GROUP BY channel
     ORDER BY total DESC
   SQL
@@ -40,9 +44,9 @@ plot "revenue" {
 }
 ```
 
-A `query` block holds one `sql` attribute (one read-only statement — SELECT, WITH, FROM, VALUES, SHOW, DESCRIBE, SUMMARIZE or PIVOT — heredoc or string; DDL, DML, COPY, ATTACH and INSTALL are rejected). A `plot` block holds `type` (`line`, `bar`, `area`, `scatter`, `pie`, `map`, `table`), `query` (a `query.name` reference), `x` and `y` (result columns, bare identifiers or quoted strings; `y` optional for `table`), optional `series` and `title`. A `pie` takes `x` as its slices and `y` as their sizes, and no `series`; it folds past eight slices into "other". A `map` takes `lat` and `lng` (degrees) instead of `x`/`y`/`series` — either may be omitted when a numeric column's name says it, such as `geo_lat` or `longitude` — plus an optional `color` column, an optional numeric `size` column (points' area follows the value; `size_scale = "log"` for values spanning orders of magnitude) and an optional `tooltip` list of the columns to show on hover (default: the size column and other numbers, then the coordinates); for example `plot "stations" { type = "map" query = query.stations lat = geo_lat lng = geo_lng color = type size = passengers tooltip = [name, passengers] }`. No functions, conditionals, or interpolation exist. There is a working example at `examples/analysis_app/dashboard.dash`.
+A `source` block names data files for the queries: `source "orders" { path = "exports/orders-*.csv" }` — one `path`, a `.csv`/`.tsv`/`.parquet`/`.json` file or a glob of them, **relative to the `.dash` file** (not the working directory); queries then read `FROM orders`, and the source shadows any table of that name for those queries only (nothing is created on the connection). Prefer a source over a path inside the SQL, so the spec works from any directory. A `query` block holds one `sql` attribute (one read-only statement — SELECT, WITH, FROM, VALUES, SHOW, DESCRIBE, SUMMARIZE or PIVOT — heredoc or string; DDL, DML, COPY, ATTACH and INSTALL are rejected). A `plot` block holds `type` (`line`, `bar`, `area`, `scatter`, `pie`, `map`, `table`, `card`), `query` (a `query.name` reference), `x` and `y` (result columns, bare identifiers or quoted strings; `y` optional for `table`), optional `series` and `title`. A `pie` takes `x` as its slices and `y` as their sizes, and no `series`; it folds past eight slices into "other". A `map` takes `lat` and `lng` (degrees) instead of `x`/`y`/`series` — either may be omitted when a numeric column's name says it, such as `geo_lat` or `longitude` — plus an optional `color` column, an optional numeric `size` column (points' area follows the value; `size_scale = "log"` for values spanning orders of magnitude) and an optional `tooltip` list of the columns to show on hover (default: the size column and other numbers, then the coordinates); for example `plot "stations" { type = "map" query = query.stations lat = geo_lat lng = geo_lng color = type size = passengers tooltip = [name, passengers] }`. A `card` shows one value — its `value` column (default: the first) from the query's first row, integers grouped by thousands — with `title` as its label, and takes no `x`/`y`/`series`. Any plot takes `width`, 1–12 columns of the dashboard's grid (default 12, a card 3); plots fill a row left to right and wrap, so four cards then two `width = 6` charts make a KPI row over two side-by-side charts. A `filter` block makes a plot clickable: `filter "channel" { plot = plot.revenue }` picks the `x` of the bar clicked on a `bar` plot, and `filter "day" { plot = plot.days column = day }` picks a column's value from the row selected in a `table` plot (a table must name `column`). A query reads it as `$channel` — a predicate, so write it where a condition goes: `WHERE $channel AND $day`. It becomes `("channel" = 'Web')` once something is picked and `TRUE` while nothing is, so the dashboard opens unfiltered; the picking plot's own query is never narrowed by its own filter (cross-filtering), and a `$name` with no filter block is a `check` error. Picks show as chips above the plots; clicking the picked bar again, or a chip's ✕, clears it. No functions, conditionals, or other interpolation exist. There is a working example at `examples/analysis_app/dashboard.dash`.
 
-Always validate before handing a spec over: `ducklocal check dashboard.dash`, or `ducklocal check dashboard.dash --database warehouse.duckdb` to also run every query read-only and verify every `x`/`y`/`series`/`lat`/`lng`/`color`/`size`/`tooltip` column against the columns the queries actually return (a non-numeric `y` is an error outside `table`, and so is a non-numeric `lat`, `lng` or `size`). A spec mistake is exit 2 with kind `spec`, one `file:line: message` per diagnostic; a query that fails on the database is exit 1 with kind `sql`, one line per failing query — fix all of them, not just the first. Prefer the `--database` form whenever the database exists: without it nothing runs, so errors that appear only at execution (a cast the build cannot perform, a value that will not convert) go unseen. To see it rendered, open the file in the GUI (`ducklocal dashboard.dash` or drag it onto the window): it becomes a dashboard tab, a resizable vertical stack of the plots with per-plot inline errors.
+Always validate before handing a spec over: `ducklocal check dashboard.dash`, or `ducklocal check dashboard.dash --database warehouse.duckdb` to also run every query read-only and verify every `x`/`y`/`series`/`lat`/`lng`/`color`/`size`/`tooltip`/`value` column against the columns the queries actually return (a non-numeric `y` is an error outside `table`, and so is a non-numeric `lat`, `lng` or `size`). A spec mistake is exit 2 with kind `spec`, one `file:line: message` per diagnostic; a query that fails on the database is exit 1 with kind `sql`, one line per failing query — fix all of them, not just the first. Prefer the `--database` form whenever the database exists: without it nothing runs, so errors that appear only at execution (a cast the build cannot perform, a value that will not convert) go unseen. To see it rendered, open the file in the GUI (`ducklocal dashboard.dash` or drag it onto the window): it becomes a dashboard tab: rows of plots on the 12-column grid, each row's height resizable, with per-plot inline errors.
 
 ## Authoring an app
 
@@ -97,7 +101,9 @@ Export model (`ducklocal export --html APP`):
 - Do not automatically retry writes. A failed command may already have written data, including when output serialization fails. Inspect the result and destination first.
 - Do not save credentials, tokens, or secrets in SQL files, skill files, history, or project configuration. This skill has no credential store.
 - Each CLI invocation is a separate process/connection. GUI registered views and in-memory tables do not carry over. Use explicit `--database` for authorized persistent work; use separate single-statement invocations.
-- `ducklocal export --html` runs an analysis app once and writes its statements and results as one standalone HTML file. It is the only subcommand that starts the window platform (a hidden window, no visible UI). The report carries the app's data, not its interface or its interactive state.
+- `ducklocal export --html` runs an analysis app once and writes its statements and results as one standalone HTML file, in a hidden window with no visible UI.
+- `ducklocal open --state` reads what the running window shows — its database and attached files, each query tab's SQL and result (columns, row count, the first 20 rows, or the error), each dashboard's plots and filter picks. Run it before continuing work the person started in the GUI, instead of asking them to paste it. It opens nothing and never starts a window (exit 1, kind `not_running`, when none is up).
+- `ducklocal open` puts SQL, a `.dash` spec or data in front of the person, in the running window — starting one if none is. Use it when the user wants to see or continue the work in the GUI, not to get results: it returns delivery only, and the SQL runs in the window's session, not the CLI's. Pass `--no-launch` when a window appearing unasked would be unwelcome (for example on a headless machine). The report carries the app's data, not its interface or its interactive state.
 - No dedicated S3 browsing, spatial command suite, session memory, or MCP server is provided. Do not invent flags or claim these capabilities.
 
 ## Failures
diff --git a/skills/ducklocal/references/cli.md b/skills/ducklocal/references/cli.md
index ee96e38..802be1f 100644
--- a/skills/ducklocal/references/cli.md
+++ b/skills/ducklocal/references/cli.md
@@ -19,16 +19,27 @@ Use exactly one `--sql`/`--sql-file`. A file is UTF-8, `-` means stdin. Exactly
 
 `--limit N` is positive, defaults to 1000, and caps output rows. A 2,000,000-cell budget also applies. An extra row determines `truncated`; this is not a computation or memory limit. Paths resolve against the working directory. Quote shell paths and escape SQL apostrophes by doubling them: `'O''Brien.csv'`. Quote SQL identifiers with double quotes.
 
-Without `--database`, each call has a new in-memory database. `--database PATH` opens an existing file read-only. `--read-write` requires `--database` and authorizes database writes/creation at that path, not parent directory creation. Do not silently fall back to memory after open/lock errors. No GUI history/settings/registered views are read or changed. A GUI path named `query`, `profile`, `export`, `check` or `dash` must be written `./query`, `./profile`, `./export`, `./check`, `./dash`.
+Without `--database`, each call has a new in-memory database. `--database PATH` opens an existing file read-only. `--read-write` requires `--database` and authorizes database writes/creation at that path, not parent directory creation. Do not silently fall back to memory after open/lock errors. No GUI history/settings/registered views are read or changed. A GUI path named like a command (`query`, `schema`, `open`, `check`, `export`, and the hidden `profile`, `lsp`, `dash`) must be written with `./`, e.g. `./query`.
 
-## Profile a relation
+## Map what can be queried
 
 ```bash
-ducklocal profile sales.csv
-ducklocal profile "my orders" --database warehouse.duckdb
+ducklocal schema ./data/                         # files, folders, globs
+ducklocal schema --database warehouse.duckdb     # tables and views
+ducklocal schema warehouse.duckdb --table orders # one relation, whole
+ducklocal schema ./logs/ --full                  # everything, however large
 ```
 
-TARGET is a data file (`csv`/`tsv`/`txt`/`parquet`/`json`/`ndjson`/`jsonl`), a workbook (`xlsx`/`xls`/`xlsb`/`ods`; its first sheet is imported as a TEMP table and profiled), or, with `--database`, a table/view name; a dotted name is `schema.table` and each part is quoted. It takes no other options. A target that names nothing is an argument error (exit 2).
+One JSON object: `{detail, relations, without_columns, hint?}`. Each relation has `name`, `kind` (`file`, `table`, `view` or `workbook`), `from` — the SQL that reads it, ready to follow `FROM` (a quoted path for a file, a quoted identifier where needed) — `rows`, `column_count` and, unless summarized, `columns: [{name, type}]`. `rows` is the catalog's estimate for a table, exact for Parquet, and `null` where it would need a scan (CSV/JSON, views). Up to 12 relations and 400 columns, `detail` is `"full"`; past that it is `"summary"`: the 5 relations with the most rows keep their columns, the rest list name, kind, rows and column count, and `hint` says to use `--table NAME` or `--full`. PATHs expand like a drop on the GUI (folders recursively, hidden files skipped, at most 256 files); a PATH that is a database file is the same as `--database`. A workbook is listed with its `sheets` and no columns — `--stats` reads its first sheet. A missing PATH or an unknown `--table` is exit 2.
+
+## Column statistics
+
+```bash
+ducklocal schema sales.csv --stats
+ducklocal schema --database warehouse.duckdb --table "my orders" --stats
+```
+
+`--stats` profiles one relation: the only one the arguments name, or the one `--table` picks (two or more without `--table` is exit 2). The relation is a data file (`csv`/`tsv`/`txt`/`parquet`/`json`/`ndjson`/`jsonl`), a workbook (`xlsx`/`xls`/`xlsb`/`ods`; its first sheet is imported as a TEMP table and profiled), or, with `--database`, a table/view name; a dotted name is `schema.table` and each part is quoted. It cannot be combined with `--full`. `ducklocal profile TARGET [--database PATH]` is the older, deprecated spelling of the same report.
 
 One JSON object: `target`, `relation`, `row_count`, `elapsed_ms`, and `columns` in relation order. Per column `name`, `type`, `nulls`, `distinct`, `unique` (only when `distinct` equals `row_count`), `min`, `max` as text; numeric columns add `decimals` (the digits after the point actually used, not the declared scale), `median` (a value the column holds, never an interpolation) and `max_over_median`; DATE/TIMESTAMP columns add `covered_days`, `span_days` and `missing_days`. `LIST`/`STRUCT`/`MAP`/`UNION` columns report `nulls` only.
 
@@ -53,7 +64,26 @@ ducklocal check dashboard.dash
 ducklocal check dashboard.dash --database warehouse.duckdb
 ```
 
-Validates a `.dash` file — `query "name" { sql = <<SQL … SQL }` blocks and `plot "name" { type/query/x/y/series/title }` blocks joined by `query.name` references — without opening a window. Static checks (syntax, duplicate names, dangling references, SQL through the real parser — one read-only statement per query) need no database; `--database` (existing file, read-only) additionally describes each query and checks plot columns against what it returns, including a numeric-type check on `y`. Success prints one JSON object with the spec's queries and plots. A spec mistake is exit 2, kind `spec`, one `file:line: message` per diagnostic, all diagnostics at once; database/I/O failures are exit 1.
+Validates a `.dash` file — `query "name" { sql = <<SQL … SQL }` blocks and `plot "name" { type/query/x/y/series/title }` blocks joined by `query.name` references, plus `source` and `filter` blocks — without opening a window. A `$name` in a query's SQL must name a `filter` block and is checked (and, with `--database`, run) as `TRUE`, which is what the dashboard runs before anything is picked; with `--database` a filter's `column` must be one its plot's query returns. The output's `filters` list each filter's `plot`, `column` and the `queries` that read it. Static checks (syntax, duplicate names, dangling references, SQL through the real parser — one read-only statement per query) need no database; `--database` (existing file, read-only) additionally describes each query and checks plot columns against what it returns, including a numeric-type check on `y`. Success prints one JSON object with the spec's queries and plots. A spec mistake is exit 2, kind `spec`, one `file:line: message` per diagnostic, all diagnostics at once; database/I/O failures are exit 1.
+
+## Show work in the running window
+
+```bash
+ducklocal open --title "Revenue by channel" --run --sql "SELECT channel, sum(amount) AS total FROM 'orders.csv' GROUP BY 1"
+ducklocal open dashboard.dash
+ducklocal open ./data/ --sql-file analysis.sql
+echo "SELECT 42" | ducklocal open --sql-file - --no-launch
+```
+
+Sends one request to the DuckLocal window that is already running and brings it forward: PATHs open as a drop on the window would (a `.dash` or app folder as a tab, data files/folders/patterns attached), then `--sql`/`--sql-file` opens in a new query tab titled `--title`; `--run` runs it once the PATHs have attached. Relative PATHs resolve against the command's directory. With no window running it starts one (up to 30s) unless `--no-launch` is given. Success prints `{"delivered": true, "launched": BOOL}` — delivery, not the query's result: it runs in the window's session (its connection, attached views and history), and any error appears there, not on stdout. Exit 2 for arguments, 1 with kind `not_running` (no window reachable), `refused` (the endpoint rejected the request) or `launch`.
+
+## Read what the window shows
+
+```bash
+ducklocal open --state
+```
+
+Asks the running window — never starts one, and opens nothing — what it shows, as one JSON object: `database` (a path, or `":memory:"`), `attached` (`[{path, name, rows}]` for the files the window registered as views), `active_tab`, and `tabs`. A query tab has `sql` (the editor's text, run or not) and `result`: `status` (`empty`, `running`, `rows`, `affected`, `failed`, `explain`), and for rows `columns`, `row_count`, `truncated`, `preview` (the first 20 rows as the grid shows them, strings) and the `sql` that produced them; for a failure `error`. A dashboard tab has `path`, `unsaved`, and `dashboard`: `plots` (`name`, `type`, `query`, `rows`, `failure`) and `filters` (`name`, `plot`, `column`, `picked`, `value` — `null` with `picked: true` means the NULL value was picked). An app tab has `directory`. `--state` takes no other option or PATH (exit 2). Exit 1 with kind `not_running` when no window is up, `timeout` if it does not answer within 5s. The names in `attached` are the window's views; a CLI query cannot read them — use their `path`.
 
 ## Discover, aggregate, convert
 
@@ -117,7 +147,9 @@ Temporal values are counts, not text. When a person reads the output rather than
 Check exit status before parsing. Codes: 0 success, 2 arguments/statement count, 1 SQL/database/I/O/output error. Errors are one object on stderr with empty stdout:
 
 ```json
-{"error":{"kind":"sql","message":"..."}}
+{"error":{"kind":"sql","message":"...","hint":"..."}}
 ```
 
-Kinds: `argument`, `sql`, `database`, `io`, `output`, and `app` for an app export whose app failed. Help/version are plain text. A broken stdout pipe cannot guarantee a complete/empty stream. Errors may follow already-performed side effects; inspect before retrying. Never report a failed query as empty data or use truncated previews as complete statistics.
+`hint` is present when there is a known next step — a misspelled flag's likely meaning, `--read-write` for a write refused on a read-only database, `ducklocal schema` for a table that does not exist, `TRY_CAST` for a value that will not convert — and absent otherwise.
+
+Kinds: `argument`, `sql`, `database`, `io`, `output`, `app` for an app export whose app failed, `spec` for a `.dash` mistake, and `not_running`/`refused`/`timeout`/`launch` for `open`. Help/version are plain text. A broken stdout pipe cannot guarantee a complete/empty stream. Errors may follow already-performed side effects; inspect before retrying. Never report a failed query as empty data or use truncated previews as complete statistics.
diff --git a/src/app.rs b/src/app.rs
index 25c99bd..9b86077 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -183,8 +183,9 @@ impl DuckLocalApp {
         .detach();
 
         // Finder opens queue from the moment the platform callback is
-        // registered — possibly before this view exists — so drain on a slow
-        // poll and open them like a drop on the window. The task ends with
+        // registered — possibly before this view exists — and `ducklocal
+        // open` requests from the moment the listener starts, so drain both
+        // on a slow poll and open them like a drop on the window. The task ends with
         // the window: `update_in` fails once the view is gone.
         cx.spawn_in(window, async move |this, cx| {
             loop {
@@ -194,11 +195,25 @@ impl DuckLocalApp {
                         .lock()
                         .unwrap_or_else(PoisonError::into_inner),
                 );
-                if paths.is_empty() {
+                let requests = crate::remote::take_pending();
+                let state_wanted = crate::remote::state_wanted();
+                if paths.is_empty() && requests.is_empty() && !state_wanted {
                     continue;
                 }
                 if this
-                    .update_in(cx, |this, window, cx| this.open_external(paths, window, cx))
+                    .update_in(cx, |this, window, cx| {
+                        if !paths.is_empty() {
+                            this.open_external(paths, window, cx);
+                        }
+                        for request in requests {
+                            this.open_remote(request, window, cx);
+                        }
+                        // After the opens, so an `open` then a `state` sees
+                        // the tab the open made.
+                        if state_wanted {
+                            crate::remote::answer_state(this.snapshot(cx));
+                        }
+                    })
                     .is_err()
                 {
                     break;
@@ -236,6 +251,67 @@ impl DuckLocalApp {
         }
     }
 
+    /// A request from `ducklocal open`: its paths open like a drop, then its
+    /// SQL gets a tab of its own, in front, in a window brought forward — the
+    /// command's caller wants someone to see it.
+    fn open_remote(
+        &mut self,
+        request: crate::remote::Request,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        window.activate_window();
+        self.open_external(request.paths, window, cx);
+        let Some(sql) = request.sql else {
+            return;
+        };
+        self.workspace
+            .update(cx, |ws, cx| ws.open_query_tab(sql, request.title, window, cx));
+        if !request.run {
+            return;
+        }
+        // The SQL may name what the paths attach, and attaching is off the
+        // UI thread: run once no open request is in flight.
+        let state = self.state.clone();
+        cx.spawn_in(window, async move |this, cx| {
+            while cx
+                .update(|_, cx| state.read(cx).is_opening())
+                .unwrap_or(false)
+            {
+                smol::Timer::after(Duration::from_millis(50)).await;
+            }
+            this.update_in(cx, |this, window, cx| {
+                this.workspace
+                    .update(cx, |ws, cx| ws.run_active(window, cx));
+            })
+            .ok();
+        })
+        .detach();
+    }
+
+    /// What the window shows, for `ducklocal open --state`: the database, the files
+    /// attached to it, and the workspace's tabs.
+    fn snapshot(&self, cx: &App) -> serde_json::Value {
+        use serde_json::json;
+        let state = self.state.read(cx);
+        let mut snapshot = self.workspace.read(cx).snapshot(cx);
+        snapshot["database"] = match &state.target {
+            Some(crate::db::DatabaseTarget::File(path)) => json!(path),
+            Some(crate::db::DatabaseTarget::Memory) => json!(":memory:"),
+            None => serde_json::Value::Null,
+        };
+        snapshot["attached"] = json!(state
+            .attached_files
+            .iter()
+            .map(|file| json!({
+                "path": file.path,
+                "name": file.view_name,
+                "rows": file.row_count,
+            }))
+            .collect::<Vec<_>>());
+        snapshot
+    }
+
     fn drop_paths(&mut self, paths: &ExternalPaths, window: &mut Window, cx: &mut Context<Self>) {
         let requested: Vec<String> = paths
             .paths()
diff --git a/src/cli.rs b/src/cli.rs
index fe1d25d..954059a 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -12,10 +12,10 @@ DuckLocal — local data workspace and headless SQL
 Usage:
   ducklocal [PATH ...]          Open the GUI on files, folders or globs
   ducklocal query [OPTIONS]     Run one SQL statement, print JSON
-  ducklocal profile TARGET      Per-column statistics, JSON
-  ducklocal export --html APP   Export an analysis app as standalone HTML
+  ducklocal schema [PATH ...]   Relations and columns; --stats per column
+  ducklocal open [OPTIONS]      Show work in the running window; --state reads it
   ducklocal check FILE          Validate a .dash dashboard spec
-  ducklocal lsp                 Language server for .dash files (stdio)
+  ducklocal export --html APP   Export an analysis app as standalone HTML
   ducklocal --version
 
 Run `ducklocal <command> --help` for its options.
@@ -43,6 +43,8 @@ arguments, 1 for SQL or I/O. Read-only is not a sandbox: COPY can write files.
 pub(crate) const PROFILE_HELP: &str = "\
 Usage: ducklocal profile TARGET [--database PATH]
 
+Deprecated: the same as `ducklocal schema TARGET --stats`.
+
 Exact per-column statistics as JSON: type, nulls, distinct, min and max, plus
 median and decimals for numbers and day coverage for dates.
 
@@ -72,6 +74,9 @@ each query with DuckDB's parser. Nothing runs unless --database is given; then
 every query runs read-only and plot columns are checked against the results.
 
 Exit 2 for spec mistakes, 1 for database or I/O failures.
+
+For editors, `ducklocal lsp [--database PATH]` serves the same diagnostics,
+with completion, hover and go-to-definition, over stdio.
 ";
 
 pub(crate) const LSP_HELP: &str = "\
@@ -87,6 +92,11 @@ pub(crate) struct CliError {
     pub(crate) kind: &'static str,
     pub(crate) message: String,
     pub(crate) code: i32,
+    /// What to do about it, when that is known: the next command to run or
+    /// the flag to add. An agent reading the error acts on this line rather
+    /// than guessing from DuckDB's message; `dispatch` fills it in from
+    /// [`hint_for`] when the error site did not.
+    pub(crate) hint: Option<String>,
 }
 
 impl CliError {
@@ -107,6 +117,7 @@ impl CliError {
             kind: "argument",
             message: message.into(),
             code: 2,
+            hint: None,
         }
     }
 
@@ -115,8 +126,86 @@ impl CliError {
             kind,
             message: error.to_string(),
             code: 1,
+            hint: None,
         }
     }
+
+    pub(crate) fn with_hint(mut self, hint: impl Into<String>) -> Self {
+        self.hint = Some(hint.into());
+        self
+    }
+}
+
+/// The next step for an error whose site gave none, read off its message.
+///
+/// DuckDB's messages say what went wrong; these say what to run next, in this
+/// CLI's own terms — which flag, which command. Only the mistakes an agent
+/// actually makes are here, and each hint is a thing to do, never a restating
+/// of the message.
+pub(crate) fn hint_for(kind: &str, message: &str) -> Option<&'static str> {
+    let has = |needle: &str| message.contains(needle);
+    if kind == "sql" || kind == "database" {
+        if has("read-only mode") || has("read-only database") {
+            return Some("File databases open read-only; add --read-write to allow writes");
+        }
+        if has("Table with name") && has("does not exist") {
+            return Some(
+                "List what exists with `ducklocal schema` (with --database PATH for a database \
+                 file); read a data file by quoting its path: FROM 'data.csv'",
+            );
+        }
+        if has("Referenced column") || has("Candidate bindings") {
+            return Some(
+                "See a relation's columns with `ducklocal schema PATH` or DESCRIBE; double-quote \
+                 names with spaces or capitals",
+            );
+        }
+        if has("No files found") {
+            return Some(
+                "Relative paths resolve against the current directory; check the name, or use an \
+                 absolute path",
+            );
+        }
+        if has("Could not convert") || has("Conversion Error") {
+            return Some(
+                "TRY_CAST(expr AS type) turns values that do not convert into NULL; \
+                 `ducklocal schema PATH --stats` shows what the column holds",
+            );
+        }
+    }
+    if kind == "argument" && has("Expected exactly one SQL statement") {
+        return Some(
+            "Run one statement per call: chain steps with WITH … AS (…), or make separate calls",
+        );
+    }
+    None
+}
+
+/// The known flag an unknown one was most likely meant to be: one or two
+/// edits away, or the same name with a different number of dashes.
+fn closest_flag<'a>(text: &str, spec: &'a [FlagSpec]) -> Option<&'a str> {
+    let bare = text.trim_start_matches('-');
+    spec.iter()
+        .map(|flag| (flag.name, edit_distance(bare, flag.name.trim_start_matches('-'))))
+        .filter(|(_, distance)| *distance <= 2)
+        .min_by_key(|(_, distance)| *distance)
+        .map(|(name, _)| name)
+}
+
+/// Levenshtein distance, over chars; flag names are short.
+fn edit_distance(a: &str, b: &str) -> usize {
+    let b: Vec<char> = b.chars().collect();
+    let mut row: Vec<usize> = (0..=b.len()).collect();
+    for (i, ca) in a.chars().enumerate() {
+        let mut previous = row[0];
+        row[0] = i + 1;
+        for (j, cb) in b.iter().enumerate() {
+            let substitute = previous + usize::from(ca != *cb);
+            previous = row[j + 1];
+            row[j + 1] = substitute.min(row[j] + 1).min(previous + 1);
+        }
+    }
+    row[b.len()]
 }
 
 /// One flag a command accepts: its name and whether it takes a value.
@@ -158,7 +247,11 @@ pub(crate) fn parse_args(
             continue;
         }
         let Some(flag) = spec.iter().find(|flag| flag.name == text) else {
-            return Err(CliError::argument(format!("Unknown {command} option: {text}")));
+            let error = CliError::argument(format!("Unknown {command} option: {text}"));
+            return Err(match closest_flag(text, spec) {
+                Some(name) => error.with_hint(format!("Did you mean {name}?")),
+                None => error.with_hint(format!("See ducklocal {command} --help")),
+            });
         };
         if !seen.insert(flag.name) {
             return Err(CliError::argument(format!("Duplicate option: {}", flag.name)));
@@ -468,7 +561,8 @@ pub(crate) fn open(database: Option<PathBuf>, read_write: bool) -> Result<Connec
     .map_err(|e| CliError::failure("database", e))
 }
 
-/// `ducklocal profile TARGET [--database PATH]`.
+/// `ducklocal profile TARGET [--database PATH]`: the deprecated spelling of
+/// `schema TARGET --stats`, kept so released scripts keep working.
 ///
 /// One positional argument, because the thing being profiled is the whole
 /// request; `--database` only says where to look for a name.
@@ -502,6 +596,12 @@ fn profile(args: &[OsString]) -> Result<String, CliError> {
             }
         }
     }
+    profile_target(target, database)
+}
+
+/// Exact per-column statistics of one relation: a data file, a workbook's
+/// first sheet, or — with a database — a table or view name.
+pub(crate) fn profile_target(target: &str, database: Option<PathBuf>) -> Result<String, CliError> {
     let conn = open(database, false)?;
     // A target that names nothing is a mistake in the arguments, and reporting
     // it as a SQL failure would send a caller looking at their data instead of
@@ -519,7 +619,16 @@ pub fn dispatch(args: &[OsString]) -> Option<i32> {
     let first = args.first()?.to_str()?;
     if !matches!(
         first,
-        "query" | "profile" | "export" | "check" | "dash" | "lsp" | "--help" | "--version"
+        "query"
+            | "schema"
+            | "profile"
+            | "open"
+            | "export"
+            | "check"
+            | "dash"
+            | "lsp"
+            | "--help"
+            | "--version"
     ) && !first.starts_with("--")
     {
         return None;
@@ -535,8 +644,12 @@ pub fn dispatch(args: &[OsString]) -> Option<i32> {
         ("--version", 1) => Ok(format!("ducklocal {}", env!("CARGO_PKG_VERSION"))),
         ("query", 2) if args[1] == "--help" => Ok(QUERY_HELP.to_string()),
         ("query", _) => query(&args[1..]),
+        ("schema", 2) if args[1] == "--help" => Ok(crate::schema_cli::SCHEMA_HELP.to_string()),
+        ("schema", _) => crate::schema_cli::run(&args[1..]),
         ("profile", 2) if args[1] == "--help" => Ok(PROFILE_HELP.to_string()),
         ("profile", _) => profile(&args[1..]),
+        ("open", 2) if args[1] == "--help" => Ok(crate::remote::OPEN_HELP.to_string()),
+        ("open", _) => crate::remote::open(&args[1..]),
         ("export", _) => crate::app_export::dispatch(&args[1..]),
         ("check", 2) if args[1] == "--help" => Ok(CHECK_HELP.to_string()),
         ("check", _) => crate::spec::check(&args[1..]),
@@ -560,12 +673,43 @@ pub fn dispatch(args: &[OsString]) -> Option<i32> {
     Some(match result {
         Ok(()) => 0,
         Err(error) => {
-            let _ = writeln!(
-                std::io::stderr().lock(),
-                "{}",
-                json!({"error": {"kind": error.kind, "message": error.message}})
-            );
+            let hint = error
+                .hint
+                .clone()
+                .or_else(|| hint_for(error.kind, &error.message).map(str::to_string));
+            let mut body = json!({"kind": error.kind, "message": error.message});
+            if let Some(hint) = hint {
+                body["hint"] = json!(hint);
+            }
+            let _ = writeln!(std::io::stderr().lock(), "{}", json!({"error": body}));
             error.code
         }
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_misspelled_flag_is_matched_to_the_one_meant() {
+        assert_eq!(closest_flag("--limt", QUERY_SPEC), Some("--limit"));
+        assert_eq!(closest_flag("-sql", QUERY_SPEC), Some("--sql"));
+        assert_eq!(closest_flag("--databse", QUERY_SPEC), Some("--database"));
+        assert_eq!(closest_flag("--everything", QUERY_SPEC), None);
+        assert_eq!(edit_distance("kitten", "sitting"), 3);
+    }
+
+    #[test]
+    fn hints_follow_the_message_and_the_kind() {
+        let read_only = "Invalid Input Error: Cannot execute statement of type \"DROP\" on database \"w\" which is attached in read-only mode!";
+        assert!(hint_for("sql", read_only).unwrap().contains("--read-write"));
+        assert!(hint_for("sql", "Catalog Error: Table with name x does not exist!")
+            .unwrap()
+            .contains("ducklocal schema"));
+        assert!(hint_for("argument", "Expected exactly one SQL statement; found 2").is_some());
+        // A kind the hint is not about gets none.
+        assert!(hint_for("io", "Table with name x does not exist").is_none());
+        assert!(hint_for("sql", "Parser Error: syntax error at or near \"x\"").is_none());
+    }
+}
diff --git a/src/i18n.rs b/src/i18n.rs
index a7ba40d..e338a44 100644
--- a/src/i18n.rs
+++ b/src/i18n.rs
@@ -755,6 +755,16 @@ static STRINGS: &[(&str, &str, &str)] = &[
         "地图需要经纬度列：请用 lat 和 lng 指定。查询返回的列：{}",
         "A map needs coordinate columns: name them with lat and lng. The query returns: {}",
     ),
+    (
+        "dashboard.card.first_row",
+        "显示的是 {} 行中的第一行",
+        "Showing the first of {} rows",
+    ),
+    (
+        "dashboard.card.no_rows",
+        "查询没有返回行",
+        "The query returned no rows",
+    ),
     (
         "dashboard.empty",
         "这个 spec 没有声明任何 plot 块。",
@@ -790,6 +800,14 @@ static STRINGS: &[(&str, &str, &str)] = &[
         "文件在磁盘上已被修改",
         "The file changed on disk",
     ),
+    ("dashboard.filter.label", "筛选", "Filtered by"),
+    ("dashboard.filter.clear", "清除此筛选", "Clear this filter"),
+    ("dashboard.filter.clear_all", "全部清除", "Clear all"),
+    (
+        "dashboard.filter.hint",
+        "点击可筛选其他图表",
+        "Click to filter the other plots",
+    ),
     (
         "dashboard.conflict.hint",
         "你的修改尚未保存；保存会覆盖磁盘上的改动。",
diff --git a/src/main.rs b/src/main.rs
index 535c7f1..747347c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,8 +12,10 @@ mod perf_probe;
 mod profile;
 mod query;
 mod recents;
+mod remote;
 mod s3;
 mod schema;
+mod schema_cli;
 mod script;
 mod setup;
 mod sources;
@@ -74,6 +76,8 @@ fn main() {
             // The interface size is the rem base; it must be re-applied after
             // every Theme::change, which resets the theme to stock defaults.
             ui::scale::apply(cx);
+            // `ducklocal open` reaches this window from here on.
+            remote::serve();
 
             let window_bounds = Bounds::centered(None, size(px(1440.), px(900.)), cx);
             let options = WindowOptions {
diff --git a/src/remote.rs b/src/remote.rs
new file mode 100644
index 0000000..7fdd4ed
--- /dev/null
+++ b/src/remote.rs
@@ -0,0 +1,676 @@
+//! `ducklocal open`: hand the window that is already running something to
+//! show — SQL in a new query tab, a `.dash` spec, an app folder, data files.
+//!
+//! The window listens on a loopback port and writes the port, with a random
+//! token, to an endpoint file in the app data directory that only this user
+//! can read. The command reads that file, connects, and sends one JSON line;
+//! the window queues the request for the root view to open (app.rs), the way
+//! Finder's opens are queued. Loopback TCP rather than a Unix socket so the
+//! three platforms share one path; the token is what keeps another user on
+//! the machine, or a web page aiming requests at localhost, out.
+//!
+//! What opens runs in the window's session — its connection, its attached
+//! data, its history — which is the point: an agent's work lands where a
+//! person can see it and carry on.
+//!
+//! `ducklocal open --state` is the other direction on the same channel: what the
+//! window shows now — its tabs, each query's SQL and result, each
+//! dashboard's picks — so an agent can pick up where the person left off.
+//! The listener thread cannot read the UI, so it parks the question with a
+//! channel to answer on, and the window's poll (app.rs) answers it from the
+//! UI thread.
+
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::{Ipv4Addr, SocketAddr, TcpListener, TcpStream};
+use std::path::{Path, PathBuf};
+use std::sync::mpsc;
+use std::sync::{Mutex, PoisonError};
+use std::time::{Duration, Instant};
+
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+
+use crate::cli::{parse_args, Arg, CliError, FlagSpec};
+
+pub(crate) const OPEN_HELP: &str = "\
+Usage: ducklocal open [OPTIONS] [PATH ...]
+
+Show something in the DuckLocal window that is already running, starting one
+if none is: SQL in a new query tab, and PATHs opened the way a drop on the
+window opens them — a .dash spec or an app folder as a tab, data files,
+folders and patterns attached.
+
+Options:
+  --sql SQL          SQL for a new query tab
+  --sql-file FILE    UTF-8 SQL file; - reads stdin
+  --title TITLE      The new query tab's title
+  --run              Run the SQL once the tab is open and PATHs are attached
+  --no-launch        Fail with kind not_running instead of starting a window
+  --state            Open nothing: print what the window shows (see below)
+
+Output: {delivered, launched}. The window opens the request in its own
+session — its connection, attached data and history, not this command's —
+and reports its own errors there. Exit 2 for arguments, 1 when no window can
+be reached.
+
+With --state, nothing opens and no window starts: the output is what the
+running window shows — {database, attached, active_tab, tabs}: each query
+tab's SQL and result (columns, row count, the first 20 rows, or the error),
+each dashboard's plots and the values its filters have picked, each app's
+folder. Exit 1 with kind not_running when no window is up, timeout when it
+does not answer within 5s. It takes no other option or PATH.
+";
+
+const OPEN_SPEC: &[FlagSpec] = &[
+    FlagSpec {
+        name: "--sql",
+        takes_value: true,
+    },
+    FlagSpec {
+        name: "--sql-file",
+        takes_value: true,
+    },
+    FlagSpec {
+        name: "--title",
+        takes_value: true,
+    },
+    FlagSpec {
+        name: "--run",
+        takes_value: false,
+    },
+    FlagSpec {
+        name: "--no-launch",
+        takes_value: false,
+    },
+    FlagSpec {
+        name: "--state",
+        takes_value: false,
+    },
+];
+
+/// The endpoint file, next to the history store.
+const ENDPOINT_FILE: &str = "gui-endpoint.json";
+
+/// The first rows a query tab's state carries: enough to see what the person
+/// is looking at, not a copy of the result.
+pub(crate) const STATE_PREVIEW_ROWS: usize = 20;
+
+/// How long the listener waits for the window to answer a state request.
+const STATE_TIMEOUT: Duration = Duration::from_secs(5);
+
+/// Largest request line the window reads: SQL files are small, and a line
+/// with no end should not grow without bound.
+const MAX_REQUEST_BYTES: u64 = 16 * 1024 * 1024;
+
+/// How long a started window gets to begin listening.
+const LAUNCH_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Where a running window can be reached.
+#[derive(Debug, Serialize, Deserialize)]
+struct Endpoint {
+    port: u16,
+    token: String,
+    pid: u32,
+}
+
+/// What the window is asked to open. Paths are absolute: the window's
+/// working directory is not the command's.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub(crate) struct Request {
+    #[serde(default)]
+    pub paths: Vec<String>,
+    #[serde(default)]
+    pub sql: Option<String>,
+    #[serde(default)]
+    pub title: Option<String>,
+    #[serde(default)]
+    pub run: bool,
+}
+
+#[derive(Serialize, Deserialize)]
+struct Envelope {
+    token: String,
+    /// Something to open; absent when the envelope asks for the state.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    request: Option<Request>,
+    /// Ask what the window shows instead of opening anything.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    state: bool,
+}
+
+/// What an accepted envelope asks for.
+enum Incoming {
+    Open(Request),
+    State,
+}
+
+/// Requests the listener accepted, for the root view to drain.
+static PENDING: Mutex<Vec<Request>> = Mutex::new(Vec::new());
+
+/// Take every request accepted since the last call.
+pub(crate) fn take_pending() -> Vec<Request> {
+    std::mem::take(&mut *PENDING.lock().unwrap_or_else(PoisonError::into_inner))
+}
+
+/// State requests waiting for the window, each with where to send it.
+static STATE_WAITERS: Mutex<Vec<mpsc::Sender<Value>>> = Mutex::new(Vec::new());
+
+/// Whether a `ducklocal open --state` is waiting for the window to answer.
+pub(crate) fn state_wanted() -> bool {
+    !STATE_WAITERS
+        .lock()
+        .unwrap_or_else(PoisonError::into_inner)
+        .is_empty()
+}
+
+/// Answer every waiting state request with `state`.
+pub(crate) fn answer_state(state: Value) {
+    let waiters =
+        std::mem::take(&mut *STATE_WAITERS.lock().unwrap_or_else(PoisonError::into_inner));
+    for waiter in waiters {
+        // A caller that gave up has dropped its receiver; nothing to do.
+        let _ = waiter.send(state.clone());
+    }
+}
+
+/// Park a state request for the window's poll and wait for its answer.
+fn ask_window_for_state() -> Result<Value, String> {
+    let (sender, receiver) = mpsc::channel();
+    STATE_WAITERS
+        .lock()
+        .unwrap_or_else(PoisonError::into_inner)
+        .push(sender);
+    receiver
+        .recv_timeout(STATE_TIMEOUT)
+        .map_err(|_| "the window did not answer within 5s".to_string())
+}
+
+fn data_dir() -> Option<PathBuf> {
+    directories::ProjectDirs::from("", "", "DuckLocal").map(|dirs| dirs.data_dir().to_path_buf())
+}
+
+/// Start listening for `ducklocal open`, on a thread of its own. A window
+/// that cannot listen still works; the command then says none is running.
+pub(crate) fn serve() {
+    let Some(dir) = data_dir() else {
+        tracing::warn!("no app data directory; `ducklocal open` cannot reach this window");
+        return;
+    };
+    match listen(&dir) {
+        Ok(listener) => {
+            std::thread::Builder::new()
+                .name("ducklocal-open".into())
+                .spawn(move || {
+                    accept_loop(
+                        listener,
+                        |request| {
+                            PENDING
+                                .lock()
+                                .unwrap_or_else(PoisonError::into_inner)
+                                .push(request);
+                        },
+                        ask_window_for_state,
+                    )
+                })
+                .ok();
+        }
+        Err(error) => tracing::warn!("`ducklocal open` listener not started: {error:#}"),
+    }
+}
+
+/// Bind a loopback port and publish it, with a fresh token, in `dir`.
+fn listen(dir: &Path) -> anyhow::Result<(TcpListener, String)> {
+    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0))?;
+    let mut bytes = [0u8; 32];
+    getrandom::fill(&mut bytes).map_err(|e| anyhow::anyhow!("no randomness for a token: {e}"))?;
+    let token: String = bytes.iter().map(|byte| format!("{byte:02x}")).collect();
+    let endpoint = Endpoint {
+        port: listener.local_addr()?.port(),
+        token: token.clone(),
+        pid: std::process::id(),
+    };
+    std::fs::create_dir_all(dir)?;
+    // Written whole and renamed into place, so a command never reads half an
+    // endpoint; created owner-only, so the token is this user's alone.
+    let temporary = dir.join(format!("{ENDPOINT_FILE}.{}", std::process::id()));
+    let mut options = std::fs::OpenOptions::new();
+    options.write(true).create(true).truncate(true);
+    #[cfg(unix)]
+    std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
+    let mut file = options.open(&temporary)?;
+    file.write_all(serde_json::to_string(&endpoint)?.as_bytes())?;
+    file.sync_all()?;
+    drop(file);
+    std::fs::rename(&temporary, dir.join(ENDPOINT_FILE))?;
+    Ok((listener, token))
+}
+
+fn accept_loop(
+    (listener, token): (TcpListener, String),
+    accept: impl Fn(Request),
+    state: impl Fn() -> Result<Value, String>,
+) {
+    for stream in listener.incoming() {
+        let Ok(stream) = stream else { continue };
+        // One connection at a time is plenty for a command a person or an
+        // agent runs; the timeouts keep a stalled one from holding the rest.
+        let reply = match receive(&stream, &token) {
+            Ok(Incoming::Open(request)) => {
+                accept(request);
+                json!({"ok": true})
+            }
+            Ok(Incoming::State) => match state() {
+                Ok(state) => json!({"ok": true, "state": state}),
+                Err(message) => json!({"error": message, "kind": "timeout"}),
+            },
+            Err(message) => json!({"error": message}),
+        };
+        let mut stream = stream;
+        let _ = writeln!(stream, "{reply}").and_then(|_| stream.flush());
+    }
+}
+
+fn receive(stream: &TcpStream, token: &str) -> Result<Incoming, String> {
+    let _ = stream.set_read_timeout(Some(Duration::from_secs(5)));
+    let _ = stream.set_write_timeout(Some(Duration::from_secs(5)));
+    let mut line = String::new();
+    BufReader::new(stream.take(MAX_REQUEST_BYTES))
+        .read_line(&mut line)
+        .map_err(|e| format!("reading the request: {e}"))?;
+    let envelope: Envelope =
+        serde_json::from_str(&line).map_err(|e| format!("malformed request: {e}"))?;
+    if envelope.token != token {
+        return Err("wrong token".into());
+    }
+    match (envelope.state, envelope.request) {
+        (true, None) => Ok(Incoming::State),
+        (false, Some(request)) => Ok(Incoming::Open(request)),
+        _ => Err("malformed request: ask for the state or send something to open".into()),
+    }
+}
+
+/// Why a request did not reach a window.
+#[derive(Debug)]
+enum Unreachable {
+    /// No endpoint, or nothing listening at it: no window is running.
+    NotRunning,
+    /// Something answered and refused, or spoke another protocol.
+    Refused(String),
+    /// The window took the request but did not answer in time.
+    Timeout(String),
+}
+
+/// Send `request` to the window whose endpoint is in `dir`.
+fn deliver(dir: &Path, request: &Request) -> Result<(), Unreachable> {
+    exchange(dir, Some(request.clone()), false).map(|_| ())
+}
+
+/// Ask the window whose endpoint is in `dir` what it shows.
+fn fetch_state(dir: &Path) -> Result<Value, Unreachable> {
+    let mut reply = exchange(dir, None, true)?;
+    reply
+        .get_mut("state")
+        .map(Value::take)
+        .ok_or_else(|| Unreachable::Refused("the window answered without its state".into()))
+}
+
+/// One envelope out, one reply line back.
+fn exchange(dir: &Path, request: Option<Request>, state: bool) -> Result<Value, Unreachable> {
+    let text =
+        std::fs::read_to_string(dir.join(ENDPOINT_FILE)).map_err(|_| Unreachable::NotRunning)?;
+    let endpoint: Endpoint = serde_json::from_str(&text).map_err(|_| Unreachable::NotRunning)?;
+    let address = SocketAddr::from((Ipv4Addr::LOCALHOST, endpoint.port));
+    // A window that quit leaves its endpoint behind; a refused connection is
+    // how that reads, and it means the same as no file at all.
+    let mut stream = TcpStream::connect_timeout(&address, Duration::from_secs(2))
+        .map_err(|_| Unreachable::NotRunning)?;
+    let _ = stream.set_read_timeout(Some(Duration::from_secs(10)));
+    let envelope = Envelope {
+        token: endpoint.token,
+        request,
+        state,
+    };
+    let line = serde_json::to_string(&envelope).map_err(|e| Unreachable::Refused(e.to_string()))?;
+    writeln!(stream, "{line}")
+        .and_then(|_| stream.flush())
+        .map_err(|e| Unreachable::Refused(e.to_string()))?;
+    let mut reply = String::new();
+    BufReader::new(&stream)
+        .read_line(&mut reply)
+        .map_err(|e| Unreachable::Refused(e.to_string()))?;
+    let reply: serde_json::Value = serde_json::from_str(&reply).map_err(|_| {
+        Unreachable::Refused("the port answered with something other than DuckLocal".into())
+    })?;
+    match reply.get("error").and_then(|e| e.as_str()) {
+        Some(message) if reply.get("kind") == Some(&json!("timeout")) => {
+            Err(Unreachable::Timeout(message.to_string()))
+        }
+        Some(message) => Err(Unreachable::Refused(message.to_string())),
+        None if reply.get("ok") == Some(&json!(true)) => Ok(reply),
+        None => Err(Unreachable::Refused("unexpected reply".into())),
+    }
+}
+
+/// `ducklocal open --state`: what the running window shows. Never starts
+/// one — a fresh window has nothing to report.
+fn read_state(dir: &Path) -> Result<String, CliError> {
+    match fetch_state(dir) {
+        Ok(state) => Ok(state.to_string()),
+        Err(Unreachable::NotRunning) => Err(CliError::failure(
+            "not_running",
+            "No DuckLocal window is running",
+        )
+        .with_hint("Start one with `ducklocal open PATH` or `ducklocal PATH`")),
+        Err(Unreachable::Timeout(message)) => Err(CliError::failure("timeout", message)),
+        Err(Unreachable::Refused(message)) => Err(CliError::failure("refused", message)),
+    }
+}
+
+/// `ducklocal open`.
+pub(crate) fn open(args: &[std::ffi::OsString]) -> Result<String, CliError> {
+    let mut request = Request {
+        paths: Vec::new(),
+        sql: None,
+        title: None,
+        run: false,
+    };
+    let mut sql_file: Option<PathBuf> = None;
+    let mut launch = true;
+    let mut state = false;
+    let cwd = std::env::current_dir().map_err(|e| CliError::failure("io", e))?;
+    for arg in parse_args("open", args, OPEN_SPEC, &["--sql", "--title"])? {
+        match arg {
+            Arg::Flag("--sql", Some(value)) => {
+                request.sql = Some(utf8(value, "SQL")?);
+            }
+            Arg::Flag("--sql-file", Some(value)) => sql_file = Some(value.into()),
+            Arg::Flag("--title", Some(value)) => {
+                request.title = Some(utf8(value, "--title")?);
+            }
+            Arg::Flag("--run", None) => request.run = true,
+            Arg::Flag("--no-launch", None) => launch = false,
+            Arg::Flag("--state", None) => state = true,
+            Arg::Positional(value) => {
+                // Joined rather than canonicalized: a pattern or a path that
+                // does not exist is the window's to report, and a pattern
+                // has no canonical form.
+                let path = cwd.join(PathBuf::from(value));
+                request.paths.push(path.to_string_lossy().into_owned());
+            }
+            _ => {
+                return Err(CliError::failure(
+                    "internal",
+                    "open accepted a flag it does not handle",
+                ))
+            }
+        }
+    }
+    if state {
+        if args.len() > 1 {
+            return Err(CliError::argument(
+                "--state reads the window and opens nothing; it takes no other option or PATH",
+            ));
+        }
+        let dir = data_dir().ok_or_else(|| {
+            CliError::failure("not_running", "Cannot resolve the app data directory")
+        })?;
+        return read_state(&dir);
+    }
+    if request.sql.is_some() && sql_file.is_some() {
+        return Err(CliError::argument("Use --sql or --sql-file, not both"));
+    }
+    if let Some(path) = sql_file {
+        let sql = if path.as_os_str() == "-" {
+            let mut sql = String::new();
+            std::io::stdin()
+                .read_to_string(&mut sql)
+                .map_err(|e| CliError::failure("io", e))?;
+            sql
+        } else {
+            std::fs::read_to_string(&path).map_err(|e| CliError::failure("io", e))?
+        };
+        request.sql = Some(sql);
+    }
+    if request
+        .sql
+        .as_deref()
+        .is_some_and(|sql| sql.trim().is_empty())
+    {
+        return Err(CliError::argument("The SQL is empty"));
+    }
+    if request.sql.is_none() && (request.title.is_some() || request.run) {
+        return Err(CliError::argument(
+            "--title and --run need --sql or --sql-file",
+        ));
+    }
+    if request.sql.is_none() && request.paths.is_empty() {
+        return Err(CliError::argument(
+            "Nothing to open: give --sql, --sql-file or a PATH",
+        ));
+    }
+
+    let dir = data_dir()
+        .ok_or_else(|| CliError::failure("not_running", "Cannot resolve the app data directory"))?;
+    let launched = match deliver(&dir, &request) {
+        Ok(()) => false,
+        Err(Unreachable::Refused(message) | Unreachable::Timeout(message)) => {
+            return Err(CliError::failure("refused", message));
+        }
+        Err(Unreachable::NotRunning) if !launch => {
+            return Err(CliError::failure(
+                "not_running",
+                "No DuckLocal window is running; omit --no-launch to start one",
+            ));
+        }
+        Err(Unreachable::NotRunning) => {
+            start_window()?;
+            wait_and_deliver(&dir, &request)?;
+            true
+        }
+    };
+    Ok(json!({"delivered": true, "launched": launched}).to_string())
+}
+
+fn utf8(value: std::ffi::OsString, what: &str) -> Result<String, CliError> {
+    value
+        .into_string()
+        .map_err(|_| CliError::argument(format!("{what} must be UTF-8")))
+}
+
+/// Start the GUI detached from this command, so it outlives the terminal.
+/// Inside a macOS bundle, through LaunchServices, which gives it the Dock
+/// icon and menu bar a double-click would.
+fn start_window() -> Result<(), CliError> {
+    let exe = std::env::current_exe().map_err(|e| CliError::failure("launch", e))?;
+    let mut command = match bundle_of(&exe) {
+        Some(bundle) => {
+            let mut command = std::process::Command::new("open");
+            command.arg("-a").arg(bundle);
+            command
+        }
+        None => std::process::Command::new(&exe),
+    };
+    command
+        .stdin(std::process::Stdio::null())
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null());
+    #[cfg(unix)]
+    std::os::unix::process::CommandExt::process_group(&mut command, 0);
+    command
+        .spawn()
+        .map_err(|e| CliError::failure("launch", format!("Could not start DuckLocal: {e}")))?;
+    Ok(())
+}
+
+/// The `.app` an executable sits in, when it is the bundle's own binary.
+fn bundle_of(exe: &Path) -> Option<PathBuf> {
+    if !cfg!(target_os = "macos") {
+        return None;
+    }
+    let macos = exe.parent()?;
+    let contents = macos.parent()?;
+    let bundle = contents.parent()?;
+    (macos.file_name()? == "MacOS"
+        && contents.file_name()? == "Contents"
+        && bundle.extension()? == "app")
+        .then(|| bundle.to_path_buf())
+}
+
+fn wait_and_deliver(dir: &Path, request: &Request) -> Result<(), CliError> {
+    let deadline = Instant::now() + LAUNCH_TIMEOUT;
+    loop {
+        match deliver(dir, request) {
+            Ok(()) => return Ok(()),
+            Err(Unreachable::Refused(message) | Unreachable::Timeout(message)) => {
+                return Err(CliError::failure("refused", message))
+            }
+            Err(Unreachable::NotRunning) if Instant::now() < deadline => {
+                std::thread::sleep(Duration::from_millis(200));
+            }
+            Err(Unreachable::NotRunning) => {
+                return Err(CliError::failure(
+                    "not_running",
+                    "Started DuckLocal, but its window did not begin listening within 30s",
+                ))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::mpsc;
+
+    fn scratch(name: &str) -> PathBuf {
+        let dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("target/remote-tests")
+            .join(format!("{name}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        dir
+    }
+
+    fn request() -> Request {
+        Request {
+            paths: vec!["/tmp/a.csv".into()],
+            sql: Some("SELECT 1".into()),
+            title: Some("Agent".into()),
+            run: true,
+        }
+    }
+
+    #[test]
+    fn a_request_reaches_the_listening_window() {
+        let dir = scratch("roundtrip");
+        let listening = listen(&dir).unwrap();
+        let (tx, rx) = mpsc::channel();
+        std::thread::spawn(move || {
+            accept_loop(listening, move |r| tx.send(r).unwrap(), || Ok(json!({"tabs": []})))
+        });
+        deliver(&dir, &request()).unwrap();
+        assert_eq!(rx.recv_timeout(Duration::from_secs(5)).unwrap(), request());
+    }
+
+    #[test]
+    fn a_wrong_token_is_refused_and_nothing_is_queued() {
+        let dir = scratch("token");
+        let listening = listen(&dir).unwrap();
+        let (tx, rx) = mpsc::channel();
+        std::thread::spawn(move || {
+            accept_loop(listening, move |r| tx.send(r).unwrap(), || Ok(json!({"tabs": []})))
+        });
+        let path = dir.join(ENDPOINT_FILE);
+        let mut endpoint: Endpoint =
+            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
+        endpoint.token = "0".repeat(64);
+        std::fs::write(&path, serde_json::to_string(&endpoint).unwrap()).unwrap();
+        assert!(matches!(
+            deliver(&dir, &request()),
+            Err(Unreachable::Refused(message)) if message == "wrong token"
+        ));
+        assert!(rx.recv_timeout(Duration::from_millis(200)).is_err());
+    }
+
+    #[test]
+    fn a_state_request_is_answered_and_opens_nothing() {
+        let dir = scratch("state");
+        let listening = listen(&dir).unwrap();
+        let (tx, rx) = mpsc::channel();
+        std::thread::spawn(move || {
+            accept_loop(
+                listening,
+                move |r| tx.send(r).unwrap(),
+                || Ok(json!({"tabs": [{"kind": "query"}]})),
+            )
+        });
+        let state = fetch_state(&dir).unwrap();
+        assert_eq!(state["tabs"][0]["kind"], "query");
+        assert!(rx.recv_timeout(Duration::from_millis(200)).is_err());
+    }
+
+    #[test]
+    fn a_window_that_does_not_answer_times_out() {
+        let dir = scratch("state-timeout");
+        let listening = listen(&dir).unwrap();
+        std::thread::spawn(move || {
+            accept_loop(listening, |_| {}, || Err("the window did not answer within 5s".into()))
+        });
+        assert!(matches!(fetch_state(&dir), Err(Unreachable::Timeout(_))));
+    }
+
+    #[test]
+    fn waiting_state_requests_are_all_answered() {
+        let (first, first_rx) = mpsc::channel();
+        let (second, second_rx) = mpsc::channel();
+        STATE_WAITERS.lock().unwrap().extend([first, second]);
+        assert!(state_wanted());
+        answer_state(json!({"n": 1}));
+        assert!(!state_wanted());
+        assert_eq!(first_rx.recv().unwrap()["n"], 1);
+        assert_eq!(second_rx.recv().unwrap()["n"], 1);
+    }
+
+    #[test]
+    fn a_missing_or_stale_endpoint_means_no_window() {
+        let dir = scratch("stale");
+        assert!(matches!(
+            deliver(&dir, &request()),
+            Err(Unreachable::NotRunning)
+        ));
+        // A window that quit: its port no longer listens.
+        let (listener, _) = listen(&dir).unwrap();
+        drop(listener);
+        assert!(matches!(
+            deliver(&dir, &request()),
+            Err(Unreachable::NotRunning)
+        ));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn the_endpoint_is_readable_by_its_owner_only() {
+        use std::os::unix::fs::PermissionsExt;
+        let dir = scratch("mode");
+        let _listening = listen(&dir).unwrap();
+        let mode = std::fs::metadata(dir.join(ENDPOINT_FILE))
+            .unwrap()
+            .permissions()
+            .mode();
+        assert_eq!(mode & 0o777, 0o600);
+    }
+
+    #[test]
+    fn only_a_bundles_own_binary_launches_through_the_bundle() {
+        let inside = Path::new("/Applications/DuckLocal.app/Contents/MacOS/ducklocal");
+        let loose = Path::new("/Users/me/ducklocal/target/debug/ducklocal");
+        assert_eq!(bundle_of(loose), None);
+        if cfg!(target_os = "macos") {
+            assert_eq!(
+                bundle_of(inside),
+                Some(PathBuf::from("/Applications/DuckLocal.app"))
+            );
+        } else {
+            assert_eq!(bundle_of(inside), None);
+        }
+    }
+}
diff --git a/src/schema_cli.rs b/src/schema_cli.rs
new file mode 100644
index 0000000..ba2b108
--- /dev/null
+++ b/src/schema_cli.rs
@@ -0,0 +1,473 @@
+//! `ducklocal schema`: what there is to query, sized for a prompt.
+//!
+//! An agent about to write SQL needs the relations and their columns, and
+//! learning them one `DESCRIBE` at a time costs a call per table. This answers
+//! in one: data files (PATHs — files, folders and globs, expanded the way the
+//! GUI expands a drop) and, with a database, its tables and views.
+//!
+//! A small catalog comes back whole. A large one would drown the prompt it is
+//! meant for, so past [`FULL_RELATIONS`] relations or [`FULL_COLUMNS`] columns
+//! only the [`SUMMARY_FULL`] largest keep their columns; the rest are listed
+//! by name, kind, rows and column count, and the output says how to ask for
+//! one of them whole (`--table`) or for everything (`--full`).
+//!
+//! `--stats` goes one level deeper on one relation: exact per-column
+//! statistics (nulls, distinct, min/max, median, decimals, day coverage) —
+//! what decides a chart's axis before one is drawn. It is `profile.rs`'s
+//! report; `ducklocal profile` remains as its deprecated spelling.
+//!
+//! Every relation carries `from`: the SQL that reads it, ready to paste after
+//! `FROM`. Row counts are what is cheap to know — a table's estimate, a
+//! Parquet footer's count — and `null` where knowing would mean a scan.
+
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+
+use serde_json::{json, Value};
+
+use crate::cli::{parse_args, Arg, CliError, FlagSpec};
+
+pub(crate) const SCHEMA_HELP: &str = "\
+Usage: ducklocal schema [PATH ...] [--database PATH] [--table NAME] [--full|--stats]
+
+What there is to query, as JSON sized for a prompt: data files (PATHs are
+files, folders or globs) and, with --database, a database's tables and views.
+A small catalog lists every relation with its columns; a large one gives the
+columns of the largest few, and name, kind, rows and column count for the rest.
+
+Options:
+  --database PATH    Existing database file, opened read-only
+  --table NAME       One relation, whole: a table, a view, or a PATH's name
+  --full             Every relation with its columns, however many
+  --stats            Exact per-column statistics of one relation: the only one
+                     named, or --table NAME. Type, nulls, distinct, min and
+                     max, plus median and decimals for numbers and day
+                     coverage for dates. A workbook's first sheet is used.
+
+Output: {detail, relations: [{name, kind, from, rows, column_count, columns?}],
+without_columns, hint?}. `from` is the SQL that reads the relation. `rows` is
+an estimate for tables, exact for Parquet, and null where it would need a scan.
+With --stats: {target, row_count, columns: [{name, type, nulls, distinct, ...}]}.
+";
+
+const SPEC: &[FlagSpec] = &[
+    FlagSpec {
+        name: "--database",
+        takes_value: true,
+    },
+    FlagSpec {
+        name: "--table",
+        takes_value: true,
+    },
+    FlagSpec {
+        name: "--full",
+        takes_value: false,
+    },
+    FlagSpec {
+        name: "--stats",
+        takes_value: false,
+    },
+];
+
+/// A catalog up to this many relations comes back whole.
+const FULL_RELATIONS: usize = 12;
+/// …and up to this many columns across them.
+const FULL_COLUMNS: usize = 400;
+/// How many relations keep their columns in a summary.
+const SUMMARY_FULL: usize = 5;
+
+/// One queryable thing, before the output decides how much of it to show.
+struct Relation {
+    name: String,
+    kind: &'static str,
+    from: String,
+    path: Option<String>,
+    /// What `--stats` profiles: a file's path as shown, or a table's name.
+    target: String,
+    rows: Option<i64>,
+    columns: Vec<(String, String)>,
+    /// Why its columns could not be read: the file is there but DuckDB could
+    /// not describe it.
+    error: Option<String>,
+    /// A workbook's sheets, which have no table function to read them by.
+    sheets: Option<Vec<String>>,
+}
+
+pub(crate) fn run(args: &[OsString]) -> Result<String, CliError> {
+    let mut paths = Vec::new();
+    let mut database = None;
+    let mut table = None;
+    let mut full = false;
+    let mut stats = false;
+    for arg in parse_args("schema", args, SPEC, &[])? {
+        match arg {
+            Arg::Flag("--database", Some(value)) => {
+                database = Some(crate::cli::database_path(&value)?);
+            }
+            Arg::Flag("--table", Some(value)) => {
+                table = Some(
+                    value
+                        .into_string()
+                        .map_err(|_| CliError::argument("--table must be UTF-8"))?,
+                );
+            }
+            Arg::Flag("--full", None) => full = true,
+            Arg::Flag("--stats", None) => stats = true,
+            Arg::Positional(value) => paths.push(value.to_string_lossy().into_owned()),
+            _ => {
+                return Err(CliError::failure(
+                    "internal",
+                    "the argument walker produced a flag schema does not declare",
+                ))
+            }
+        }
+    }
+
+    // PATHs resolve as the GUI resolves them, database files included: a
+    // `.duckdb` named as a PATH is the same request as --database.
+    let sources = crate::sources::resolve(&paths);
+    if !sources.problems.is_empty() {
+        return Err(CliError::argument(sources.problems.join("\n")));
+    }
+    if let Some(named) = sources.database {
+        if database.is_some() {
+            return Err(CliError::argument(
+                "Name one database: a PATH that is a database and --database are both given",
+            ));
+        }
+        database = Some(PathBuf::from(named));
+    }
+    if paths.is_empty() && database.is_none() {
+        return Err(
+            CliError::argument("Name data files, folders or globs, or --database PATH").with_hint(
+                "e.g. ducklocal schema ./data/  or  ducklocal schema --database warehouse.duckdb",
+            ),
+        );
+    }
+
+    if stats && full {
+        return Err(CliError::argument(
+            "--stats and --full are two answers; ask for one",
+        ));
+    }
+
+    let connection = crate::cli::open(database.clone(), false)?;
+    let cwd = std::env::current_dir().unwrap_or_default();
+    let mut relations: Vec<Relation> = sources
+        .files
+        .iter()
+        .map(|file| file_relation(&connection, file, &cwd))
+        .collect();
+    if database.is_some() {
+        relations.extend(database_relations(&connection)?);
+    }
+
+    if let Some(wanted) = table {
+        let found = relations
+            .into_iter()
+            .find(|r| names_match(r, &wanted))
+            .ok_or_else(|| {
+                CliError::argument(format!("No relation named {wanted:?}"))
+                    .with_hint("Run the same command without --table to list the names")
+            })?;
+        if stats {
+            drop(connection);
+            return crate::cli::profile_target(&found.target, database);
+        }
+        return Ok(json!({
+            "detail": "full",
+            "relations": [entry(&found, true)],
+            "without_columns": 0,
+        })
+        .to_string());
+    }
+
+    if stats {
+        let [only] = relations.as_slice() else {
+            return Err(CliError::argument(format!(
+                "--stats profiles one relation; these arguments name {}",
+                relations.len()
+            ))
+            .with_hint("Add --table NAME to pick one"));
+        };
+        let target = only.target.clone();
+        drop(connection);
+        return crate::cli::profile_target(&target, database);
+    }
+
+    let total_columns: usize = relations.iter().map(|r| r.columns.len()).sum();
+    let whole = full || (relations.len() <= FULL_RELATIONS && total_columns <= FULL_COLUMNS);
+    let keep = if whole {
+        vec![true; relations.len()]
+    } else {
+        largest(&relations, SUMMARY_FULL)
+    };
+    let without_columns = keep.iter().filter(|kept| !**kept).count();
+    let mut output = json!({
+        "detail": if whole { "full" } else { "summary" },
+        "relations": relations
+            .iter()
+            .zip(&keep)
+            .map(|(relation, kept)| entry(relation, *kept))
+            .collect::<Vec<_>>(),
+        "without_columns": without_columns,
+    });
+    if !whole {
+        output["hint"] = json!(format!(
+            "{without_columns} relations are listed without columns; \
+             add --table NAME for one of them, or --full for all"
+        ));
+    }
+    Ok(output.to_string())
+}
+
+/// A relation as output: everything, or everything but the column list.
+fn entry(relation: &Relation, with_columns: bool) -> Value {
+    let mut value = json!({
+        "name": relation.name,
+        "kind": relation.kind,
+        "from": relation.from,
+        "rows": relation.rows,
+        "column_count": relation.columns.len(),
+    });
+    if let Some(path) = &relation.path {
+        value["path"] = json!(path);
+    }
+    if let Some(error) = &relation.error {
+        value["error"] = json!(error);
+    }
+    if let Some(sheets) = &relation.sheets {
+        value["sheets"] = json!(sheets);
+    }
+    if with_columns {
+        value["columns"] = json!(relation
+            .columns
+            .iter()
+            .map(|(name, ty)| json!({"name": name, "type": ty}))
+            .collect::<Vec<_>>());
+    }
+    value
+}
+
+/// Which relations keep their columns in a summary: the `n` with the most
+/// rows, unknown counts after known ones, catalog order breaking ties.
+fn largest(relations: &[Relation], n: usize) -> Vec<bool> {
+    let mut order: Vec<usize> = (0..relations.len()).collect();
+    order.sort_by_key(|&ix| std::cmp::Reverse(relations[ix].rows.map_or(-1, |rows| rows)));
+    let mut keep = vec![false; relations.len()];
+    for &ix in order.iter().take(n) {
+        keep[ix] = true;
+    }
+    keep
+}
+
+/// `--table` matches a relation's name as listed, its unqualified table name,
+/// or — for a file — the path as given or its file name.
+fn names_match(relation: &Relation, wanted: &str) -> bool {
+    let wanted = wanted.trim();
+    if relation.name.eq_ignore_ascii_case(wanted) {
+        return true;
+    }
+    if let Some(last) = relation.name.rsplit('.').next() {
+        if relation.kind != "file" && last.eq_ignore_ascii_case(wanted) {
+            return true;
+        }
+    }
+    relation.path.as_deref().is_some_and(|path| {
+        path == wanted
+            || Path::new(path)
+                .file_name()
+                .is_some_and(|name| name.to_string_lossy() == wanted)
+    })
+}
+
+/// A data file as a relation: its columns per DuckDB's reader, and its row
+/// count when the format keeps one.
+fn file_relation(connection: &duckdb::Connection, file: &str, cwd: &Path) -> Relation {
+    let shown = Path::new(file)
+        .strip_prefix(cwd)
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_else(|_| file.to_string());
+    let literal = format!("'{}'", shown.replace('\'', "''"));
+    if crate::db::is_excel_file(file) {
+        return Relation {
+            name: shown.clone(),
+            kind: "workbook",
+            from: String::new(),
+            target: shown.clone(),
+            path: Some(shown),
+            rows: None,
+            columns: Vec::new(),
+            error: Some(
+                "A workbook has no table function; open it in DuckLocal, or see its first \
+                 sheet's columns with --stats"
+                    .to_string(),
+            ),
+            sheets: crate::excel::sheets(file).ok(),
+        };
+    }
+    let reader = crate::db::data_file_reader(file).unwrap_or("read_csv_auto");
+    let absolute = format!("'{}'", file.replace('\'', "''"));
+    let (columns, error) =
+        match describe(connection, &format!("SELECT * FROM {reader}({absolute})")) {
+            Ok(columns) => (columns, None),
+            Err(message) => (Vec::new(), Some(message)),
+        };
+    let rows = (reader == "read_parquet")
+        .then(|| {
+            connection
+                .query_row(
+                    &format!("SELECT sum(num_rows)::BIGINT FROM parquet_file_metadata({absolute})"),
+                    [],
+                    |row| row.get::<_, Option<i64>>(0),
+                )
+                .ok()
+                .flatten()
+        })
+        .flatten();
+    Relation {
+        name: shown.clone(),
+        kind: "file",
+        // A quoted path is how DuckDB reads a file by its extension; the
+        // explicit reader is only needed where the extension is ambiguous.
+        from: if reader == "read_csv_auto" && !file.to_ascii_lowercase().ends_with(".csv") {
+            format!("{reader}({literal})")
+        } else {
+            literal
+        },
+        target: shown.clone(),
+        path: Some(shown),
+        rows,
+        columns,
+        error,
+        sheets: None,
+    }
+}
+
+/// Every table and view the database holds, named as SQL on this connection
+/// reaches it: bare in the default schema, `schema.table` elsewhere, and
+/// `database.schema.table` outside the attached file.
+fn database_relations(connection: &duckdb::Connection) -> Result<Vec<Relation>, CliError> {
+    let current: String = connection
+        .query_row("SELECT current_database()", [], |row| row.get(0))
+        .map_err(|e| CliError::failure("database", e))?;
+    let catalog = crate::schema::load_catalog_of(connection)
+        .map_err(|e| CliError::failure("database", format!("{e:#}")))?;
+    Ok(catalog
+        .into_iter()
+        .flat_map(|database| database.tables)
+        .filter(|table| table.database != "temp")
+        .map(|table| {
+            let parts: Vec<&str> = if table.database != current {
+                vec![&table.database, &table.schema, &table.name]
+            } else if table.schema != "main" {
+                vec![&table.schema, &table.name]
+            } else {
+                vec![&table.name]
+            };
+            Relation {
+                name: parts.join("."),
+                kind: match table.kind {
+                    crate::schema::NodeKind::Table => "table",
+                    crate::schema::NodeKind::View => "view",
+                },
+                from: parts
+                    .iter()
+                    .map(|part| quote(part))
+                    .collect::<Vec<_>>()
+                    .join("."),
+                path: None,
+                target: parts.join("."),
+                rows: table.estimated_rows,
+                columns: table
+                    .columns
+                    .into_iter()
+                    .map(|column| (column.name, column.data_type))
+                    .collect(),
+                error: None,
+                sheets: None,
+            }
+        })
+        .collect())
+}
+
+/// An identifier as SQL: bare when it can be, double-quoted when not.
+fn quote(name: &str) -> String {
+    let mut chars = name.chars();
+    let plain = chars
+        .next()
+        .is_some_and(|c| c.is_ascii_lowercase() || c == '_')
+        && chars.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_');
+    if plain {
+        name.to_string()
+    } else {
+        format!("\"{}\"", name.replace('"', "\"\""))
+    }
+}
+
+fn describe(connection: &duckdb::Connection, sql: &str) -> Result<Vec<(String, String)>, String> {
+    let mut statement = connection
+        .prepare(&format!("DESCRIBE {sql}"))
+        .map_err(|e| e.to_string())?;
+    let mut rows = statement.query([]).map_err(|e| e.to_string())?;
+    let mut columns = Vec::new();
+    while let Some(row) = rows.next().map_err(|e| e.to_string())? {
+        columns.push((
+            row.get::<_, String>(0).map_err(|e| e.to_string())?,
+            row.get::<_, String>(1).map_err(|e| e.to_string())?,
+        ));
+    }
+    Ok(columns)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn relation(name: &str, rows: Option<i64>) -> Relation {
+        Relation {
+            name: name.into(),
+            kind: "table",
+            from: name.into(),
+            path: None,
+            target: name.into(),
+            rows,
+            columns: Vec::new(),
+            error: None,
+            sheets: None,
+        }
+    }
+
+    #[test]
+    fn a_summary_keeps_the_largest_relations_whole() {
+        let relations = [
+            relation("small", Some(10)),
+            relation("view", None),
+            relation("big", Some(1_000)),
+            relation("mid", Some(100)),
+        ];
+        assert_eq!(largest(&relations, 2), vec![false, false, true, true]);
+        // Unknown counts come last, but still come when there is room.
+        assert_eq!(largest(&relations, 4), vec![true; 4]);
+    }
+
+    #[test]
+    fn identifiers_are_quoted_only_when_they_must_be() {
+        assert_eq!(quote("orders"), "orders");
+        assert_eq!(quote("Orders"), "\"Orders\"");
+        assert_eq!(quote("order items"), "\"order items\"");
+        assert_eq!(quote("a\"b"), "\"a\"\"b\"");
+    }
+
+    #[test]
+    fn table_names_match_qualified_bare_or_by_file_name() {
+        let mut table = relation("sales.orders", None);
+        assert!(names_match(&table, "sales.orders"));
+        assert!(names_match(&table, "ORDERS"));
+        table.kind = "file";
+        table.name = "data/orders.csv".into();
+        table.path = Some("data/orders.csv".into());
+        assert!(names_match(&table, "orders.csv"));
+        assert!(!names_match(&table, "orders"));
+    }
+}
diff --git a/src/setup.rs b/src/setup.rs
index c47afc2..82bdbff 100644
--- a/src/setup.rs
+++ b/src/setup.rs
@@ -328,9 +328,10 @@ pub fn agent_prompt() -> String {
          over local CSV, TSV, Parquet, JSON and Excel files and databases, and prints JSON.\n\
          \n\
          - Start with `{command} --help` for the options.\n\
-         - Read a file's columns before querying it: \
-         `{command} query --sql \"DESCRIBE SELECT * FROM 'data.csv'\"`.\n\
-         - Profile what you will chart or summarize: `{command} profile data.csv`.\n\
+         - See what there is to query, with columns, before writing SQL: \
+         `{command} schema ./data/` (or `--database file.duckdb`).\n\
+         - Profile what you will chart or summarize: `{command} schema data.csv --stats`.\n\
+         - To see what I have open in the DuckLocal window: `{command} open --state`.\n\
          - Compute totals in SQL, not from sample rows; check `truncated` in the output.\n\
          - Use `--format md` for a table to show me, JSON when you parse it.\n\
          - It opens data read-only by default. Answer from the values it returns, \
@@ -367,8 +368,9 @@ mod tests {
     fn the_prompt_names_a_command_that_runs() {
         let prompt = agent_prompt();
         assert!(prompt.contains("--help"));
-        assert!(prompt.contains("profile"));
-        assert!(prompt.contains("DESCRIBE"));
+        assert!(prompt.contains("schema ./data/"));
+        assert!(prompt.contains("--stats"));
+        assert!(prompt.contains("open --state"));
     }
 
     #[cfg(unix)]
diff --git a/src/spec/complete.rs b/src/spec/complete.rs
index 1dc8138..2514bb3 100644
--- a/src/spec/complete.rs
+++ b/src/spec/complete.rs
@@ -13,22 +13,27 @@
 use super::model;
 
 /// Every attribute a plot block may hold, in the order completion offers
-/// them: the common ones first, a map's own after.
-pub(crate) const PLOT_ATTRS: [&str; 12] = [
+/// them: the common ones first, a map's and a card's own after.
+pub(crate) const PLOT_ATTRS: [&str; 14] = [
     "type",
     "query",
     "x",
     "y",
     "series",
     "title",
+    "width",
     "lat",
     "lng",
     "color",
     "size",
     "size_scale",
     "tooltip",
+    "value",
 ];
 
+/// The block kinds, in the order completion offers them at the top level.
+const BLOCKS: [&str; 4] = ["query", "plot", "source", "filter"];
+
 /// One thing that could be inserted at the cursor.
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct Completion {
@@ -47,13 +52,14 @@ pub(crate) struct Completion {
 /// `CompletionItemKind` for the GUI, the LSP's for the server.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum CompletionKind {
-    /// `query` / `plot` at the top level.
+    /// `query` / `plot` / `source` at the top level.
     Block,
     /// An attribute name inside a block.
     Attribute,
     /// One of the plot types after `type =`.
     Value,
-    /// A query block's name after `query = query.`.
+    /// A query block's name after `query = query.`, or a plot's after
+    /// `plot = plot.`.
     Reference,
 }
 
@@ -92,6 +98,17 @@ pub(crate) fn complete(source: &str, line: usize, col: usize) -> Vec<Completion>
             })
             .collect();
     }
+    if after_ref_dot(&before, "plot") {
+        return block_names(source, "plot")
+            .into_iter()
+            .map(|name| Completion {
+                label: name.clone(),
+                kind: CompletionKind::Reference,
+                detail: Some("plot block".to_string()),
+                insert_text: name,
+            })
+            .collect();
+    }
 
     // The two attributes whose value is one of a fixed set of strings.
     let choices = [
@@ -127,9 +144,11 @@ pub(crate) fn complete(source: &str, line: usize, col: usize) -> Vec<Completion>
             .map(|name| attribute(name, "plot"))
             .collect(),
         Some(kind) if kind == "query" => vec![attribute("sql", "query")],
+        Some(kind) if kind == "source" => vec![attribute("path", "source")],
+        Some(kind) if kind == "filter" => vec![attribute("plot", "filter"), attribute("column", "filter")],
         // An unknown block kind has no known attributes to offer.
         Some(_) => Vec::new(),
-        None => ["query", "plot"]
+        None => BLOCKS
             .into_iter()
             .map(|name| Completion {
                 label: name.to_string(),
@@ -184,16 +203,48 @@ fn heredoc_delimiter(line: &str) -> Option<String> {
 
 /// The cursor follows `query = query.`, possibly part-way into the name.
 fn after_query_dot(before: &str) -> bool {
+    after_ref_dot(before, "query")
+}
+
+/// The cursor follows `kind = kind.` — `plot = plot.` in a filter —
+/// possibly part-way into the name.
+fn after_ref_dot(before: &str, kind: &str) -> bool {
     let before = before.trim_end();
     let ident_len = trailing_ident_len(before);
     let head = &before[..before.len() - ident_len];
-    let Some(head) = head.strip_suffix("query.") else {
+    let Some(head) = head.strip_suffix(&format!("{kind}.")) else {
         return false;
     };
     let Some(head) = head.trim_end().strip_suffix('=') else {
         return false;
     };
-    head.trim() == "query"
+    head.trim() == kind
+}
+
+/// The names of the file's blocks of one kind, when it parses; mid-edit,
+/// the `kind "name"` openers a line scan finds.
+fn block_names(source: &str, kind: &str) -> Vec<String> {
+    if let Ok(file) = model::parse(source) {
+        return file
+            .blocks
+            .iter()
+            .filter(|block| block.kind == kind)
+            .map(|block| block.name.clone())
+            .collect();
+    }
+    let mut names = Vec::new();
+    for line in source.lines() {
+        let trimmed = line.trim_start();
+        if block_opener(trimmed).as_deref() == Some(kind) {
+            let rest = trimmed[kind.len()..].trim_start();
+            if let Some(name) = rest.strip_prefix('"').and_then(|r| r.split('"').next()) {
+                if !names.iter().any(|n: &String| n == name) {
+                    names.push(name.to_string());
+                }
+            }
+        }
+    }
+    names
 }
 
 /// The cursor follows `type =`, optionally inside an opened quote. The answer
@@ -332,14 +383,14 @@ mod tests {
     #[test]
     fn block_types_at_the_top_level() {
         let candidates = complete("", 1, 1);
-        assert_eq!(labels(&candidates), ["query", "plot"]);
+        assert_eq!(labels(&candidates), BLOCKS);
         assert!(candidates
             .iter()
             .all(|c| c.kind == CompletionKind::Block));
 
         // Between two blocks, and past the last one.
-        assert_eq!(labels(&complete(SPEC, 6, 1)), ["query", "plot"]);
-        assert_eq!(labels(&complete(SPEC, 12, 1)), ["query", "plot"]);
+        assert_eq!(labels(&complete(SPEC, 6, 1)), BLOCKS);
+        assert_eq!(labels(&complete(SPEC, 12, 1)), BLOCKS);
     }
 
     #[test]
@@ -358,6 +409,9 @@ mod tests {
 
         let candidates = complete("query \"q\" {\n  s\n}", 2, 3);
         assert_eq!(labels(&candidates), ["sql"]);
+
+        let candidates = complete("source \"orders\" {\n  \n}", 2, 3);
+        assert_eq!(labels(&candidates), ["path"]);
     }
 
     #[test]
@@ -400,6 +454,13 @@ mod tests {
         assert_eq!(labels(&candidates), ["revenue", "cost"]);
     }
 
+    #[test]
+    fn filter_attributes_and_plot_names() {
+        let source = "plot \"channels\" {\n  type = \"bar\"\n}\nfilter \"c\" {\n  plot = plot.\n}\n";
+        assert_eq!(labels(&complete(source, 5, 3)), ["plot", "column"]);
+        assert_eq!(labels(&complete(source, 5, 15)), ["channels"]);
+    }
+
     #[test]
     fn a_broken_file_still_completes() {
         // Both blocks unclosed: parse fails, and the answers come from the
diff --git a/src/spec/filter.rs b/src/spec/filter.rs
new file mode 100644
index 0000000..1940be0
--- /dev/null
+++ b/src/spec/filter.rs
@@ -0,0 +1,205 @@
+//! `filter` blocks: a click on one plot narrows the queries of the others.
+//!
+//! ```text
+//! filter "channel" {
+//!   plot   = plot.revenue_by_channel   // a click on a bar (or a table row) picks
+//!   column = channel                   // the value of this column; default: x
+//! }
+//! query "daily" {
+//!   sql = "SELECT date, sum(orders) FROM orders WHERE $channel GROUP BY 1"
+//! }
+//! ```
+//!
+//! `$channel` in a query's SQL is a predicate: `("channel" = 'Web')` while a
+//! value is picked, `TRUE` while none is — so a dashboard with nothing picked
+//! runs exactly the SQL it would without the filter. Several filters combine
+//! as the author writes them (`WHERE $channel AND $region`), and a query that
+//! names none is never re-run when a pick changes.
+//!
+//! The picking plot's own queries see `TRUE`: the filter narrows everything
+//! else, never the plot it is picked on — otherwise one click would collapse
+//! the bars to the one just clicked, and there would be nothing left to click
+//! next. This is the cross-filter of Mosaic and crossfilter.js.
+//!
+//! The picked value goes into the SQL as a string literal, quotes doubled, and
+//! DuckDB casts it to the column's type where it is compared; the column is a
+//! quoted identifier. Nothing the data holds can end the literal early, so
+//! the rewrite keeps a read-only query read-only — the read-only check runs
+//! on the SQL with every placeholder `TRUE`.
+//!
+//! Finding `$name` skips string literals, quoted identifiers, comments and
+//! dollar-quoted strings, so a `'$5'` in the data or a `$$ … $$` body is never
+//! mistaken for one.
+
+use std::collections::HashMap;
+use std::ops::Range;
+
+/// One `$name` in a query's SQL.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct Placeholder {
+    pub name: String,
+    /// Byte range of the whole `$name`, dollar included.
+    pub range: Range<usize>,
+}
+
+/// A value picked on a plot, for the queries that name its filter.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct Pick {
+    /// The column the predicate compares, as named on the filter.
+    pub column: String,
+    /// The cell as the result grid shows it; `None` is SQL NULL.
+    pub value: Option<String>,
+}
+
+impl Pick {
+    /// The predicate that stands in for the placeholder.
+    pub(crate) fn predicate(&self) -> String {
+        let column = format!("\"{}\"", self.column.replace('"', "\"\""));
+        match &self.value {
+            None => format!("({column} IS NULL)"),
+            Some(value) => format!("({column} = '{}')", value.replace('\'', "''")),
+        }
+    }
+}
+
+/// Every `$name` outside strings, quoted identifiers and comments, in order.
+/// `$1`-style positional parameters are not names and are left alone.
+pub(crate) fn placeholders(sql: &str) -> Vec<Placeholder> {
+    let bytes = sql.as_bytes();
+    let mut found = Vec::new();
+    let mut i = 0;
+    let ident = |b: u8| b.is_ascii_alphanumeric() || b == b'_';
+    while i < bytes.len() {
+        match bytes[i] {
+            quote @ (b'\'' | b'"') => {
+                // A doubled quote inside is an escaped one; either way the
+                // scan resumes after the closing quote.
+                i += 1;
+                while i < bytes.len() {
+                    if bytes[i] == quote {
+                        if bytes.get(i + 1) == Some(&quote) {
+                            i += 2;
+                            continue;
+                        }
+                        break;
+                    }
+                    i += 1;
+                }
+                i += 1;
+            }
+            b'-' if bytes.get(i + 1) == Some(&b'-') => {
+                i = sql[i..].find('\n').map_or(bytes.len(), |end| i + end + 1);
+            }
+            b'/' if bytes.get(i + 1) == Some(&b'*') => {
+                i = sql[i + 2..]
+                    .find("*/")
+                    .map_or(bytes.len(), |end| i + 2 + end + 2);
+            }
+            b'$' => {
+                let start = i;
+                let mut end = i + 1;
+                while end < bytes.len() && ident(bytes[end]) {
+                    end += 1;
+                }
+                let tag = &sql[start..end];
+                if bytes.get(end) == Some(&b'$') {
+                    // `$$ … $$` or `$tag$ … $tag$`: a string; skip past its end.
+                    let close = format!("{tag}$");
+                    i = sql[end + 1..]
+                        .find(&close)
+                        .map_or(bytes.len(), |at| end + 1 + at + close.len());
+                } else if end > start + 1 && !bytes[start + 1].is_ascii_digit() {
+                    found.push(Placeholder {
+                        name: sql[start + 1..end].to_string(),
+                        range: start..end,
+                    });
+                    i = end;
+                } else {
+                    i = end.max(start + 1);
+                }
+            }
+            _ => i += 1,
+        }
+    }
+    found
+}
+
+/// `sql` with each `$name` replaced: by the picked value's predicate when
+/// `picks` has one for that name, by `TRUE` when it does not.
+pub(crate) fn apply(sql: &str, picks: &HashMap<String, Pick>) -> String {
+    let mut out = String::with_capacity(sql.len());
+    let mut last = 0;
+    for placeholder in placeholders(sql) {
+        out.push_str(&sql[last..placeholder.range.start]);
+        match picks.get(&placeholder.name) {
+            Some(pick) => out.push_str(&pick.predicate()),
+            None => out.push_str("TRUE"),
+        }
+        last = placeholder.range.end;
+    }
+    out.push_str(&sql[last..]);
+    out
+}
+
+/// `sql` as it runs with nothing picked: every placeholder `TRUE`. What the
+/// read-only check and `check` judge.
+pub(crate) fn neutral(sql: &str) -> String {
+    apply(sql, &HashMap::new())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn names(sql: &str) -> Vec<String> {
+        placeholders(sql).into_iter().map(|p| p.name).collect()
+    }
+
+    #[test]
+    fn placeholders_are_found_outside_strings_and_comments() {
+        assert_eq!(
+            names("SELECT * FROM t WHERE $channel AND ($region OR x = 1)"),
+            ["channel", "region"]
+        );
+        assert_eq!(
+            names("SELECT '$not', \"$nor\", $$ $body $$, $t$ $x $t$ -- $no\n/* $none */ FROM t WHERE $yes"),
+            ["yes"]
+        );
+        assert_eq!(names("SELECT 'it''s $x' WHERE $ok"), ["ok"]);
+        // Positional parameters and a lone dollar are not filters.
+        assert!(names("SELECT $1, $ FROM t").is_empty());
+    }
+
+    #[test]
+    fn nothing_picked_is_true_and_a_pick_is_a_quoted_comparison() {
+        let sql = "FROM t WHERE $channel AND $day";
+        assert_eq!(neutral(sql), "FROM t WHERE TRUE AND TRUE");
+        let mut picks = HashMap::new();
+        picks.insert(
+            "channel".to_string(),
+            Pick {
+                column: "Sales \"Channel\"".into(),
+                value: Some("it's".into()),
+            },
+        );
+        picks.insert(
+            "day".to_string(),
+            Pick {
+                column: "day".into(),
+                value: None,
+            },
+        );
+        assert_eq!(
+            apply(sql, &picks),
+            "FROM t WHERE (\"Sales \"\"Channel\"\"\" = 'it''s') AND (\"day\" IS NULL)"
+        );
+    }
+
+    #[test]
+    fn an_unterminated_string_ends_the_scan_without_panicking() {
+        assert!(names("SELECT 'open $x").is_empty());
+        assert!(names("SELECT /* open $x").is_empty());
+        assert!(names("SELECT $$ open $x").is_empty());
+        assert_eq!(names("SELECT $x"), ["x"]);
+    }
+}
diff --git a/src/spec/lsp.rs b/src/spec/lsp.rs
index 050b012..8f1c16b 100644
--- a/src/spec/lsp.rs
+++ b/src/spec/lsp.rs
@@ -103,6 +103,7 @@ fn serve(database: Option<PathBuf>) -> Result<i32, CliError> {
             kind: "lsp",
             message: error.to_string(),
             code: 2,
+            hint: None,
         })?;
 
     let mut documents: HashMap<Url, String> = HashMap::new();
@@ -407,7 +408,15 @@ fn hover_at(source: &str, position: Position) -> Option<Hover> {
         Hit::Attr { name, .. } => attr_doc(&name)?.to_string(),
         Hit::Block { kind, name, .. } => match kind.as_str() {
             "query" => format!("**query \"{name}\"**\n\nA named query: one `sql` attribute holding one statement, as a heredoc or a string."),
-            "plot" => format!("**plot \"{name}\"**\n\nA named plot: `type`, `query`, `x` and `y`, plus optional `series` and `title`; a `map` takes `lat`, `lng` and optional `color`, `size`, `size_scale` and `tooltip` instead of `x`, `y` and `series`."),
+            "plot" => format!("**plot \"{name}\"**\n\nA named plot: `type`, `query`, `x` and `y`, plus optional `series`, `title` and `width`; a `map` takes `lat`, `lng` and optional `color`, `size`, `size_scale` and `tooltip` instead of `x`, `y` and `series`; a `card` takes an optional `value` instead."),
+            "filter" => {
+                let (plot, column) = spec.filters.iter().find(|f| f.name == name).map(|f| (f.plot.clone(), f.column.clone())).unwrap_or_default();
+                format!("**filter \"{name}\"**\n\nA click on plot `{plot}` picks a `{column}`; a query reads it as `${name}` — `(\"{column}\" = <picked>)`, or `TRUE` while nothing is picked. The plot's own query is never narrowed by it.")
+            }
+            "source" => {
+                let path = spec.sources.iter().find(|s| s.name == name).map(|s| s.path.clone()).unwrap_or_default();
+                format!("**source \"{name}\"**\n\n`{path}`, read as `{name}` by every query that names it. The path is relative to this file.")
+            }
             _ => return None,
         },
         Hit::Ref { segments, .. } => {
@@ -418,6 +427,9 @@ fn hover_at(source: &str, position: Position) -> Option<Hover> {
                     query.name,
                     sql_summary(&query.sql)
                 )
+            } else if segments.len() == 2 && segments[0] == "plot" {
+                let plot = spec.plots.iter().find(|p| p.name == segments[1])?;
+                format!("**plot \"{}\"**\n\nA `{}` of query `{}`.", plot.name, plot.kind, plot.query)
             } else {
                 return None;
             }
@@ -440,13 +452,17 @@ fn definition_at(source: &str, uri: &Url, position: Position) -> Option<GotoDefi
     let Hit::Ref { segments, .. } = spec.locate(line, col)? else {
         return None;
     };
-    if segments.len() != 2 || segments[0] != "query" {
+    if segments.len() != 2 {
         return None;
     }
-    let query = spec.queries.iter().find(|q| q.name == segments[1])?;
+    let target = match segments[0].as_str() {
+        "query" => spec.queries.iter().find(|q| q.name == segments[1])?.name_span,
+        "plot" => spec.plots.iter().find(|p| p.name == segments[1])?.name_span,
+        _ => return None,
+    };
     Some(GotoDefinitionResponse::Scalar(Location {
         uri: uri.clone(),
-        range: span_range(source, query.name_span),
+        range: span_range(source, target),
     }))
 }
 
@@ -462,7 +478,7 @@ fn validate(source: &str) -> Option<Spec> {
 fn attr_doc(name: &str) -> Option<&'static str> {
     Some(match name {
         "sql" => "**sql**\n\nThe query's one statement, as a heredoc or a string. A query block holds only this.",
-        "type" => "**type**\n\nThe plot's kind: one of `line`, `bar`, `area`, `scatter`, `pie`, `map`, `table`.",
+        "type" => "**type**\n\nThe plot's kind: one of `line`, `bar`, `area`, `scatter`, `pie`, `map`, `table`, `card`.",
         "query" => "**query**\n\nThe query block this plot draws: `query = query.some_name`.",
         "x" => "**x**\n\nA column of the query's result, as a bare identifier or a quoted string; a `pie`'s slices. Not for a `map`.",
         "y" => "**y**\n\nThe numeric column the plot draws; a `pie`'s slice sizes. Optional for `table`, not for a `map`.",
@@ -473,7 +489,12 @@ fn attr_doc(name: &str) -> Option<&'static str> {
         "size" => "**size**\n\nOptional, for a `map`: a numeric column its points are sized by — the area follows the value, so twice the value is twice the ink. A key in the corner reads sizes back.",
         "size_scale" => "**size_scale**\n\nOptional, with `size`: `\"sqrt\"` (the default, area follows value) or `\"log\"`, for values spanning orders of magnitude.",
         "tooltip" => "**tooltip**\n\nOptional, for a `map`: the columns its tooltip lists, in order — `tooltip = [place, requests, ips]`. Left out, it lists the size column and the other numbers, then the coordinates.",
-        "title" => "**title**\n\nOptional: the plot's title.",
+        "title" => "**title**\n\nOptional: the plot's title; a `card`'s label.",
+        "width" => "**width**\n\nOptional: how many of the dashboard's 12 columns the plot spans, 1 to 12. Plots fill a row left to right and wrap. Default 12, or 3 for a `card`.",
+        "value" => "**value**\n\nOptional, for a `card`: the column it shows, from the query's first row. Left out, the first column.",
+        "plot" => "**plot**\n\nThe plot a click picks a value on: `plot = plot.some_name`, a `bar` or a `table`.",
+        "column" => "**column**\n\nOptional for a bar, required for a table: the column whose value the click picks, and that `$name` compares. Default: the bar's `x`.",
+        "path" => "**path**\n\nThe source's data: a `.csv`, `.tsv`, `.parquet` or `.json` file, or a glob of them read as one relation. Relative to this `.dash` file.",
         _ => return None,
     })
 }
diff --git a/src/spec/mod.rs b/src/spec/mod.rs
index 6688603..7777ea3 100644
--- a/src/spec/mod.rs
+++ b/src/spec/mod.rs
@@ -1,4 +1,4 @@
-//! Declarative dashboards: a `.dash` file of query and plot blocks.
+//! Declarative dashboards: a `.dash` file of source, query and plot blocks.
 //!
 //! An analysis app (`src/analysis/`) is a script that draws itself; a `.dash`
 //! file is the same idea declared rather than scripted — queries as heredocs,
@@ -9,6 +9,8 @@
 //! ```text
 //! src/spec/syntax.rs   the text as a tree: blocks, attributes, heredocs
 //! src/spec/model.rs    what the tree means, checked without a database
+//! src/spec/source.rs   `source` blocks: named data files, as each query's CTEs
+//! src/spec/filter.rs   `filter` blocks: a click's pick, as `$name` predicates
 //! src/spec/mod.rs      `ducklocal check`, the command half
 //! src/spec/prepare.rs  a plot's data, derived from its query's result once
 //! src/spec/plot.rs     the plots the catalog charts cannot draw honestly
@@ -28,14 +30,17 @@
 //! that fails `check` opens as its diagnostics, not as a broken chart.
 
 pub mod complete;
+pub mod filter;
 pub mod highlight;
 pub mod lsp;
 pub mod model;
 pub mod plot;
 pub mod prepare;
+pub mod source;
 pub mod syntax;
 pub mod tabs;
 pub mod view;
+mod wheel;
 
 use std::ffi::OsString;
 use std::path::PathBuf;
@@ -75,6 +80,7 @@ pub fn check(args: &[OsString]) -> Result<String, CliError> {
                     message: "the argument walker produced a flag check does not declare"
                         .to_string(),
                     code: 1,
+                    hint: None,
                 });
             }
         }
@@ -111,6 +117,7 @@ pub fn check(args: &[OsString]) -> Result<String, CliError> {
     // the two stop at the same row budget and fail on the same statements.
     // Every failing query is reported, not only the first.
     let mut query_columns: Vec<Option<Vec<(String, String)>>> = vec![None; spec.queries.len()];
+    let base = source::base_of(&file);
     if let Some(database) = &database {
         let connection = crate::cli::open(Some(database.clone()), false)?;
         let mut failures = Vec::new();
@@ -118,14 +125,17 @@ pub fn check(args: &[OsString]) -> Result<String, CliError> {
             let located = |message: String| {
                 format!("{}:{}: query {:?}: {message}", path_display, query.line, query.name)
             };
-            match describe(&connection, &query.sql) {
+            // What runs is the query with the sources it names in front of
+            // it — the same SQL the dashboard runs, with nothing picked.
+            let sql = source::expand(&filter::neutral(&query.sql), &spec.sources, &base);
+            match describe(&connection, &sql) {
                 Ok(columns) => query_columns[index] = Some(columns),
                 Err(message) => {
                     failures.push(located(message));
                     continue;
                 }
             }
-            match crate::query::run_of(&connection, &query.sql) {
+            match crate::query::run_of(&connection, &sql) {
                 Ok(crate::query::QueryOutcome::Rows(_)) => {}
                 Ok(crate::query::QueryOutcome::Affected { .. }) => {
                     failures.push(located("returns no rows to plot".to_string()));
@@ -152,6 +162,12 @@ pub fn check(args: &[OsString]) -> Result<String, CliError> {
 
     Ok(json!({
         "file": path_display,
+        "sources": spec.sources.iter().map(|s| json!({
+            "name": s.name,
+            "path": s.path,
+            "resolved": source::resolve(&s.path, &base).display().to_string(),
+            "line": s.line,
+        })).collect::<Vec<_>>(),
         "queries": spec.queries.iter().enumerate().map(|(index, q)| {
             let mut entry = json!({"name": q.name, "line": q.line});
             if let Some(columns) = &query_columns[index] {
@@ -161,6 +177,16 @@ pub fn check(args: &[OsString]) -> Result<String, CliError> {
             }
             entry
         }).collect::<Vec<_>>(),
+        "filters": spec.filters.iter().map(|f| json!({
+            "name": f.name,
+            "plot": f.plot,
+            "column": f.column,
+            "queries": spec.queries.iter()
+                .filter(|q| spec.filters_of(q).iter().any(|used| used.name == f.name))
+                .map(|q| q.name.clone())
+                .collect::<Vec<_>>(),
+            "line": f.line,
+        })).collect::<Vec<_>>(),
         "plots": spec.plots.iter().map(|p| json!({
             "name": p.name,
             "type": p.kind,
@@ -174,7 +200,9 @@ pub fn check(args: &[OsString]) -> Result<String, CliError> {
             "size": p.size,
             "size_scale": p.size_scale,
             "tooltip": p.tooltip,
+            "value": p.value,
             "title": p.title,
+            "width": p.width(),
             "line": p.line,
         })).collect::<Vec<_>>(),
         "database": database.as_ref().map(|p| p.display().to_string()),
@@ -195,6 +223,9 @@ pub fn check(args: &[OsString]) -> Result<String, CliError> {
 /// everything else. Its one false refusal is `PIVOT`/`UNPIVOT`, which cannot
 /// carry a write, so a statement led by either is let through.
 pub(crate) fn validate_query_sql(sql: &str) -> Result<(), String> {
+    // Judged with nothing picked: a `$name` is a predicate, and what a pick
+    // puts there is a comparison with a quoted literal (see `filter`).
+    let sql = &filter::neutral(sql);
     crate::cli::validate_sql(sql).map_err(|error| error.message().to_string())?;
     let leading = sql
         .trim_start()
@@ -245,6 +276,7 @@ fn spec_error(file: &str, line: usize, message: &str) -> CliError {
         kind: "spec",
         message: format!("{file}:{line}: {message}"),
         code: 2,
+        hint: None,
     }
 }
 
@@ -257,6 +289,7 @@ fn spec_error_all(file: &str, diagnostics: Vec<model::Diagnostic>) -> CliError {
             .collect::<Vec<_>>()
             .join("\n"),
         code: 2,
+        hint: None,
     }
 }
 
@@ -276,6 +309,8 @@ mod tests {
             "SUMMARIZE SELECT 1",
             "PIVOT (SELECT 1 AS a, 2 AS b) ON a IN (1) USING sum(b)",
             "SELECT * FROM read_csv('orders.csv') -- a trailing note",
+            // A filter's placeholder is judged as TRUE.
+            "SELECT * FROM t WHERE $channel AND $region",
         ] {
             assert!(validate_query_sql(sql).is_ok(), "{sql}");
         }
diff --git a/src/spec/model.rs b/src/spec/model.rs
index 3c7944a..86655bd 100644
--- a/src/spec/model.rs
+++ b/src/spec/model.rs
@@ -1,8 +1,10 @@
-//! What the tree means: two block kinds, a fixed set of attributes, and
+//! What the tree means: three block kinds, a fixed set of attributes, and
 //! references that must resolve.
 //!
 //! The rules a `.dash` file lives by:
 //!
+//! * a `source` block names data files: one `path` (a file or a glob, relative
+//!   to the `.dash` file), and its name is a relation every query may read;
 //! * a `query` block holds one `sql` attribute — one statement, nothing else;
 //! * a `plot` block holds `type`, `query`, `x`, and (unless a table) `y`,
 //!   plus an optional `series` and `title`;
@@ -11,6 +13,14 @@
 //!   out when a column's name says what it is (`geo_lat`, `longitude`) — and
 //!   optionally `color`, `size` (with `size_scale`, `"sqrt"` or `"log"`) and
 //!   `tooltip`, a list of the columns its tooltip shows;
+//! * a `card` shows one number: its `value` column (the first column when left
+//!   out) from the query's first row, and takes no `x`, `y` or `series`;
+//! * `width` is how many of the dashboard's twelve columns a plot spans —
+//!   plots fill a row left to right and wrap; 12 unless a card, which is 3;
+//! * a `filter` block names a plot a click picks a value on — a `bar` (its
+//!   bars) or a `table` (its rows) — and optionally the `column` whose value
+//!   is picked (a bar's `x` when left out; a table must name one); a query
+//!   reads it as `$name`, a predicate (see `filter.rs`);
 //! * `query = query.latency` names a query block that exists;
 //! * `x`, `y`, `series` name result columns — as bare identifiers when the
 //!   column allows it, as strings when it does not (`"Revenue (USD)"`).
@@ -26,24 +36,49 @@ use super::syntax::{self, Attr, Block, File, RefSite, Value};
 /// The plot types the format knows. Each is a promise the renderer can keep:
 /// x/y for the continuous ones and `pie`, anything tabular for `table`,
 /// coordinates for `map`.
-pub(crate) const PLOT_TYPES: &[&str] = &["line", "bar", "area", "scatter", "pie", "map", "table"];
+pub(crate) const PLOT_TYPES: &[&str] =
+    &["line", "bar", "area", "scatter", "pie", "map", "table", "card"];
 
 /// The attributes only a `map` takes.
 const MAP_ATTRS: &[&str] = &["lat", "lng", "color", "size", "size_scale", "tooltip"];
 
+/// The attributes only a `card` takes.
+const CARD_ATTRS: &[&str] = &["value"];
+
+/// The dashboard's grid: a row is this many columns wide.
+pub(crate) const GRID_COLUMNS: u8 = 12;
+
 /// How a map's `size` may scale its points.
 pub(crate) const SIZE_SCALES: &[&str] = &["sqrt", "log"];
 
+/// The plot types a filter can pick a value on: a bar by its band, a table
+/// by its row.
+pub(crate) const FILTER_PLOTS: &[&str] = &["bar", "table"];
+
 #[derive(Debug, Clone)]
 pub(crate) struct Spec {
+    pub sources: Vec<Source>,
     pub queries: Vec<Query>,
     pub plots: Vec<Plot>,
+    pub filters: Vec<Filter>,
     /// Where every block and attribute sits in the source, in source order,
     /// for `Spec::locate`.
     #[allow(dead_code)] // read by locate(), which the editor phases wire up
     sites: Vec<Site>,
 }
 
+/// Data files under a name the queries read: `source "orders" { path = ... }`.
+#[derive(Debug, Clone)]
+pub(crate) struct Source {
+    pub name: String,
+    /// As written: a file or a glob, relative to the `.dash` file's folder
+    /// unless absolute or `~`-led. `source::resolve` makes it a real path.
+    pub path: String,
+    pub line: usize,
+    /// The quoted name's span, quotes included: the definition target.
+    pub name_span: (usize, usize),
+}
+
 #[derive(Debug, Clone)]
 pub(crate) struct Query {
     pub name: String,
@@ -78,6 +113,10 @@ pub(crate) struct Plot {
     pub size_scale: Option<String>,
     /// The columns a `map`'s tooltip lists; `None` picks the numbers.
     pub tooltip: Option<Vec<String>>,
+    /// The column a `card` shows; `None` shows the first.
+    pub value: Option<String>,
+    /// Grid columns spanned as written; `Plot::width` applies the default.
+    pub width: Option<u8>,
     /// Line and column of the block's kind keyword.
     pub line: usize,
     pub col: usize,
@@ -87,6 +126,36 @@ pub(crate) struct Plot {
     pub name_span: (usize, usize),
 }
 
+/// A value a click on one plot picks, for the queries that read `$name`.
+#[derive(Debug, Clone)]
+pub(crate) struct Filter {
+    pub name: String,
+    /// The plot block the value is picked on.
+    pub plot: String,
+    /// The column picked and compared: as written, or the bar's `x`. Empty
+    /// only while the file has diagnostics.
+    pub column: String,
+    pub line: usize,
+    pub col: usize,
+    pub span: (usize, usize),
+    pub name_span: (usize, usize),
+}
+
+impl Spec {
+    /// The filters a query reads, by name, in the order its SQL names them.
+    pub(crate) fn filters_of(&self, query: &Query) -> Vec<&Filter> {
+        let mut used: Vec<&Filter> = Vec::new();
+        for placeholder in super::filter::placeholders(&query.sql) {
+            if let Some(filter) = self.filters.iter().find(|f| f.name == placeholder.name) {
+                if !used.iter().any(|f| f.name == filter.name) {
+                    used.push(filter);
+                }
+            }
+        }
+        used
+    }
+}
+
 /// One thing wrong with the file, with its line, column, and span. Semantic
 /// checking collects rather than fails fast: a dashboard being written has
 /// all its mistakes worth saying in one pass.
@@ -177,6 +246,15 @@ pub(crate) enum Hit {
     },
 }
 
+impl Plot {
+    /// How many of the grid's columns this plot spans: as written, or a
+    /// quarter row for a card and the whole row for everything else.
+    pub(crate) fn width(&self) -> u8 {
+        self.width
+            .unwrap_or(if self.kind == "card" { 3 } else { GRID_COLUMNS })
+    }
+}
+
 impl Spec {
     /// The innermost named thing at `(line, col)` — both 1-based, columns in
     /// characters — or `None` outside every block. A linear scan; spec files
@@ -237,12 +315,30 @@ pub(crate) fn validate(file: &File) -> Result<Spec, Vec<Diagnostic>> {
     let mut diagnostics = Vec::new();
     let mut queries = Vec::new();
     let mut plots = Vec::new();
+    let mut sources = Vec::new();
     let mut sites = Vec::new();
     let mut query_names: HashSet<String> = HashSet::new();
     let mut plot_names: HashSet<String> = HashSet::new();
+    let mut source_names: HashSet<String> = HashSet::new();
+    let mut filters = Vec::new();
+    let mut filter_names: HashSet<String> = HashSet::new();
 
     for block in &file.blocks {
         match block.kind.as_str() {
+            "source" => {
+                // SQL names are case-insensitive, so `Orders` and `orders`
+                // would be one relation.
+                if !source_names.insert(block.name.to_ascii_lowercase()) {
+                    diagnostics.push(Diagnostic::at_block(
+                        block,
+                        format!("Duplicate source name: {:?}", block.name),
+                    ));
+                }
+                if let Some(s) = source(block, &mut diagnostics) {
+                    sites.push(site(block, s.name_span));
+                    sources.push(s);
+                }
+            }
             "query" => {
                 if !query_names.insert(block.name.clone()) {
                     diagnostics.push(Diagnostic::at_block(
@@ -267,9 +363,22 @@ pub(crate) fn validate(file: &File) -> Result<Spec, Vec<Diagnostic>> {
                     plots.push(p);
                 }
             }
+            "filter" => {
+                if !filter_names.insert(block.name.clone()) {
+                    diagnostics.push(Diagnostic::at_block(
+                        block,
+                        format!("Duplicate filter name: {:?}", block.name),
+                    ));
+                }
+                let f = filter(block, &mut diagnostics);
+                sites.push(site(block, f.name_span));
+                filters.push((f, block));
+            }
             other => diagnostics.push(Diagnostic::at_block(
                 block,
-                format!("Unknown block: {other:?}; the file holds query and plot blocks"),
+                format!(
+                    "Unknown block: {other:?}; the file holds source, query, plot and filter blocks"
+                ),
             )),
         }
     }
@@ -302,10 +411,82 @@ pub(crate) fn validate(file: &File) -> Result<Spec, Vec<Diagnostic>> {
         }
     }
 
+    // A filter picks on a plot that exists and can be picked on; a bar's
+    // column defaults to its x, a table has no such default.
+    for (filter, block) in filters.iter_mut() {
+        let at_plot = |message: String| match block.attrs.iter().find(|a| a.name == "plot") {
+            Some(attr) => Diagnostic::at_attr(attr, message),
+            None => Diagnostic::at_block(block, message),
+        };
+        if filter.plot.is_empty() {
+            continue; // its own diagnostic already says so
+        }
+        let Some(plot) = plots.iter().find(|p| p.name == filter.plot) else {
+            diagnostics.push(at_plot(format!(
+                "filter {:?} picks on plot {:?}, which the file does not define",
+                filter.name, filter.plot
+            )));
+            continue;
+        };
+        if !plot.kind.is_empty() && !FILTER_PLOTS.contains(&plot.kind.as_str()) {
+            diagnostics.push(at_plot(format!(
+                "filter {:?} picks on plot {:?}, a {}; a value is picked on a {} plot",
+                filter.name,
+                plot.name,
+                plot.kind,
+                FILTER_PLOTS.join(" or ")
+            )));
+            continue;
+        }
+        if filter.column.is_empty() {
+            if plot.kind == "bar" {
+                filter.column = plot.x.clone();
+            } else if plot.kind == "table" {
+                diagnostics.push(Diagnostic::at_block(
+                    block,
+                    format!(
+                        "filter {:?} picks on table {:?}: name the column a row gives, column = some_column",
+                        filter.name, plot.name
+                    ),
+                ));
+            }
+        }
+    }
+    let filters: Vec<Filter> = filters.into_iter().map(|(f, _)| f).collect();
+
+    // Every `$name` a query reads is a filter the file defines.
+    for query in &queries {
+        for placeholder in super::filter::placeholders(&query.sql) {
+            if !filters.iter().any(|f| f.name == placeholder.name) {
+                let block = file
+                    .blocks
+                    .iter()
+                    .find(|b| b.kind == "query" && b.name == query.name);
+                let message = format!(
+                    "query {:?} reads ${}, but no filter block is named {:?}",
+                    query.name, placeholder.name, placeholder.name
+                );
+                diagnostics.push(
+                    match block.and_then(|b| b.attrs.iter().find(|a| a.name == "sql")) {
+                        Some(attr) => Diagnostic::at_attr(attr, message),
+                        None => Diagnostic {
+                            line: query.line,
+                            col: query.col,
+                            span: query.span,
+                            message,
+                        },
+                    },
+                );
+            }
+        }
+    }
+
     if diagnostics.is_empty() {
         Ok(Spec {
+            sources,
             queries,
             plots,
+            filters,
             sites,
         })
     } else {
@@ -334,6 +515,127 @@ fn site(block: &Block, name_span: (usize, usize)) -> Site {
     }
 }
 
+fn source(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Source> {
+    // The name is written into SQL bare, so it must read as one identifier.
+    let mut chars = block.name.chars();
+    let identifier = chars
+        .next()
+        .is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
+        && chars.all(|c| c.is_ascii_alphanumeric() || c == '_');
+    if !identifier {
+        diagnostics.push(Diagnostic::at_block(
+            block,
+            format!(
+                "source {:?}: a source's name is how SQL reads it, so it is letters, digits and _, not starting with a digit",
+                block.name
+            ),
+        ));
+    }
+    let mut path = None;
+    let mut seen = false;
+    for attr in &block.attrs {
+        match attr.name.as_str() {
+            "path" if seen => diagnostics.push(Diagnostic::at_attr(
+                attr,
+                "Duplicate attribute: path",
+            )),
+            "path" => {
+                seen = true;
+                match string(attr, diagnostics) {
+                    Some(text) if text.trim().is_empty() => diagnostics.push(
+                        Diagnostic::at_attr(attr, "path names a file or a glob; it is empty"),
+                    ),
+                    Some(text) => {
+                        if let Some(message) = super::source::unreadable(&text) {
+                            diagnostics.push(Diagnostic::at_attr(attr, message));
+                        }
+                        path = Some(text);
+                    }
+                    None => {}
+                }
+            }
+            other => diagnostics.push(Diagnostic::at_attr(
+                attr,
+                format!("A source block holds only path; unknown attribute: {other}"),
+            )),
+        }
+    }
+    if !seen {
+        diagnostics.push(Diagnostic::at_block(
+            block,
+            format!("source block {:?} requires path", block.name),
+        ));
+    }
+    Some(Source {
+        name: block.name.clone(),
+        path: path.unwrap_or_default(),
+        line: block.line,
+        name_span: block.name_span,
+    })
+}
+
+fn filter(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Filter {
+    // `$name` in SQL ends at the first character that is not a letter, digit
+    // or underscore, so the name must be made of nothing else.
+    let mut chars = block.name.chars();
+    let identifier = chars
+        .next()
+        .is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
+        && chars.all(|c| c.is_ascii_alphanumeric() || c == '_');
+    if !identifier {
+        diagnostics.push(Diagnostic::at_block(
+            block,
+            format!(
+                "filter {:?}: a query reads a filter as $name, so its name is letters, digits and _, not starting with a digit",
+                block.name
+            ),
+        ));
+    }
+    let mut plot = None;
+    let mut column_name = None;
+    let mut seen: HashSet<&str> = HashSet::new();
+    for attr in &block.attrs {
+        if !seen.insert(attr.name.as_str()) {
+            diagnostics.push(Diagnostic::at_attr(
+                attr,
+                format!("Duplicate attribute: {}", attr.name),
+            ));
+            continue;
+        }
+        match attr.name.as_str() {
+            "plot" => match &attr.value {
+                Value::Ref(segments) if segments.len() == 2 && segments[0] == "plot" => {
+                    plot = Some(segments[1].clone())
+                }
+                _ => diagnostics.push(Diagnostic::at_attr(
+                    attr,
+                    "plot names the plot a value is picked on: plot = plot.some_name",
+                )),
+            },
+            "column" => column_name = column(attr, diagnostics),
+            other => diagnostics.push(Diagnostic::at_attr(
+                attr,
+                format!("A filter block holds plot and column; unknown attribute: {other}"),
+            )),
+        }
+    }
+    if !seen.contains("plot") {
+        diagnostics.push(Diagnostic::at_block(
+            block,
+            format!("filter block {:?} requires plot", block.name),
+        ));
+    }
+    Filter {
+        name: block.name.clone(),
+        plot: plot.unwrap_or_default(),
+        column: column_name.unwrap_or_default(),
+        line: block.line,
+        col: block.col,
+        span: block.kind_span,
+        name_span: block.name_span,
+    }
+}
+
 fn query(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Query> {
     let mut sql = None;
     let mut seen = false;
@@ -387,6 +689,8 @@ fn plot(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Plot> {
     let mut size = None;
     let mut size_scale = None;
     let mut tooltip = None;
+    let mut value = None;
+    let mut width = None;
     let mut seen: HashSet<&str> = HashSet::new();
     for attr in &block.attrs {
         if !seen.insert(attr.name.as_str()) {
@@ -439,16 +743,19 @@ fn plot(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Plot> {
                 None => {}
             },
             "tooltip" => tooltip = columns(attr, diagnostics),
+            "value" => value = column(attr, diagnostics),
+            "width" => width = grid_width(attr, diagnostics),
             other => diagnostics.push(Diagnostic::at_attr(
                 attr,
                 format!(
-                    "A plot block holds type, query, x, y, series, title, and for a map lat, lng, color, size, size_scale, tooltip; unknown attribute: {other}"
+                    "A plot block holds type, query, x, y, series, title, width, for a map lat, lng, color, size, size_scale, tooltip, and for a card value; unknown attribute: {other}"
                 ),
             )),
         }
     }
     let kind_name = kind.clone().unwrap_or_default();
     let is_map = kind_name == "map";
+    let is_card = kind_name == "card";
     // Attributes the type has no use for are mistakes, not no-ops: a map's
     // `x` or a line's `lat` says the author expects something that will not
     // happen.
@@ -457,8 +764,12 @@ fn plot(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Plot> {
         let misplaced = if is_map {
             matches!(name, "x" | "y" | "series")
                 .then(|| format!("A map plot places points by lat and lng; it takes no {name}"))
+        } else if is_card && (matches!(name, "x" | "y" | "series") || MAP_ATTRS.contains(&name)) {
+            Some(format!("A card shows one value; it takes no {name} (name its column with value)"))
         } else if !kind_name.is_empty() && MAP_ATTRS.contains(&name) {
             Some(format!("{name} is for map plots; this plot is a {kind_name}"))
+        } else if !kind_name.is_empty() && !is_card && CARD_ATTRS.contains(&name) {
+            Some(format!("{name} is for card plots; this plot is a {kind_name}"))
         } else if kind_name == "pie" && name == "series" {
             Some("A pie draws one series; it takes no series".to_string())
         } else {
@@ -474,7 +785,11 @@ fn plot(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Plot> {
             ));
         }
     }
-    let required: &[&str] = if is_map { &["type", "query"] } else { &["type", "query", "x"] };
+    let required: &[&str] = if is_map || is_card {
+        &["type", "query"]
+    } else {
+        &["type", "query", "x"]
+    };
     for &name in required {
         if !seen.contains(name) {
             diagnostics.push(Diagnostic::at_block(
@@ -487,7 +802,7 @@ fn plot(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Plot> {
     // is only for attributes never written. y is required once the type is
     // known to need one.
     let kind = kind.unwrap_or_default();
-    if !kind.is_empty() && kind != "table" && kind != "map" && y.is_none() {
+    if !kind.is_empty() && !matches!(kind.as_str(), "table" | "map" | "card") && y.is_none() {
         diagnostics.push(Diagnostic::at_block(
             block,
             format!("plot block {:?} requires y", block.name),
@@ -507,6 +822,8 @@ fn plot(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Plot> {
         size,
         size_scale,
         tooltip,
+        value,
+        width,
         line: block.line,
         col: block.col,
         span: block.kind_span,
@@ -514,6 +831,26 @@ fn plot(block: &Block, diagnostics: &mut Vec<Diagnostic>) -> Option<Plot> {
     })
 }
 
+/// A plot's `width`: a whole number of grid columns, 1 to 12.
+fn grid_width(attr: &Attr, diagnostics: &mut Vec<Diagnostic>) -> Option<u8> {
+    let parsed = match &attr.value {
+        Value::Number(text) => text.parse::<u8>().ok(),
+        _ => None,
+    };
+    match parsed {
+        Some(n) if (1..=GRID_COLUMNS).contains(&n) => Some(n),
+        _ => {
+            diagnostics.push(Diagnostic::at_attr(
+                attr,
+                format!(
+                    "width is how many of the dashboard's {GRID_COLUMNS} columns the plot spans: a whole number from 1 to {GRID_COLUMNS}"
+                ),
+            ));
+            None
+        }
+    }
+}
+
 /// A list of column names: `[place, requests, "Unique IPs"]`, not empty.
 fn columns(attr: &Attr, diagnostics: &mut Vec<Diagnostic>) -> Option<Vec<String>> {
     let Value::List(items) = &attr.value else {
@@ -591,6 +928,38 @@ pub(crate) type ColumnLookup<'a> = dyn Fn(&str) -> Result<Vec<(String, String)>,
 /// ask for. This is the half of checking that needs a live connection.
 pub(crate) fn check_columns(spec: &Spec, columns: &ColumnLookup) -> Vec<Diagnostic> {
     let mut diagnostics = Vec::new();
+    // A filter picks its column's value from the row the click lands on, so
+    // the picked plot's query must return it.
+    for filter in &spec.filters {
+        let Some(plot) = spec.plots.iter().find(|p| p.name == filter.plot) else {
+            continue;
+        };
+        let Ok(available) = columns(&plot.query) else {
+            continue; // the plot's own check reports the query
+        };
+        if !available
+            .iter()
+            .any(|(name, _)| name.eq_ignore_ascii_case(&filter.column))
+        {
+            diagnostics.push(Diagnostic {
+                line: filter.line,
+                col: filter.col,
+                span: filter.span,
+                message: format!(
+                    "filter {:?} picks column {:?}, which query {:?} (plot {:?}) does not return; it returns: {}",
+                    filter.name,
+                    filter.column,
+                    plot.query,
+                    plot.name,
+                    available
+                        .iter()
+                        .map(|(name, _)| name.as_str())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                ),
+            });
+        }
+    }
     for plot in &spec.plots {
         let Some(query) = spec.queries.iter().find(|q| q.name == plot.query) else {
             continue; // already reported by validate()
@@ -645,7 +1014,8 @@ pub(crate) fn check_columns(spec: &Spec, columns: &ColumnLookup) -> Vec<Diagnost
                 }
             }
         }
-        let x = (plot.kind != "map").then_some(plot.x.as_str());
+        let x = !matches!(plot.kind.as_str(), "map" | "card");
+        let x = x.then_some(plot.x.as_str());
         for (name, column) in [
             ("x", x),
             ("y", plot.y.as_deref()),
@@ -654,6 +1024,7 @@ pub(crate) fn check_columns(spec: &Spec, columns: &ColumnLookup) -> Vec<Diagnost
             ("lng", plot.lng.as_deref()),
             ("color", plot.color.as_deref()),
             ("size", plot.size.as_deref()),
+            ("value", plot.value.as_deref()),
         ]
         .into_iter()
         .chain(
@@ -704,6 +1075,17 @@ pub(crate) fn check_columns(spec: &Spec, columns: &ColumnLookup) -> Vec<Diagnost
             }
         }
         // A plotted y that is not a number draws nothing worth looking at.
+        if plot.kind == "card" && available.is_empty() {
+            diagnostics.push(Diagnostic {
+                line: plot.line,
+                col: plot.col,
+                span: plot.span,
+                message: format!(
+                    "card {:?}: query {:?} returns no columns to show",
+                    plot.name, query.name
+                ),
+            });
+        }
         if plot.kind != "table" {
             if let Some(y) = &plot.y {
                 if let Some((_, ty)) = available
@@ -767,6 +1149,89 @@ mod tests {
         validate(&file).expect_err("the spec should not validate")
     }
 
+    const FILTERED: &str = r#"
+query "by_channel" { sql = "SELECT channel, sum(revenue) AS revenue FROM orders GROUP BY 1" }
+query "daily" { sql = "SELECT date, sum(orders) AS orders FROM orders WHERE $channel GROUP BY 1" }
+query "rows" { sql = "SELECT id, channel FROM orders" }
+plot "channels" {
+  type = "bar"
+  query = query.by_channel
+  x = channel
+  y = revenue
+}
+plot "list" {
+  type = "table"
+  query = query.rows
+  x = id
+}
+plot "daily" {
+  type = "line"
+  query = query.daily
+  x = date
+  y = orders
+}
+filter "channel" { plot = plot.channels }
+filter "picked" {
+  plot = plot.list
+  column = id
+}
+"#;
+
+    #[test]
+    fn a_filter_picks_on_a_bar_or_a_table_and_queries_read_it() {
+        let spec = validate_ok(FILTERED);
+        assert_eq!(spec.filters.len(), 2);
+        // A bar's column defaults to its x; a table's is as written.
+        assert_eq!(spec.filters[0].column, "channel");
+        assert_eq!(spec.filters[1].column, "id");
+        let daily = spec.queries.iter().find(|q| q.name == "daily").unwrap();
+        let used: Vec<&str> = spec.filters_of(daily).iter().map(|f| f.name.as_str()).collect();
+        assert_eq!(used, ["channel"]);
+    }
+
+    #[test]
+    fn filter_mistakes_are_named() {
+        let unknown = FILTERED.replace("WHERE $channel", "WHERE $chanel");
+        let messages: Vec<String> = validate_err(&unknown).into_iter().map(|d| d.message).collect();
+        assert!(
+            messages.iter().any(|m| m.contains("$chanel") && m.contains("no filter block")),
+            "{messages:?}"
+        );
+
+        let on_a_line = FILTERED.replace("plot = plot.channels", "plot = plot.daily");
+        let messages: Vec<String> = validate_err(&on_a_line).into_iter().map(|d| d.message).collect();
+        assert!(messages.iter().any(|m| m.contains("a line")), "{messages:?}");
+
+        let missing = FILTERED.replace("plot = plot.channels", "plot = plot.nope");
+        let messages: Vec<String> = validate_err(&missing).into_iter().map(|d| d.message).collect();
+        assert!(messages.iter().any(|m| m.contains("does not define")), "{messages:?}");
+
+        let table_without_column = FILTERED.replace("  column = id\n", "");
+        let messages: Vec<String> =
+            validate_err(&table_without_column).into_iter().map(|d| d.message).collect();
+        assert!(messages.iter().any(|m| m.contains("name the column")), "{messages:?}");
+
+        let bad_name = FILTERED.replace("filter \"channel\"", "filter \"sales-channel\"");
+        let messages: Vec<String> = validate_err(&bad_name).into_iter().map(|d| d.message).collect();
+        assert!(messages.iter().any(|m| m.contains("letters, digits")), "{messages:?}");
+    }
+
+    #[test]
+    fn a_filter_column_the_picked_query_lacks_is_caught_with_a_database() {
+        let spec = validate_ok(&FILTERED.replace("column = id", "column = nope"));
+        let lookup = |name: &str| -> Result<Vec<(String, String)>, String> {
+            Ok(match name {
+                "by_channel" => vec![("channel".into(), "VARCHAR".into()), ("revenue".into(), "DOUBLE".into())],
+                "rows" => vec![("id".into(), "BIGINT".into()), ("channel".into(), "VARCHAR".into())],
+                _ => vec![("date".into(), "DATE".into()), ("orders".into(), "BIGINT".into())],
+            })
+        };
+        let messages: Vec<String> =
+            check_columns(&spec, &lookup).into_iter().map(|d| d.message).collect();
+        assert_eq!(messages.len(), 1, "{messages:?}");
+        assert!(messages[0].contains("\"nope\""), "{messages:?}");
+    }
+
     const GOOD: &str = r#"
 query "latency" {
   sql = <<SQL
@@ -1167,4 +1632,58 @@ plot "m" {
             "{messages:?}"
         );
     }
+
+    #[test]
+    fn sources_cards_and_widths_validate() {
+        let spec = validate_ok(
+            r#"
+source "orders" { path = "exports/*.parquet" }
+query "q" { sql = "SELECT count(*) AS n FROM orders" }
+plot "n" { type = "card" query = query.q value = n title = "Orders" }
+plot "first" { type = "card" query = query.q }
+plot "half" { type = "bar" query = query.q x = n y = n width = 6 }
+"#,
+        );
+        assert_eq!(spec.sources[0].name, "orders");
+        assert_eq!(spec.sources[0].path, "exports/*.parquet");
+        assert_eq!(spec.plots[0].value.as_deref(), Some("n"));
+        assert_eq!(spec.plots[1].value, None, "a card may leave its column out");
+        let widths: Vec<u8> = spec.plots.iter().map(Plot::width).collect();
+        assert_eq!(widths, [3, 3, 6]);
+    }
+
+    #[test]
+    fn source_card_and_width_mistakes_are_said() {
+        let diagnostics = validate_err(
+            r#"
+source "orders" { path = "o.csv" }
+source "ORDERS" { path = "p.csv" }
+source "has space" { path = "o.csv" }
+source "nopath" { glob = "o.csv" }
+source "book" { path = "b.xlsx" }
+query "q" { sql = "SELECT 1" }
+plot "a" { type = "card" query = query.q y = n series = s }
+plot "b" { type = "line" query = query.q x = t y = v value = v }
+plot "c" { type = "line" query = query.q x = t y = v width = 0 }
+plot "d" { type = "line" query = query.q x = t y = v width = "6" }
+"#,
+        );
+        let messages: Vec<&str> = diagnostics.iter().map(|d| d.message.as_str()).collect();
+        let has = |needle: &str| messages.iter().any(|m| m.contains(needle));
+        assert!(has("Duplicate source name: \"ORDERS\""), "{messages:?}");
+        assert!(has("source \"has space\""), "{messages:?}");
+        assert!(has("unknown attribute: glob"), "{messages:?}");
+        assert!(has("requires path"), "{messages:?}");
+        assert!(has("A workbook cannot be a source"), "{messages:?}");
+        assert!(has("A card shows one value; it takes no y"), "{messages:?}");
+        assert!(has("A card shows one value; it takes no series"), "{messages:?}");
+        assert!(has("value is for card plots"), "{messages:?}");
+        assert_eq!(
+            messages.iter().filter(|m| m.starts_with("width is")).count(),
+            2,
+            "{messages:?}"
+        );
+        // A card needs no x or y.
+        assert!(!has("requires x") && !has("requires y"), "{messages:?}");
+    }
 }
diff --git a/src/spec/plot.rs b/src/spec/plot.rs
index a6a37ee..089c9e5 100644
--- a/src/spec/plot.rs
+++ b/src/spec/plot.rs
@@ -142,8 +142,14 @@ pub(crate) struct GroupedBars {
     points: Vec<Arc<PlotPoint>>,
     series: Vec<SharedString>,
     label_count: usize,
+    /// The band a filter has picked: it keeps its colour and the rest fade,
+    /// so the plot says what the dashboard is narrowed to.
+    selected: Option<SharedString>,
 }
 
+/// How much of its opacity a bar outside the picked band keeps.
+const UNPICKED_OPACITY: f32 = 0.3;
+
 impl GroupedBars {
     pub(crate) fn new(id: impl Into<ElementId>, plot: &PreparedPlot) -> Self {
         Self::of(id, plot.points.clone(), &plot.series_names)
@@ -161,9 +167,32 @@ impl GroupedBars {
             label_count: x_label_count(&points),
             points,
             series: series_names.iter().map(SharedString::from).collect(),
+            selected: None,
         }
     }
 
+    pub(crate) fn selected(mut self, band: Option<SharedString>) -> Self {
+        self.selected = band;
+        self
+    }
+
+    /// The band under `position` — relative to the plot's origin, as the
+    /// tooltip's is — for a click to pick. The axis labels below the baseline
+    /// are not a band.
+    pub(crate) fn band_at(
+        &self,
+        position: Point<Pixels>,
+        bounds: Bounds<Pixels>,
+    ) -> Option<SharedString> {
+        let baseline = bounds.size.height.as_f32() - axis_gap();
+        if position.y.as_f32() > baseline || position.y.as_f32() < 0. {
+            return None;
+        }
+        let (band_scale, _) = self.scales(bounds);
+        let index = band_scale.nearest_index(position.x.as_f32());
+        self.points.get(index).map(|d| d.band.clone())
+    }
+
     /// The band and value scales for `bounds`, shared by `paint` and the
     /// tooltip so the bars and the hover band stay aligned. The value scale
     /// spans the data and zero, so a bar always grows from the zero line.
@@ -207,6 +236,7 @@ impl Plot for GroupedBars {
         let zero = value_scale.tick(&0.).unwrap_or(baseline);
         let palette = palette(cx);
         let n = self.series.len();
+        let selected = self.selected.clone();
 
         // The axis line sits at zero, which is mid-plot when the data crosses
         // it; the band labels stay at the bottom, clear of any bar.
@@ -263,7 +293,13 @@ impl Plot for GroupedBars {
             })
             .base(move |_| zero)
             .value(move |d: &(Arc<PlotPoint>, usize)| value_scale.tick(&d.0.values[d.1]))
-            .fill(move |d: &(Arc<PlotPoint>, usize), _, _| palette[d.1 % palette.len()])
+            .fill(move |d: &(Arc<PlotPoint>, usize), _, _| {
+                let color = palette[d.1 % palette.len()];
+                match &selected {
+                    Some(band) if *band != d.0.band => color.opacity(UNPICKED_OPACITY),
+                    _ => color,
+                }
+            })
             .paint(&bounds, window, cx);
     }
 
@@ -592,11 +628,39 @@ impl Plot for SeriesPlot {
 mod tests {
     // Deliberately not `use super::*`: that pulls in `gpui_kit::*`, whose
     // `test` macro shadows the built-in `#[test]`.
-    use super::{GROUP_GAP, group_slot, labeled, point_label_align, value_ticks, x_label_count};
+    use super::{
+        GROUP_GAP, GroupedBars, group_slot, labeled, point_label_align, value_ticks,
+        x_label_count,
+    };
     use crate::spec::prepare::PlotPoint;
-    use gpui_kit::{SharedString, TextAlign};
+    use gpui_kit::{Bounds, SharedString, TextAlign, point, px, size};
     use std::sync::Arc;
 
+    #[test]
+    fn a_click_finds_the_band_under_it() {
+        let points: Vec<Arc<PlotPoint>> = ["a", "b", "c"]
+            .iter()
+            .enumerate()
+            .map(|(ix, band)| {
+                Arc::new(PlotPoint {
+                    band: SharedString::from(*band),
+                    label: SharedString::new(""),
+                    values: vec![1.0],
+                    present: vec![true],
+                    ix,
+                })
+            })
+            .collect();
+        let bars = GroupedBars::of("t", points, &["y".to_string()]);
+        let bounds = Bounds::new(point(px(100.), px(50.)), size(px(300.), px(200.)));
+        let at = |x: f32, y: f32| bars.band_at(point(px(x), px(y)), bounds);
+        assert_eq!(at(10., 100.).as_deref(), Some("a"));
+        assert_eq!(at(150., 100.).as_deref(), Some("b"));
+        assert_eq!(at(290., 100.).as_deref(), Some("c"));
+        // The axis labels under the baseline are not a bar.
+        assert_eq!(at(150., 199.), None);
+    }
+
     #[test]
     fn a_group_tiles_its_band() {
         for series in 1..=12 {
diff --git a/src/spec/prepare.rs b/src/spec/prepare.rs
index fea6124..4719ebb 100644
--- a/src/spec/prepare.rs
+++ b/src/spec/prepare.rs
@@ -10,7 +10,8 @@
 //! A `pie` is the same matrix with one series, never merged or truncated —
 //! its slices must add up to the whole — then folded into its largest
 //! slices. A `map` skips the matrix: it is the results chart's `GeoData`,
-//! over the columns the spec names.
+//! over the columns the spec names. A `card` is one cell: its column's value
+//! in the first row, grouped by thousands when it is a plain number.
 //!
 //! Everything here is pure and tested as such; the view (`view.rs`) only
 //! renders what this prepares.
@@ -66,6 +67,10 @@ pub struct PreparedPlot {
     pub pie: Vec<Arc<PieSlice>>,
     /// A `map`'s points.
     pub geo: Option<Arc<GeoData>>,
+    /// A `card`'s value, ready to show.
+    pub card: Option<SharedString>,
+    /// Grid columns the plot spans, default applied.
+    pub width: u8,
     /// What was dropped or merged to keep the plot drawable.
     pub notice: Option<String>,
     /// Why there is nothing to draw: the query failed, or a column the plot
@@ -77,7 +82,10 @@ pub struct PreparedPlot {
 /// Prepare one plot from its query's result. `table` plots need no
 /// preparation — the view renders the result grid directly — and a plot whose
 /// query failed carries the failure instead of data.
-pub(crate) fn prepare(plot: &Plot, result: Option<&Result<QueryResult, String>>) -> PreparedPlot {
+pub(crate) fn prepare<R: std::borrow::Borrow<QueryResult>>(
+    plot: &Plot,
+    result: Option<&Result<R, String>>,
+) -> PreparedPlot {
     let base = |failure: Option<String>| PreparedPlot {
         name: plot.name.clone(),
         title: plot.title.clone().unwrap_or_else(|| plot.name.clone()),
@@ -88,26 +96,54 @@ pub(crate) fn prepare(plot: &Plot, result: Option<&Result<QueryResult, String>>)
         points: Vec::new(),
         pie: Vec::new(),
         geo: None,
+        card: None,
+        width: plot.width(),
         notice: None,
         failure,
     };
     let Some(result) = result else {
         return base(Some(trf("dashboard.query_missing", &[&plot.query])));
     };
-    let result = match result {
-        Ok(result) => result,
+    let result: &QueryResult = match result {
+        Ok(result) => result.borrow(),
         Err(error) => return base(Some(error.clone())),
     };
     if plot.kind == "table" {
         return base(None);
     }
-
     let column = |name: &str| {
         result
             .columns
             .iter()
             .position(|column| column.name.eq_ignore_ascii_case(name))
     };
+    if plot.kind == "card" {
+        let ix = match plot.value.as_deref() {
+            Some(name) => match column(name) {
+                Some(ix) => ix,
+                None => return base(Some(missing_column(name, result))),
+            },
+            None if result.columns.is_empty() => {
+                return base(Some(missing_column("value", result)))
+            }
+            None => 0,
+        };
+        let (value, notice) = match result.rows.first() {
+            Some(row) => (
+                group_thousands(row.get(ix).map(String::as_str).unwrap_or("")),
+                (result.rows.len() > 1)
+                    .then(|| trf("dashboard.card.first_row", &[&result.rows.len().to_string()])),
+            ),
+            None => ("—".to_string(), Some(crate::i18n::tr("dashboard.card.no_rows").to_string())),
+        };
+        return PreparedPlot {
+            label_name: result.columns[ix].name.clone(),
+            card: Some(SharedString::from(value)),
+            notice,
+            ..base(None)
+        };
+    }
+
     if plot.kind == "map" {
         // Named columns are taken at their word; a missing one is found by
         // name among the numeric columns, as the results chart finds them.
@@ -380,11 +416,42 @@ pub(crate) fn prepare(plot: &Plot, result: Option<&Result<QueryResult, String>>)
         points,
         pie,
         geo: None,
+        card: None,
+        width: plot.width(),
         notice: (!notices.is_empty()).then(|| notices.join(" · ")),
         failure: None,
     }
 }
 
+/// A cell as a card shows it: a plain decimal number with its integer part
+/// grouped by thousands (`1859708` → `1,859,708`), anything else — a date, a
+/// word, an exponent — exactly as the database wrote it.
+fn group_thousands(cell: &str) -> String {
+    let (sign, unsigned) = match cell.strip_prefix('-') {
+        Some(rest) => ("-", rest),
+        None => ("", cell),
+    };
+    let (int, frac) = match unsigned.split_once('.') {
+        Some((int, frac)) => (int, Some(frac)),
+        None => (unsigned, None),
+    };
+    let digits = |s: &str| !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit());
+    if !digits(int) || frac.is_some_and(|f| !digits(f)) {
+        return cell.to_string();
+    }
+    let mut grouped = String::with_capacity(int.len() + int.len() / 3);
+    for (ix, ch) in int.chars().enumerate() {
+        if ix > 0 && (int.len() - ix) % 3 == 0 {
+            grouped.push(',');
+        }
+        grouped.push(ch);
+    }
+    match frac {
+        Some(frac) => format!("{sign}{grouped}.{frac}"),
+        None => format!("{sign}{grouped}"),
+    }
+}
+
 /// Why a `map` with no `lat` or `lng` has nothing to place.
 fn missing_coordinates(result: &QueryResult) -> String {
     let available = result
@@ -426,6 +493,8 @@ mod tests {
             size: None,
             size_scale: None,
             tooltip: None,
+            value: None,
+            width: None,
             line: 1,
             col: 1,
             span: (0, 4),
@@ -532,7 +601,7 @@ mod tests {
     fn a_failed_query_carries_its_error() {
         let prepared = prepare(
             &plot("bar", Some("y"), None),
-            Some(&Err("boom".to_string())),
+            Some(&Err::<QueryResult, _>("boom".to_string())),
         );
         assert_eq!(prepared.failure.as_deref(), Some("boom"));
     }
@@ -664,4 +733,41 @@ mod tests {
         assert_eq!(total, (1..=300).sum::<i64>() as f64);
         assert!(pie.notice.unwrap().contains('1'), "the negative band is reported");
     }
+
+    #[test]
+    fn a_card_shows_its_first_row_grouped() {
+        let data = || {
+            Ok(result(
+                vec![
+                    column("label", ColumnKind::Text),
+                    column("total", ColumnKind::Numeric),
+                ],
+                vec![vec!["all", "1859708"], vec!["more", "2"]],
+            ))
+        };
+        let card = |value: Option<&str>| Plot {
+            value: value.map(str::to_string),
+            ..plot("card", None, None)
+        };
+        let shown = prepare(&card(Some("total")), Some(&data()));
+        assert_eq!(shown.card.as_ref().map(|c| c.as_ref()), Some("1,859,708"));
+        assert_eq!(shown.width, 3, "a card is a quarter row by default");
+        assert!(shown.notice.is_some(), "a second row is said, not shown");
+        // Left out, the value is the first column.
+        let first = prepare(&card(None), Some(&data()));
+        assert_eq!(first.card.as_ref().map(|c| c.as_ref()), Some("all"));
+        let missing = prepare(&card(Some("nope")), Some(&data()));
+        assert!(missing.failure.unwrap().contains("nope"));
+        assert_eq!(prepare(&plot("line", Some("y"), None), Some(&data())).width, 12);
+    }
+
+    #[test]
+    fn only_plain_numbers_are_grouped() {
+        assert_eq!(group_thousands("1234567.891"), "1,234,567.891");
+        assert_eq!(group_thousands("-1000"), "-1,000");
+        assert_eq!(group_thousands("999"), "999");
+        assert_eq!(group_thousands("1e10"), "1e10");
+        assert_eq!(group_thousands("2026-09-30"), "2026-09-30");
+        assert_eq!(group_thousands(""), "");
+    }
 }
diff --git a/src/spec/source.rs b/src/spec/source.rs
new file mode 100644
index 0000000..9d15a41
--- /dev/null
+++ b/src/spec/source.rs
@@ -0,0 +1,230 @@
+//! `source` blocks: data files under a name, for the queries to read.
+//!
+//! A query that reads `FROM 'exports/amount-2026-09-01.csv'` is tied to the
+//! working directory it runs from and to that one file's name. A source says
+//! the where once, beside the spec:
+//!
+//! ```text
+//! source "usage" { path = "exports/amount-*.csv" }
+//! query "by_type" { sql = "SELECT type, sum(amount) FROM usage GROUP BY 1" }
+//! ```
+//!
+//! The path is relative to the `.dash` file's own folder, so the spec and its
+//! data move together; a glob reads every match as one relation.
+//!
+//! A source never touches the connection. The dashboard runs on the window's
+//! session, and a view created there would show up in the user's catalog,
+//! outlive the tab, and collide with a second dashboard's `orders`. Instead
+//! each query that names a source gets it as a CTE in front of its own SQL —
+//! so a source shadows a table of the same name for that query only, and
+//! nothing outside the query can see it. The rewrite adds only a
+//! `SELECT * FROM reader('path')`, which reads; the read-only check runs on
+//! the query as written.
+
+use std::path::{Path, PathBuf};
+
+use super::model::Source;
+
+/// Why a path cannot be a source, judged by its extension: the readers a
+/// source can use are DuckDB's own table functions. `None` when it can.
+pub(crate) fn unreadable(path: &str) -> Option<String> {
+    if crate::db::data_file_reader(path).is_some() {
+        return None;
+    }
+    Some(if crate::db::is_excel_file(path) {
+        "A workbook cannot be a source; open it in DuckLocal and query the table it becomes"
+            .to_string()
+    } else {
+        format!(
+            "path {path:?}: a source reads .csv, .tsv, .txt, .parquet, .json, .jsonl or .ndjson files"
+        )
+    })
+}
+
+/// A source's path as a real one: `~` expanded, relative paths joined to the
+/// spec's folder, and the result absolute — the GUI's working directory is
+/// wherever it was launched from, which is no anchor at all.
+pub(crate) fn resolve(path: &str, base: &Path) -> PathBuf {
+    let expanded = PathBuf::from(crate::db::expand_tilde(path));
+    let joined = if expanded.is_absolute() {
+        expanded
+    } else {
+        base.join(expanded)
+    };
+    std::path::absolute(&joined).unwrap_or(joined)
+}
+
+/// The folder a spec's relative source paths start from.
+pub(crate) fn base_of(spec_path: &Path) -> PathBuf {
+    spec_path
+        .parent()
+        .map(Path::to_path_buf)
+        .unwrap_or_default()
+}
+
+/// `sql` with every source it names defined in front of it, as CTEs. A query
+/// that names none comes back as written.
+///
+/// Which sources a query names is a word match, case-insensitive like SQL
+/// names: a false match — the word inside a string literal — only adds a CTE
+/// nothing reads, and DuckDB does not scan a CTE nothing reads.
+pub(crate) fn expand(sql: &str, sources: &[Source], base: &Path) -> String {
+    let words = words(sql);
+    let used: Vec<&Source> = sources
+        .iter()
+        .filter(|source| words.iter().any(|w| w.eq_ignore_ascii_case(&source.name)))
+        .collect();
+    if used.is_empty() {
+        return sql.to_string();
+    }
+    let ctes = used
+        .iter()
+        .map(|source| {
+            let path = resolve(&source.path, base).to_string_lossy().into_owned();
+            // Validation has already said the extension has a reader.
+            let reader = crate::db::data_file_reader(&path).unwrap_or("read_csv_auto");
+            format!(
+                "\"{}\" AS (SELECT * FROM {reader}('{}'))",
+                source.name.replace('"', "\"\""),
+                path.replace('\'', "''")
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(",\n");
+
+    let body = skip_comments(sql);
+    let (keyword, rest) = leading_word(body);
+    match keyword.to_ascii_lowercase().as_str() {
+        // Join the query's own CTE list; RECURSIVE applies to the whole list,
+        // so it stays in front.
+        "with" => {
+            let (next, after) = leading_word(rest.trim_start());
+            if next.eq_ignore_ascii_case("recursive") {
+                format!("WITH RECURSIVE {ctes},\n{}", after.trim_start())
+            } else {
+                format!("WITH {ctes},\n{}", rest.trim_start())
+            }
+        }
+        "select" | "from" => format!("WITH {ctes}\n{body}"),
+        // SHOW, DESCRIBE, SUMMARIZE, VALUES, PIVOT, TABLE: statements a CTE
+        // cannot lead, but a subquery can hold. The newline before the
+        // parenthesis keeps a trailing `--` comment from swallowing it.
+        _ => {
+            let inner = body.trim_end().trim_end_matches(';');
+            format!("WITH {ctes}\nSELECT * FROM (\n{inner}\n)")
+        }
+    }
+}
+
+/// The identifier-shaped words of `sql`, for matching source names.
+fn words(sql: &str) -> Vec<&str> {
+    sql.split(|c: char| !(c.is_ascii_alphanumeric() || c == '_'))
+        .filter(|w| !w.is_empty())
+        .collect()
+}
+
+/// `sql` past its leading whitespace and comments, both `--` and `/* */`.
+fn skip_comments(sql: &str) -> &str {
+    let mut rest = sql.trim_start();
+    loop {
+        if let Some(after) = rest.strip_prefix("--") {
+            rest = after.find('\n').map(|ix| &after[ix + 1..]).unwrap_or("").trim_start();
+        } else if let Some(after) = rest.strip_prefix("/*") {
+            rest = after.find("*/").map(|ix| &after[ix + 2..]).unwrap_or("").trim_start();
+        } else {
+            return rest;
+        }
+    }
+}
+
+/// The leading ASCII word of `text` and what follows it.
+fn leading_word(text: &str) -> (&str, &str) {
+    let end = text
+        .find(|c: char| !c.is_ascii_alphabetic())
+        .unwrap_or(text.len());
+    text.split_at(end)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn source(name: &str, path: &str) -> Source {
+        Source {
+            name: name.into(),
+            path: path.into(),
+            line: 1,
+            name_span: (7, 10),
+        }
+    }
+
+    #[test]
+    fn a_query_that_names_no_source_runs_as_written() {
+        let sources = [source("orders", "orders.csv")];
+        let sql = "SELECT * FROM customers";
+        assert_eq!(expand(sql, &sources, Path::new("/data")), sql);
+        // Part of a longer word is not the name.
+        let sql = "SELECT * FROM orders_2026";
+        assert_eq!(expand(sql, &sources, Path::new("/data")), sql);
+    }
+
+    #[test]
+    fn a_named_source_becomes_a_cte_read_from_the_specs_folder() {
+        let sources = [source("orders", "exports/o*.csv"), source("unused", "u.parquet")];
+        let sql = expand(
+            "SELECT channel FROM ORDERS GROUP BY 1",
+            &sources,
+            Path::new("/data/dash"),
+        );
+        assert_eq!(
+            sql,
+            "WITH \"orders\" AS (SELECT * FROM read_csv_auto('/data/dash/exports/o*.csv'))\nSELECT channel FROM ORDERS GROUP BY 1"
+        );
+        assert!(!sql.contains("unused"), "{sql}");
+    }
+
+    #[test]
+    fn a_query_with_its_own_ctes_keeps_them() {
+        let sources = [source("orders", "/abs/o.parquet")];
+        let base = Path::new("/ignored");
+        assert_eq!(
+            expand("-- note\nWITH t AS (FROM orders) SELECT * FROM t", &sources, base),
+            "WITH \"orders\" AS (SELECT * FROM read_parquet('/abs/o.parquet')),\nt AS (FROM orders) SELECT * FROM t"
+        );
+        assert_eq!(
+            expand("with recursive t AS (FROM orders) FROM t", &sources, base),
+            "WITH RECURSIVE \"orders\" AS (SELECT * FROM read_parquet('/abs/o.parquet')),\nt AS (FROM orders) FROM t"
+        );
+    }
+
+    #[test]
+    fn statements_a_cte_cannot_lead_are_wrapped() {
+        let sources = [source("orders", "/abs/o.json")];
+        assert_eq!(
+            expand("SUMMARIZE orders; -- all of it", &sources, Path::new("/")),
+            "WITH \"orders\" AS (SELECT * FROM read_json_auto('/abs/o.json'))\nSELECT * FROM (\nSUMMARIZE orders; -- all of it\n)"
+        );
+    }
+
+    #[test]
+    fn quotes_in_a_path_stay_inside_the_literal() {
+        let sources = [source("o", "it's.csv")];
+        let sql = expand("FROM o", &sources, Path::new("/d"));
+        assert!(sql.contains("('/d/it''s.csv')"), "{sql}");
+    }
+
+    #[test]
+    fn relative_paths_follow_the_spec_and_absolute_ones_stay() {
+        assert_eq!(resolve("a/b.csv", Path::new("/x/y")), PathBuf::from("/x/y/a/b.csv"));
+        assert_eq!(resolve("/abs.csv", Path::new("/x/y")), PathBuf::from("/abs.csv"));
+        assert_eq!(base_of(Path::new("/x/y/d.dash")), PathBuf::from("/x/y"));
+    }
+
+    #[test]
+    fn only_readable_extensions_are_sources() {
+        assert_eq!(unreadable("logs/*.parquet"), None);
+        assert_eq!(unreadable("a.TSV"), None);
+        assert!(unreadable("book.xlsx").unwrap().contains("workbook"));
+        assert!(unreadable("data").unwrap().contains(".csv"));
+    }
+}
diff --git a/src/spec/view.rs b/src/spec/view.rs
index 257fd5c..7bc4cb1 100644
--- a/src/spec/view.rs
+++ b/src/spec/view.rs
@@ -2,9 +2,10 @@
 //!
 //! `mod.rs` checks a spec without a window; this module draws one. A
 //! `Dashboard` parses and validates its file, runs every query on the window's
-//! connection, and renders each plot as one panel of a vertical resizable
-//! stack — the plot heights are the user's to drag, and a stack taller than
-//! the tab scrolls. The data a plot draws is
+//! connection, and lays the plots out on a twelve-column grid: each plot
+//! spans its `width`, plots fill a row left to right and wrap, and each row is
+//! one panel of a vertical resizable stack — the row heights are the user's
+//! to drag, and a stack taller than the tab scrolls. The data a plot draws is
 //! `prepare`'s business; the view only renders what it prepares. A plot whose
 //! query failed, or whose columns do not resolve, shows the reason in its own
 //! panel: one bad plot never takes the dashboard down. And a reload follows
@@ -17,6 +18,13 @@
 //! grouped bars, bare lines, unconnected dots — on the same primitives the
 //! catalog charts compose.
 //!
+//! A `filter` block makes a plot pickable: a click on a bar, or on a table's
+//! row, picks a value, and every query that reads `$name` re-runs with it —
+//! only those, and only when the SQL they would run has changed; the picking
+//! plot's own queries never narrow (see `filter.rs`). The picks show as chips
+//! above the plots, each clearing its own; a click on the picked bar again
+//! clears it too.
+//!
 //! The toolbar's source toggle swaps the whole body for the spec's text in an
 //! editor — not a read-only one: the source is where a dashboard is fixed.
 //! Edits are written back with the save button or ⌘S, and a save reloads; a
@@ -25,6 +33,7 @@
 //! a dirty dot, and an external change to the file is a conflict banner
 //! rather than a silent overwrite; with a clean buffer it just reloads.
 
+use std::cell::Cell;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
@@ -32,6 +41,7 @@ use std::sync::Arc;
 use std::time::Instant;
 
 use gpui_kit::component::alert::Alert;
+use gpui_kit::component::button::{Button, ButtonVariants};
 use gpui_kit::component::chart::{AreaChart, BarChart, LineChart};
 use gpui_kit::component::input::{
     CompletionProvider, Editor, EditorState, Rope, RopeExt, TabSize,
@@ -40,9 +50,11 @@ use gpui_kit::component::label::Label;
 use gpui_kit::component::resizable::{resizable_panel, v_resizable};
 use gpui_kit::component::scroll::ScrollableElement as _;
 use gpui_kit::component::spinner::Spinner;
-use gpui_kit::component::table::{Column, DataTable, TableDelegate, TableState};
+use gpui_kit::component::table::{Column, DataTable, TableDelegate, TableEvent, TableState};
 use gpui_kit::component::{h_flex, v_flex, ActiveTheme, Icon, IconName, Sizable, StyledExt};
 use gpui_kit::prelude::FluentBuilder;
+
+use super::wheel::WheelLatch;
 use gpui_kit::*;
 
 use lsp_types::{
@@ -54,6 +66,7 @@ use crate::analysis::watch::{Debounce, FileStamp, POLL_INTERVAL};
 use crate::i18n::{tr, trf};
 use crate::query::{ColumnKind, QueryOutcome, QueryResult};
 use crate::spec::complete::{self, CompletionKind};
+use crate::spec::filter::Pick;
 use crate::spec::model::{self, Spec};
 use crate::spec::plot::{GroupedBars, SeriesPlot, x_label_count};
 use crate::ui::chart::{format_value, legend_row, map_notes, pie_parts};
@@ -67,6 +80,10 @@ use crate::ui::results::fit_column_width;
 const PLOT_DEFAULT: f32 = 300.;
 const PLOT_MIN: f32 = 160.;
 const PLOT_MAX: f32 = 800.;
+/// A row of nothing but cards holds one number each: it starts short.
+const CARD_DEFAULT: f32 = 104.;
+const CARD_MIN: f32 = 80.;
+const CARD_MAX: f32 = 400.;
 
 /// A `.dash` file open as a tab: its plots, and the run that produced them.
 pub struct Dashboard {
@@ -109,8 +126,31 @@ pub struct Dashboard {
     /// Polls the spec file for external changes. Dropping it ends the
     /// watcher, which is how closing the tab stops watching.
     watcher: Option<Task<()>>,
+    /// Which scroller the wheel gesture in progress moves: a table plot, or
+    /// the stack it sits in (see `wheel`).
+    wheel: WheelLatch,
+    /// The spec the plots on screen came from: which filters exist and which
+    /// plot each picks on.
+    spec: Option<Arc<Spec>>,
+    /// What each filter has picked, by filter name. Survives reloads for as
+    /// long as the filter does.
+    picks: HashMap<String, Pick>,
+    /// Each query's last outcome and the SQL that produced it: a re-run after
+    /// a pick reuses every query whose SQL the pick did not change.
+    outcomes: Outcomes,
+    /// A pick changed while a run was in flight: run again when it lands.
+    refilter_pending: bool,
+    /// Where each pickable plot was last laid out, by plot name, for a click
+    /// to find its bar.
+    plot_bounds: HashMap<String, Rc<Cell<Option<Bounds<Pixels>>>>>,
+    /// Row-selection subscriptions of the pickable tables, by table entity;
+    /// dropped with them.
+    table_subscriptions: Vec<(EntityId, Subscription)>,
 }
 
+/// Each query's outcome by name, with the SQL that ran.
+type Outcomes = HashMap<String, (String, Result<Arc<QueryResult>, String>)>;
+
 impl Dashboard {
     pub fn new(id: u64, path: PathBuf, cx: &mut Context<Self>) -> Self {
         let known_stamp = FileStamp::capture(&path);
@@ -131,6 +171,13 @@ impl Dashboard {
             known_stamp,
             conflict: false,
             watcher: None,
+            wheel: WheelLatch::default(),
+            spec: None,
+            picks: HashMap::new(),
+            outcomes: HashMap::new(),
+            refilter_pending: false,
+            plot_bounds: HashMap::new(),
+            table_subscriptions: Vec::new(),
         };
         this.watch(cx);
         this.reload(cx);
@@ -141,6 +188,41 @@ impl Dashboard {
         self.running
     }
 
+    /// What the tab shows, for `ducklocal open --state`: each plot and whether it
+    /// drew, and every filter with the value it has picked, if any.
+    pub fn summary(&self) -> serde_json::Value {
+        use serde_json::json;
+        let filters = self.spec.as_ref().map_or_else(Vec::new, |spec| {
+            spec.filters
+                .iter()
+                .map(|filter| {
+                    let pick = self.picks.get(&filter.name);
+                    json!({
+                        "name": filter.name,
+                        "plot": filter.plot,
+                        "column": filter.column,
+                        "picked": pick.is_some(),
+                        "value": pick.and_then(|pick| pick.value.clone()),
+                    })
+                })
+                .collect()
+        });
+        json!({
+            "running": self.running,
+            "error": self.spec_error,
+            "stale": self.stale_reason,
+            "plots": self.plots.iter().map(|plot| json!({
+                "name": plot.name,
+                "type": plot.kind,
+                "title": plot.title,
+                "query": plot.query,
+                "failure": plot.failure,
+                "rows": self.results.get(&plot.query).map(|r| r.rows.len()),
+            })).collect::<Vec<_>>(),
+            "filters": filters,
+        })
+    }
+
     pub fn is_showing_source(&self) -> bool {
         self.showing_source
     }
@@ -267,11 +349,27 @@ impl Dashboard {
             // reload is no reason to lose it.
             self.read_source();
         }
+        // A reload re-reads the data as well as the spec: nothing is reused.
+        self.start_run(HashMap::new(), cx);
+    }
+
+    /// Re-run after a pick changed: every query whose SQL the picks leave as
+    /// it was keeps its result, so only the narrowed plots redraw.
+    fn refilter(&mut self, cx: &mut Context<Self>) {
+        if self.running {
+            self.refilter_pending = true;
+            return;
+        }
+        self.start_run(self.outcomes.clone(), cx);
+    }
+
+    fn start_run(&mut self, reuse: Outcomes, cx: &mut Context<Self>) {
         self.running = true;
         cx.notify();
         let path = self.path.clone();
+        let picks = self.picks.clone();
         cx.spawn(async move |this, cx| {
-            let run = smol::unblock(move || load(&path)).await;
+            let run = smol::unblock(move || load(&path, &picks, &reuse)).await;
             this.update(cx, |this, cx| {
                 this.running = false;
                 match run.spec_error {
@@ -285,11 +383,46 @@ impl Dashboard {
                     spec_error => {
                         this.spec_error = spec_error;
                         this.stale_reason = None;
+                        // A table whose query came back as the very same
+                        // result keeps its entity: its scroll position and
+                        // its selected row — the pick — are the user's.
+                        let tables = run
+                            .plots
+                            .iter()
+                            .map(|plot| {
+                                let old = this
+                                    .plots
+                                    .iter()
+                                    .position(|p| p.name == plot.name && p.kind == "table")?;
+                                let same = match (
+                                    this.results.get(&plot.query),
+                                    run.results.get(&plot.query),
+                                ) {
+                                    (Some(a), Some(b)) => Arc::ptr_eq(a, b),
+                                    _ => false,
+                                };
+                                same.then(|| this.tables.get(old).cloned().flatten()).flatten()
+                            })
+                            .collect::<Vec<_>>();
+                        this.table_subscriptions.retain(|(id, _)| {
+                            tables.iter().flatten().any(|table| table.entity_id() == *id)
+                        });
+                        this.tables = tables;
                         this.plots = run.plots;
                         this.results = run.results;
-                        this.tables = vec![None; this.plots.len()];
+                        this.outcomes = run.outcomes;
+                        this.spec = run.spec;
+                        // A pick whose filter is gone from the spec goes too.
+                        let spec = this.spec.clone();
+                        this.picks.retain(|name, _| {
+                            spec.as_ref()
+                                .is_some_and(|spec| spec.filters.iter().any(|f| &f.name == name))
+                        });
                     }
                 }
+                if std::mem::take(&mut this.refilter_pending) {
+                    this.refilter(cx);
+                }
                 cx.notify();
             })
             .ok();
@@ -297,12 +430,199 @@ impl Dashboard {
         .detach();
     }
 
+    /// Whether a click on this plot picks a value: some filter names it.
+    fn is_pickable(&self, plot: &str) -> bool {
+        self.spec
+            .as_ref()
+            .is_some_and(|spec| spec.filters.iter().any(|f| f.plot == plot))
+    }
+
+    /// The band a bar plot shows as picked: the value of a filter that picks
+    /// the plot's own x.
+    fn picked_band(&self, plot: &PreparedPlot) -> Option<SharedString> {
+        let spec = self.spec.as_ref()?;
+        spec.filters
+            .iter()
+            .filter(|f| f.plot == plot.name && f.column.eq_ignore_ascii_case(&plot.label_name))
+            .find_map(|f| self.picks.get(&f.name))
+            .map(|pick| SharedString::from(pick.value.clone().unwrap_or_else(|| "NULL".into())))
+    }
+
+    /// A click on a pickable bar plot: the band under it becomes the pick —
+    /// or, when it is the band already picked, the pick is cleared.
+    fn bar_clicked(&mut self, ix: usize, position: Point<Pixels>, cx: &mut Context<Self>) {
+        let plot = &self.plots[ix];
+        let Some(bounds) = self.plot_bounds.get(&plot.name).and_then(|cell| cell.get()) else {
+            return;
+        };
+        let local = point(position.x - bounds.origin.x, position.y - bounds.origin.y);
+        let Some(band) = GroupedBars::new("dashboard-hit", plot).band_at(local, bounds) else {
+            return;
+        };
+        let Some(result) = self.results.get(&plot.query).cloned() else {
+            return;
+        };
+        // The row the bar came from: the first whose x is the band.
+        let Some(x) = result
+            .columns
+            .iter()
+            .position(|c| c.name.eq_ignore_ascii_case(&plot.label_name))
+        else {
+            return;
+        };
+        let Some(row) = result
+            .rows
+            .iter()
+            .position(|row| row.get(x).is_some_and(|cell| cell.as_str() == band.as_ref()))
+        else {
+            return;
+        };
+        let name = plot.name.clone();
+        self.pick_row(&name, &result, row, true, cx);
+    }
+
+    /// Pick, for every filter on `plot`, its column's value in `row`. With
+    /// `toggle`, a pick that is already the one made clears instead.
+    fn pick_row(
+        &mut self,
+        plot: &str,
+        result: &QueryResult,
+        row: usize,
+        toggle: bool,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(spec) = self.spec.clone() else {
+            return;
+        };
+        let mut changed = false;
+        for filter in spec.filters.iter().filter(|f| f.plot == plot) {
+            let Some(column) = result
+                .columns
+                .iter()
+                .position(|c| c.name.eq_ignore_ascii_case(&filter.column))
+            else {
+                continue;
+            };
+            let Some(cell) = result.rows.get(row).and_then(|r| r.get(column)) else {
+                continue;
+            };
+            let pick = Pick {
+                column: filter.column.clone(),
+                // The grid's NULL is SQL's: compared with IS NULL.
+                value: (cell != "NULL").then(|| cell.clone()),
+            };
+            if self.picks.get(&filter.name) == Some(&pick) {
+                if toggle {
+                    self.picks.remove(&filter.name);
+                    changed = true;
+                }
+            } else {
+                self.picks.insert(filter.name.clone(), pick);
+                changed = true;
+            }
+        }
+        if changed {
+            self.refilter(cx);
+            cx.notify();
+        }
+    }
+
+    /// Clear one filter's pick, or every pick; a table it was picked on lets
+    /// go of its selected row.
+    fn clear_picks(&mut self, only: Option<&str>, cx: &mut Context<Self>) {
+        let cleared: Vec<String> = self
+            .picks
+            .keys()
+            .filter(|name| only.is_none_or(|only| only == name.as_str()))
+            .cloned()
+            .collect();
+        if cleared.is_empty() {
+            return;
+        }
+        for name in &cleared {
+            self.picks.remove(name);
+        }
+        if let Some(spec) = self.spec.clone() {
+            for filter in spec.filters.iter().filter(|f| cleared.contains(&f.name)) {
+                for (ix, plot) in self.plots.iter().enumerate() {
+                    if plot.name == filter.plot {
+                        if let Some(Some(table)) = self.tables.get(ix) {
+                            table.update(cx, |table, cx| table.clear_selection(cx));
+                        }
+                    }
+                }
+            }
+        }
+        self.refilter(cx);
+        cx.notify();
+    }
+
+    /// The picks in force, as chips above the plots: each says what it
+    /// narrows to and clears on its ✕.
+    fn render_picks(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
+        if self.picks.is_empty() {
+            return None;
+        }
+        let spec = self.spec.clone()?;
+        let chips = spec
+            .filters
+            .iter()
+            .filter_map(|filter| Some((filter, self.picks.get(&filter.name)?)))
+            .enumerate()
+            .map(|(ix, (filter, pick))| {
+                let name = filter.name.clone();
+                let value = pick.value.clone().unwrap_or_else(|| "NULL".into());
+                Button::new(("dashboard-pick", ix))
+                    .outline()
+                    .xsmall()
+                    .label(format!("{} = {value}", filter.column))
+                    .icon(IconName::Close)
+                    .tooltip(tr("dashboard.filter.clear"))
+                    .on_click(cx.listener(move |this, _, _, cx| {
+                        this.clear_picks(Some(&name), cx)
+                    }))
+            })
+            .collect::<Vec<_>>();
+        let several = chips.len() > 1;
+        Some(
+            h_flex()
+                .flex_none()
+                .flex_wrap()
+                .gap_2()
+                .px_3()
+                .py_1p5()
+                .items_center()
+                .border_b_1()
+                .border_color(cx.theme().border)
+                .child(
+                    div()
+                        .text_xs()
+                        .text_color(cx.theme().muted_foreground)
+                        .child(tr("dashboard.filter.label")),
+                )
+                .children(chips)
+                .when(several, |this| {
+                    this.child(
+                        Button::new("dashboard-picks-clear")
+                            .ghost()
+                            .xsmall()
+                            .label(tr("dashboard.filter.clear_all"))
+                            .on_click(cx.listener(|this, _, _, cx| this.clear_picks(None, cx))),
+                    )
+                })
+                .into_any_element(),
+        )
+    }
+
     fn render_plot(
         &mut self,
         ix: usize,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> AnyElement {
+        if self.plots[ix].kind == "card" && self.plots[ix].failure.is_none() {
+            return render_card(&self.plots[ix], cx);
+        }
         let (title, mut notice, failure, is_table, is_empty) = {
             let plot = &self.plots[ix];
             let is_empty = match plot.kind.as_str() {
@@ -322,6 +642,13 @@ impl Dashboard {
         // x column — for a pie, what the shares are of; for a map, which
         // columns place the points. Tables and failures have nothing to say.
         let drawn = !is_table && failure.is_none() && !is_empty;
+        if failure.is_none() && self.is_pickable(&self.plots[ix].name) {
+            let hint = tr("dashboard.filter.hint").to_string();
+            notice = Some(match notice.take() {
+                Some(notice) => format!("{notice} · {hint}"),
+                None => hint,
+            });
+        }
         let mut legend = Vec::new();
         let axes = drawn.then(|| {
             let plot = &self.plots[ix];
@@ -359,6 +686,45 @@ impl Dashboard {
             self.render_table(ix, window, cx)
         } else if is_empty {
             empty_chart(cx)
+        } else if self.plots[ix].kind == "bar" && self.is_pickable(&self.plots[ix].name) {
+            let picked = self.picked_band(&self.plots[ix]);
+            let chart = GroupedBars::new(
+                (ElementId::from("dashboard-chart"), self.plots[ix].name.clone()),
+                &self.plots[ix],
+            )
+            .selected(picked);
+            // The chart fills this box, so the box's bounds are the chart's:
+            // the canvas records them for the click to hit-test against.
+            let bounds = self
+                .plot_bounds
+                .entry(self.plots[ix].name.clone())
+                .or_default()
+                .clone();
+            div()
+                .size_full()
+                .px_2()
+                .pb_2()
+                .child(
+                    div()
+                        .size_full()
+                        .relative()
+                        .cursor_pointer()
+                        .child(chart)
+                        .child(
+                            canvas(move |b, _, _| bounds.set(Some(b)), |_, _, _, _| {})
+                                .absolute()
+                                .top_0()
+                                .left_0()
+                                .size_full(),
+                        )
+                        .on_mouse_down(
+                            MouseButton::Left,
+                            cx.listener(move |this, event: &MouseDownEvent, _, cx| {
+                                this.bar_clicked(ix, event.position, cx)
+                            }),
+                        ),
+                )
+                .into_any_element()
         } else {
             div()
                 .size_full()
@@ -425,11 +791,26 @@ impl Dashboard {
         };
         if self.tables[ix].is_none() {
             let delegate = SpecTableDelegate::new(result.clone());
-            self.tables[ix] = Some(cx.new(|cx| TableState::new(delegate, window, cx)));
+            let table = cx.new(|cx| TableState::new(delegate, window, cx));
+            let plot = self.plots[ix].name.clone();
+            if self.is_pickable(&plot) {
+                // A row selected — by click or by the arrow keys — is a pick;
+                // the table's own highlight is what shows it.
+                let picked_from = result.clone();
+                let subscription = cx.subscribe(&table, move |this, _, event: &TableEvent, cx| {
+                    if let TableEvent::SelectRow(row) = event {
+                        this.pick_row(&plot, &picked_from, *row, false, cx);
+                    }
+                });
+                self.table_subscriptions.push((table.entity_id(), subscription));
+            }
+            self.tables[ix] = Some(table);
         }
         let table = self.tables[ix].clone().expect("built just above");
         let truncated = result.truncated;
         let row_count = result.rows.len();
+        let rows = table.read(cx).vertical_scroll_handle.0.borrow().base_handle.clone();
+        let wheel = self.wheel.clone();
         v_flex()
             .size_full()
             .when(truncated, |this| {
@@ -443,12 +824,22 @@ impl Dashboard {
                 )
             })
             .child(
-                div().flex_1().min_h_0().child(
-                    DataTable::new(&table)
-                        .small()
-                        .stripe(true)
-                        .scrollbar_visible(true, true),
-                ),
+                div()
+                    .flex_1()
+                    .min_h_0()
+                    // Runs after the table's own scrolling and before the
+                    // stack's, so it decides whether the stack moves too.
+                    .on_scroll_wheel(move |event, window, cx| {
+                        if wheel.table_scrolled(ix, &rows, event, window) {
+                            cx.stop_propagation();
+                        }
+                    })
+                    .child(
+                        DataTable::new(&table)
+                            .small()
+                            .stripe(true)
+                            .scrollbar_visible(true, true),
+                    ),
             )
             .into_any_element()
     }
@@ -636,8 +1027,33 @@ impl Dashboard {
     }
 }
 
+// TEMP frame trace
+pub(crate) static TRACE_WHEEL: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+fn trace_frame(started: Instant) {
+    use std::sync::Mutex;
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    static LAST: Mutex<Option<Instant>> = Mutex::new(None);
+    if !*ON.get_or_init(|| std::env::var_os("DUCKLOCAL_TRACE_FRAMES").is_some()) {
+        return;
+    }
+    let mut last = LAST.lock().unwrap();
+    let dt = last.map(|l| started.duration_since(l).as_secs_f64() * 1000.).unwrap_or(0.);
+    *last = Some(started);
+    let wheels = TRACE_WHEEL.swap(0, std::sync::atomic::Ordering::Relaxed);
+    eprintln!("FRAME dt={dt:.2} render={:.3} wheels={wheels}", started.elapsed().as_secs_f64() * 1000.);
+}
+
 impl Render for Dashboard {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let __started = Instant::now();
+        let __out = self.render_inner(window, cx);
+        trace_frame(__started);
+        __out
+    }
+}
+
+impl Dashboard {
+    fn render_inner(&mut self, window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
         let body = if self.showing_source {
             // The source view stands on its own, spec error or not: the text
             // of a broken spec is exactly what one opens the source to fix.
@@ -653,22 +1069,51 @@ impl Render for Dashboard {
                 self.render_empty(cx)
             }
         } else {
-            let panels = (0..self.plots.len())
-                .map(|ix| {
+            let rows = grid_rows(self.plots.iter().map(|plot| plot.width));
+            let mut stack = 0.;
+            let panels = rows
+                .iter()
+                .map(|row| {
+                    let cards = row.iter().all(|&ix| self.plots[ix].kind == "card");
+                    let (default, min, max) = if cards {
+                        (CARD_DEFAULT, CARD_MIN, CARD_MAX)
+                    } else {
+                        (PLOT_DEFAULT, PLOT_MIN, PLOT_MAX)
+                    };
+                    stack += default;
+                    // A row short of twelve columns leaves the rest empty,
+                    // so a plot's width means the same on every row.
+                    let cells = row.iter().enumerate().map(|(position, &ix)| {
+                        let share = self.plots[ix].width as f32 / model::GRID_COLUMNS as f32;
+                        div()
+                            .h_full()
+                            .w(relative(share))
+                            .min_w_0()
+                            .when(position > 0, |this| {
+                                this.border_l_1().border_color(cx.theme().border)
+                            })
+                            .child(self.render_plot(ix, window, cx))
+                    });
+                    let cells = cells.collect::<Vec<_>>();
                     resizable_panel()
-                        .size(px(PLOT_DEFAULT))
-                        .size_range(px(PLOT_MIN)..px(PLOT_MAX))
-                        .child(self.render_plot(ix, window, cx))
+                        .size(px(default))
+                        .size_range(px(min)..px(max))
+                        .child(h_flex().size_full().children(cells))
                 })
                 .collect::<Vec<_>>();
-            // Every plot keeps its default height and the tab scrolls, rather
+            // Every row keeps its default height and the tab scrolls, rather
             // than a dozen plots squeezed into one screen and the rest clipped
             // out of reach. Dragging a divider still trades height between
             // neighbours; a tab taller than the stack is filled, as before.
-            let stack = px(PLOT_DEFAULT * self.plots.len() as f32);
+            let stack = px(stack);
+            let wheel = self.wheel.clone();
             div()
                 .id(format!("dashboard-scroll-{}", self.id))
                 .size_full()
+                .on_scroll_wheel(move |event, window, _| {
+                    TRACE_WHEEL.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                    wheel.stack_scrolled(event, window)
+                })
                 .overflow_y_scrollbar()
                 .child(
                     div()
@@ -686,19 +1131,25 @@ impl Render for Dashboard {
             .text_color(cx.theme().foreground)
             .children(self.render_conflict_warning(cx))
             .children(self.render_stale_warning(cx))
+            .when(!self.showing_source, |this| this.children(self.render_picks(cx)))
             .child(body)
+            .into_any_element()
     }
 }
 
 /// Everything one run of a dashboard produces, computed off the UI thread.
 struct Run {
     spec_error: Option<String>,
+    spec: Option<Arc<Spec>>,
     plots: Vec<PreparedPlot>,
     results: HashMap<String, Arc<QueryResult>>,
+    outcomes: Outcomes,
 }
 
 /// Read, parse, validate, run, prepare. Blocking — call it off the UI thread.
-fn load(path: &Path) -> Run {
+/// `picks` narrow the queries that read their filters; a query whose SQL
+/// comes out as `reuse` last ran it keeps that outcome instead of running.
+fn load(path: &Path, picks: &HashMap<String, Pick>, reuse: &Outcomes) -> Run {
     let display = path.display().to_string();
     let spec = (|| -> Result<Spec, String> {
         let source = std::fs::read_to_string(path).map_err(|e| format!("{display}: {e}"))?;
@@ -717,8 +1168,10 @@ fn load(path: &Path) -> Run {
         Err(spec_error) => {
             return Run {
                 spec_error: Some(spec_error),
+                spec: None,
                 plots: Vec::new(),
                 results: HashMap::new(),
+                outcomes: HashMap::new(),
             };
         }
     };
@@ -726,52 +1179,88 @@ fn load(path: &Path) -> Run {
     // Every query runs once, however many plots draw from it, and only after
     // it has been shown to read and nothing else: opening a file someone sent
     // must not be what runs its `DROP` or `COPY … TO`.
-    let outcomes: Vec<Result<QueryResult, String>> = spec
-        .queries
-        .iter()
-        .map(|query| match super::validate_query_sql(&query.sql)
-            .and_then(|()| crate::query::run(&query.sql).map_err(|e| format!("{e:#}")))
-        {
-            Ok(QueryOutcome::Rows(result)) => Ok(result),
-            Ok(QueryOutcome::Affected { .. }) => {
-                Err(trf("dashboard.query_not_rows", &[&query.name]))
-            }
-            Err(e) => Err(e),
-        })
-        .collect();
+    // The check is on the SQL as written; what runs has the sources it names
+    // in front of it, which only read.
+    // Picks go in before the sources, which only read.
+    let base = super::source::base_of(path);
+    let mut outcomes: Outcomes = HashMap::new();
+    for query in &spec.queries {
+        let sql = super::validate_query_sql(&query.sql).map(|()| {
+            let narrowed = super::filter::apply(&query.sql, &picks_for(&spec, query, picks));
+            super::source::expand(&narrowed, &spec.sources, &base)
+        });
+        let entry = match sql {
+            Err(error) => (String::new(), Err(error)),
+            Ok(sql) => match reuse.get(&query.name) {
+                Some((ran, outcome)) if *ran == sql => (sql, outcome.clone()),
+                _ => {
+                    let outcome = match crate::query::run(&sql) {
+                        Ok(QueryOutcome::Rows(result)) => Ok(Arc::new(result)),
+                        Ok(QueryOutcome::Affected { .. }) => {
+                            Err(trf("dashboard.query_not_rows", &[&query.name]))
+                        }
+                        Err(e) => Err(format!("{e:#}")),
+                    };
+                    (sql, outcome)
+                }
+            },
+        };
+        outcomes.insert(query.name.clone(), entry);
+    }
 
     // validate() has already said every plot's query exists.
     let plots = spec
         .plots
         .iter()
-        .map(|plot| {
-            let result = spec
-                .queries
-                .iter()
-                .position(|q| q.name == plot.query)
-                .map(|ix| &outcomes[ix]);
-            prepare(plot, result)
-        })
+        .map(|plot| prepare(plot, outcomes.get(&plot.query).map(|(_, outcome)| outcome)))
         .collect();
 
-    let results = spec
-        .queries
+    let results = outcomes
         .iter()
-        .zip(outcomes)
-        .filter_map(|(query, outcome)| {
-            outcome
-                .ok()
-                .map(|result| (query.name.clone(), Arc::new(result)))
+        .filter_map(|(name, (_, outcome))| {
+            outcome.as_ref().ok().map(|result| (name.clone(), result.clone()))
         })
         .collect();
 
     Run {
         spec_error: None,
+        spec: Some(Arc::new(spec)),
         plots,
         results,
+        outcomes,
     }
 }
 
+/// The picks a query sees: each filter it reads that has one — except a
+/// filter picked on a plot this very query draws, which would otherwise
+/// narrow the plot down to the one value just clicked.
+fn picks_for(
+    spec: &Spec,
+    query: &model::Query,
+    picks: &HashMap<String, Pick>,
+) -> HashMap<String, Pick> {
+    spec.filters_of(query)
+        .into_iter()
+        .filter(|filter| {
+            spec.plots
+                .iter()
+                .find(|plot| plot.name == filter.plot)
+                .is_none_or(|plot| plot.query != query.name)
+        })
+        .filter_map(|filter| {
+            let pick = picks.get(&filter.name)?;
+            // The column is the spec's as it stands, not as it was clicked.
+            Some((
+                filter.name.clone(),
+                Pick {
+                    column: filter.column.clone(),
+                    value: pick.value.clone(),
+                },
+            ))
+        })
+        .collect()
+}
+
 /// One plot's chart element, built from the prepared data on each frame;
 /// cloning the `Arc`s is a refcount bump, not a copy of the row set.
 fn chart_element(plot_ix: usize, plot: &PreparedPlot, cx: &App) -> AnyElement {
@@ -873,6 +1362,59 @@ fn chart_element(plot_ix: usize, plot: &PreparedPlot, cx: &App) -> AnyElement {
     }
 }
 
+/// Plots in rows of the grid: each row takes plots in order until the next
+/// would not fit in the twelve columns, then a new row starts. Indices into
+/// the plot list, every plot in exactly one row.
+fn grid_rows(widths: impl IntoIterator<Item = u8>) -> Vec<Vec<usize>> {
+    let mut rows: Vec<Vec<usize>> = Vec::new();
+    let mut used = model::GRID_COLUMNS;
+    for (ix, width) in widths.into_iter().enumerate() {
+        if used + width > model::GRID_COLUMNS {
+            rows.push(Vec::new());
+            used = 0;
+        }
+        used += width;
+        rows.last_mut().expect("pushed above").push(ix);
+    }
+    rows
+}
+
+/// A card: its title over its one value, large. What was dropped to get to
+/// one value — the rows past the first — is said under it, small.
+fn render_card(plot: &PreparedPlot, cx: &App) -> AnyElement {
+    v_flex()
+        .size_full()
+        .px_4()
+        .py_3()
+        .gap_1()
+        .justify_center()
+        .overflow_hidden()
+        .child(
+            div()
+                .text_sm()
+                .text_color(cx.theme().muted_foreground)
+                .text_ellipsis()
+                .child(plot.title.clone()),
+        )
+        .child(
+            div()
+                .text_3xl()
+                .font_weight(FontWeight::SEMIBOLD)
+                .text_ellipsis()
+                .child(plot.card.clone().unwrap_or_default()),
+        )
+        .when_some(plot.notice.clone(), |this, notice| {
+            this.child(
+                div()
+                    .text_xs()
+                    .text_color(cx.theme().muted_foreground)
+                    .text_ellipsis()
+                    .child(notice),
+            )
+        })
+        .into_any_element()
+}
+
 /// The plot body when nothing parsed: the same medium-over-muted message the
 /// results chart's empty state uses.
 fn empty_chart(cx: &App) -> AnyElement {
@@ -1082,3 +1624,88 @@ impl CompletionProvider for SpecCompletionProvider {
             .unwrap_or(false)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    // Not `use super::*`: that brings `gpui_kit::*`, whose `test` macro
+    // shadows the built-in `#[test]`.
+    use super::{grid_rows, load, Pick, Run};
+    use std::collections::HashMap;
+    use std::path::Path;
+    use std::sync::Arc;
+
+    const BOARD: &str = r#"
+source "orders" { path = "orders.csv" }
+query "by_channel" { sql = "SELECT channel, sum(amount) AS amount FROM orders GROUP BY 1 ORDER BY 1" }
+query "total" { sql = "SELECT sum(amount) AS total FROM orders WHERE $channel" }
+query "count" { sql = "SELECT count(*) AS n FROM orders" }
+plot "channels" { type = "bar" query = query.by_channel x = channel y = amount }
+plot "total" { type = "card" query = query.total }
+plot "count" { type = "card" query = query.count }
+filter "channel" { plot = plot.channels }
+"#;
+
+    fn total(run: &Run) -> String {
+        run.results["total"].rows[0][0].clone()
+    }
+
+    #[test]
+    fn a_pick_narrows_the_queries_that_read_it_and_reuses_the_rest() {
+        let _guard = crate::db::connection_guard();
+        crate::db::open_memory().unwrap();
+        let dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("target/view-tests")
+            .join(format!("pick-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("orders.csv"), "channel,amount\nweb,10\nshop,20\nweb,5\n,1\n")
+            .unwrap();
+        let path = dir.join("board.dash");
+        std::fs::write(&path, BOARD).unwrap();
+
+        let fresh = load(&path, &HashMap::new(), &HashMap::new());
+        assert_eq!(fresh.spec_error, None);
+        assert_eq!(total(&fresh), "36");
+
+        let mut picks = HashMap::new();
+        picks.insert(
+            "channel".to_string(),
+            Pick {
+                column: "channel".into(),
+                value: Some("web".into()),
+            },
+        );
+        let narrowed = load(&path, &picks, &fresh.outcomes);
+        assert_eq!(total(&narrowed), "15");
+        // The picking plot's own query is not narrowed, and neither it nor a
+        // query that reads no filter ran again: the same result comes back.
+        for unchanged in ["by_channel", "count"] {
+            assert!(
+                Arc::ptr_eq(&fresh.results[unchanged], &narrowed.results[unchanged]),
+                "{unchanged} ran again"
+            );
+        }
+        assert_eq!(narrowed.results["by_channel"].rows.len(), 3);
+
+        // The grid's NULL picks the rows with no channel.
+        picks.get_mut("channel").unwrap().value = None;
+        assert_eq!(total(&load(&path, &picks, &narrowed.outcomes)), "1");
+
+        // A reload reuses nothing: every query runs.
+        let reloaded = load(&path, &picks, &HashMap::new());
+        assert!(!Arc::ptr_eq(&fresh.results["count"], &reloaded.results["count"]));
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn plots_fill_rows_and_wrap() {
+        // Four cards, then two halves, then a full row, then a lone third
+        // that no longer fits beside an eight.
+        assert_eq!(
+            grid_rows([3, 3, 3, 3, 6, 6, 12, 8, 6]),
+            vec![vec![0, 1, 2, 3], vec![4, 5], vec![6], vec![7], vec![8]]
+        );
+        // Existing specs: every plot the full width, one per row.
+        assert_eq!(grid_rows([12, 12]), vec![vec![0], vec![1]]);
+        assert!(grid_rows([]).is_empty());
+    }
+}
diff --git a/src/spec/wheel.rs b/src/spec/wheel.rs
new file mode 100644
index 0000000..85fec68
--- /dev/null
+++ b/src/spec/wheel.rs
@@ -0,0 +1,238 @@
+//! Which scroller a wheel gesture moves, when a `table` plot — itself
+//! scrollable — sits inside the dashboard's scrolling stack.
+//!
+//! GPUI hands a wheel event to every scroll container under the pointer and
+//! none of them stops it, so a swipe over a table moved the table's rows and
+//! the whole dashboard at once, and the two fought. Browsers settle this with
+//! two rules, and so does this:
+//!
+//! - Chaining: the inner scroller takes the wheel until it is at its edge in
+//!   that direction; then the outer one does.
+//! - Latching: one gesture stays with the scroller it started on, trackpad
+//!   momentum included. A dashboard scroll that carries a table under the
+//!   pointer keeps scrolling the dashboard, instead of stopping dead when the
+//!   table catches it.
+//!
+//! A trackpad says where a gesture begins: its first event is `Started`,
+//! often with no movement yet (fingers down, nothing moved). So a gesture is
+//! decided by its first event that moves, and a new `Started` decides afresh
+//! even while the last swipe's momentum is still streaming in. A mouse wheel
+//! reports no phases; for it, a pause between events is what ends a gesture.
+
+use std::cell::Cell;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
+
+use gpui_kit::{point, Pixels, ScrollHandle, ScrollWheelEvent, TouchPhase, Window};
+
+/// Events closer together than this belong to one gesture. Momentum arrives
+/// every frame; a wheel's separate clicks a person means as one move come
+/// well inside this too.
+const GESTURE_GAP: Duration = Duration::from_millis(150);
+
+/// Slack at the edges, so rounding does not leave a scroller "not quite at
+/// the end" forever.
+const EDGE: f32 = 0.5;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Target {
+    /// The dashboard's own stack.
+    Stack,
+    /// The table of the plot at this index.
+    Table(usize),
+}
+
+#[derive(Clone, Copy, Debug)]
+struct Latch {
+    target: Target,
+    at: Instant,
+}
+
+/// The gesture in progress, shared by the stack and each table's handler.
+#[derive(Clone, Default)]
+pub struct WheelLatch(Rc<Cell<Option<Latch>>>);
+
+impl WheelLatch {
+    /// The target of the gesture `now` continues, if it continues one.
+    fn current(&self, now: Instant) -> Option<Target> {
+        self.0
+            .get()
+            .filter(|latch| now.saturating_duration_since(latch.at) < GESTURE_GAP)
+            .map(|latch| latch.target)
+    }
+
+    fn hold(&self, target: Target, now: Instant) {
+        self.0.set(Some(Latch { target, at: now }));
+    }
+
+    /// The stack's own handler: it only sees events no table kept, so any
+    /// event reaching it that moves is the stack's.
+    pub fn stack_scrolled(&self, event: &ScrollWheelEvent, window: &Window) {
+        let delta = event.delta.pixel_delta(window.line_height());
+        if delta.x != Pixels::ZERO || delta.y != Pixels::ZERO {
+            self.hold(Target::Stack, Instant::now());
+        }
+    }
+
+    /// The table of plot `ix` has already applied `event` to its rows (its
+    /// listener runs before this one); decide whether it keeps the event.
+    /// Returns true when propagation should stop — the stack must not move.
+    pub fn table_scrolled(
+        &self,
+        ix: usize,
+        handle: &ScrollHandle,
+        event: &ScrollWheelEvent,
+        window: &Window,
+    ) -> bool {
+        let now = Instant::now();
+        let delta = event.delta.pixel_delta(window.line_height());
+        let offset = handle.offset();
+        let before = offset.y - delta.y;
+        let latched = self.current(now);
+        let moved = delta.x != Pixels::ZERO || delta.y != Pixels::ZERO;
+        let keeps = keeps(
+            before.into(),
+            handle.max_offset().y.into(),
+            delta.x.into(),
+            delta.y.into(),
+        );
+        let started = event.touch_phase == TouchPhase::Started;
+        let Some(target) = decide(latched, started, moved, keeps, ix) else {
+            // Nothing moved, so there is nothing to take back, and no reason
+            // to change hands.
+            return latched.is_some_and(|target| target != Target::Stack);
+        };
+        self.hold(target, now);
+        if target != Target::Table(ix) {
+            // Not this table's gesture: take back what its listener did. Only
+            // the rows move on this handle; the columns scroll on another.
+            handle.set_offset(point(offset.x, before));
+        }
+        target != Target::Stack
+    }
+}
+
+/// Who an event over table `ix` goes to. `None` for an event that does not
+/// move: fingers landing on a trackpad say a gesture has begun, not where it
+/// is going, and deciding then would hand every trackpad gesture over a
+/// table to the stack.
+fn decide(
+    latched: Option<Target>,
+    started: bool,
+    moved: bool,
+    keeps: bool,
+    ix: usize,
+) -> Option<Target> {
+    if !moved {
+        return None;
+    }
+    Some(match latched {
+        Some(target) if !started => target,
+        _ if keeps => Target::Table(ix),
+        _ => Target::Stack,
+    })
+}
+
+/// Whether an inner scroller at vertical offset `before` (GPUI's: 0 at the
+/// top, `-max` at the bottom) should take a gesture that starts with this
+/// delta: always for a sideways swipe, which the stack cannot use, and for a
+/// vertical one while it has room to move that way.
+fn keeps(before: f32, max: f32, dx: f32, dy: f32) -> bool {
+    if dy.abs() < dx.abs() {
+        return true;
+    }
+    if dy < 0.0 {
+        before > -max + EDGE
+    } else if dy > 0.0 {
+        before < -EDGE
+    } else {
+        false
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{decide, keeps, Target, WheelLatch, GESTURE_GAP};
+    use std::time::{Duration, Instant};
+
+    const MAX: f32 = 400.0;
+
+    #[test]
+    fn a_table_keeps_the_wheel_until_its_edge() {
+        // Scrolling down (negative delta) from the top, and in the middle.
+        assert!(keeps(0.0, MAX, 0.0, -20.0));
+        assert!(keeps(-200.0, MAX, 0.0, -20.0));
+        // At the bottom, down goes to the stack; up stays.
+        assert!(!keeps(-MAX, MAX, 0.0, -20.0));
+        assert!(keeps(-MAX, MAX, 0.0, 20.0));
+        // At the top, up goes to the stack.
+        assert!(!keeps(0.0, MAX, 0.0, 20.0));
+    }
+
+    #[test]
+    fn a_table_that_does_not_scroll_passes_every_vertical_gesture_on() {
+        assert!(!keeps(0.0, 0.0, 0.0, -20.0));
+        assert!(!keeps(0.0, 0.0, 0.0, 20.0));
+    }
+
+    #[test]
+    fn a_sideways_swipe_stays_with_the_table() {
+        // The stack would read a sideways delta as vertical; the table's
+        // columns are what a sideways swipe means.
+        assert!(keeps(-MAX, MAX, 30.0, -2.0));
+        assert!(keeps(0.0, 0.0, -30.0, 0.0));
+    }
+
+    #[test]
+    fn rounding_at_an_edge_counts_as_the_edge() {
+        assert!(!keeps(-MAX + 0.2, MAX, 0.0, -20.0));
+        assert!(!keeps(-0.2, MAX, 0.0, 20.0));
+    }
+
+    #[test]
+    fn fingers_landing_decide_nothing() {
+        // A trackpad's first event has no movement: it must not latch the
+        // gesture to the stack before the table has had a say.
+        assert_eq!(decide(None, true, false, false, 3), None);
+        assert_eq!(decide(Some(Target::Stack), true, false, false, 3), None);
+        // The first event that moves decides.
+        assert_eq!(decide(None, false, true, true, 3), Some(Target::Table(3)));
+    }
+
+    #[test]
+    fn a_new_swipe_decides_afresh_while_momentum_streams() {
+        // Momentum from a dashboard scroll is still arriving (the latch is
+        // live), and a new swipe begins over a table that can scroll.
+        assert_eq!(
+            decide(Some(Target::Stack), true, true, true, 3),
+            Some(Target::Table(3))
+        );
+        // ... and one at the table's edge goes to the stack.
+        assert_eq!(
+            decide(Some(Target::Table(3)), true, true, false, 3),
+            Some(Target::Stack)
+        );
+        // Within a gesture, the latch holds either way.
+        assert_eq!(
+            decide(Some(Target::Stack), false, true, true, 3),
+            Some(Target::Stack)
+        );
+        assert_eq!(
+            decide(Some(Target::Table(3)), false, true, false, 3),
+            Some(Target::Table(3))
+        );
+    }
+
+    #[test]
+    fn a_gesture_stays_with_its_target_until_it_pauses() {
+        let latch = WheelLatch::default();
+        let start = Instant::now();
+        assert_eq!(latch.current(start), None);
+        latch.hold(Target::Stack, start);
+        assert_eq!(
+            latch.current(start + Duration::from_millis(16)),
+            Some(Target::Stack)
+        );
+        assert_eq!(latch.current(start + GESTURE_GAP), None);
+    }
+}
diff --git a/src/ui/geo.rs b/src/ui/geo.rs
index e3df6f8..4653396 100644
--- a/src/ui/geo.rs
+++ b/src/ui/geo.rs
@@ -7,7 +7,8 @@
 //! coastline would say nothing at the city scale most station, store or
 //! sensor tables live at. When a low
 //! cardinality text column is present (a `type`, a `country`), points are
-//! colored by it, so the map says something beyond "where".
+//! colored by it, so the map says something beyond "where"; a dashboard can
+//! also size them by a number (`MapStyle`), so it says "how much" too.
 //!
 //! Like the other charts, detection and projection happen once per result set
 //! (`GeoData::detect`); a frame re-derives only the viewport transform, which
diff --git a/src/ui/results.rs b/src/ui/results.rs
index 2a79773..d89fa8e 100644
--- a/src/ui/results.rs
+++ b/src/ui/results.rs
@@ -399,6 +399,42 @@ pub struct ResultsPanel {
 }
 
 impl ResultsPanel {
+    /// What the panel shows, for `ducklocal open --state`: the result's shape and
+    /// its first rows, or the error, or what the run changed.
+    pub fn summary(&self) -> serde_json::Value {
+        use serde_json::json;
+        let mut summary = match &self.view {
+            ResultView::Empty => json!({"status": "empty"}),
+            ResultView::Running => json!({"status": "running"}),
+            ResultView::Rows(result) => json!({
+                "status": "rows",
+                "columns": result.columns.iter().map(|c| json!({
+                    "name": c.name,
+                    "type": c.duck_type,
+                })).collect::<Vec<_>>(),
+                "row_count": result.rows.len(),
+                "truncated": result.truncated,
+                "preview": result.rows.iter().take(crate::remote::STATE_PREVIEW_ROWS).collect::<Vec<_>>(),
+                "elapsed_ms": result.elapsed_ms,
+            }),
+            ResultView::Affected { count, elapsed_ms } => json!({
+                "status": "affected",
+                "count": count,
+                "elapsed_ms": elapsed_ms,
+            }),
+            ResultView::Failed(message) => json!({"status": "failed", "error": message}),
+            ResultView::Explain { lines, elapsed_ms } => json!({
+                "status": "explain",
+                "plan": lines,
+                "elapsed_ms": elapsed_ms,
+            }),
+        };
+        if let Some(sql) = &self.rows_sql {
+            summary["sql"] = json!(sql);
+        }
+        summary
+    }
+
     pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let table = cx.new(|cx| TableState::new(ResultTableDelegate::new(), window, cx));
         let filter_input =
diff --git a/src/ui/workspace.rs b/src/ui/workspace.rs
index 5669954..9a4dc5d 100644
--- a/src/ui/workspace.rs
+++ b/src/ui/workspace.rs
@@ -601,6 +601,42 @@ impl Workspace {
         }
     }
 
+    /// Every tab as `ducklocal open --state` reports it, and which is in front.
+    pub fn snapshot(&self, cx: &App) -> serde_json::Value {
+        use serde_json::json;
+        let tabs = self
+            .tabs
+            .iter()
+            .enumerate()
+            .map(|(ix, tab)| {
+                let mut entry = json!({
+                    "title": tab.title().to_string(),
+                    "active": ix == self.active,
+                });
+                match tab {
+                    WorkspaceTab::Query(tab) => {
+                        entry["kind"] = json!("query");
+                        entry["sql"] = json!(tab.editor.read(cx).value().to_string());
+                        entry["result"] = tab.results.read(cx).summary();
+                    }
+                    WorkspaceTab::Dashboard(tab) => {
+                        let host = tab.host.read(cx);
+                        entry["kind"] = json!("dashboard");
+                        entry["path"] = json!(tab.path.display().to_string());
+                        entry["unsaved"] = json!(host.is_dirty(cx));
+                        entry["dashboard"] = host.summary();
+                    }
+                    WorkspaceTab::App(tab) => {
+                        entry["kind"] = json!("app");
+                        entry["directory"] = json!(tab.directory.display().to_string());
+                    }
+                }
+                entry
+            })
+            .collect::<Vec<_>>();
+        json!({"active_tab": self.active, "tabs": tabs})
+    }
+
     fn active_tab(&self) -> Option<&WorkspaceTab> {
         self.tabs.get(self.active)
     }
@@ -635,6 +671,29 @@ impl Workspace {
         self.focus_active_editor(window, cx);
     }
 
+    /// A new query tab holding `sql`, in front — what `ducklocal open --sql`
+    /// asks for. The SQL is the tab's own, not a history refill, so it never
+    /// overwrites a tab someone is writing in.
+    pub fn open_query_tab(
+        &mut self,
+        sql: String,
+        title: Option<String>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let mut tab = self.new_tab_editor(window, cx);
+        if let Some(title) = title.filter(|title| !title.trim().is_empty()) {
+            tab.title = title.into();
+        }
+        tab.editor
+            .update(cx, |editor, cx| editor.set_value(sql, window, cx));
+        self.tabs.push(WorkspaceTab::Query(tab));
+        self.active = self.tabs.len() - 1;
+        self.editor_shown = true;
+        cx.notify();
+        self.focus_active_editor(window, cx);
+    }
+
     /// The tab strip's "+": a query, or an app folder to open as one.
     fn pick_app_directory(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         let rx = cx.prompt_for_paths(PathPromptOptions {
@@ -930,7 +989,7 @@ impl Workspace {
         self.run_active(window, cx);
     }
 
-    fn run_active(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+    pub(crate) fn run_active(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         if self.running || self.explaining {
             return;
         }
diff --git a/tests/cli.rs b/tests/cli.rs
index 7907c95..7068a42 100644
--- a/tests/cli.rs
+++ b/tests/cli.rs
@@ -805,6 +805,105 @@ export default class App extends View {
     assert_eq!(replaced["rows"], 2);
 }
 
+/// A `source` names data files beside the spec: its path is the `.dash`
+/// file's folder's business, not the working directory's, and every query
+/// that names it reads it — a `WITH` query, a `SUMMARIZE`, a plain `SELECT` —
+/// with the database's own table of the same name shadowed for that query.
+/// Cards and widths come back in the report.
+#[test]
+fn check_runs_sources_from_the_specs_folder() {
+    let s = Sandbox::new();
+    let dash = s.0.join("dash");
+    std::fs::create_dir_all(dash.join("exports")).unwrap();
+    std::fs::write(dash.join("exports/orders-1.csv"), "channel,amount\nweb,10\nshop,20\n").unwrap();
+    std::fs::write(dash.join("exports/orders-2.csv"), "channel,amount\nweb,5\n").unwrap();
+    std::fs::write(
+        dash.join("board.dash"),
+        r#"
+source "orders" { path = "exports/orders-*.csv" }
+
+query "total" { sql = "SELECT sum(amount) AS total, count(*) AS n FROM orders" }
+query "by_channel" {
+  sql = <<SQL
+    -- a leading note
+    WITH c AS (SELECT channel, amount FROM orders)
+    SELECT channel, sum(amount) AS amount FROM c GROUP BY channel ORDER BY amount DESC
+  SQL
+}
+query "shape" { sql = "SUMMARIZE orders;" }
+
+plot "total"  { type = "card" query = query.total value = total title = "Revenue" }
+plot "orders" { type = "card" query = query.total value = n }
+plot "chart"  { type = "bar" query = query.by_channel x = channel y = amount width = 6 }
+plot "stats"  { type = "table" query = query.shape x = column_name width = 6 }
+"#,
+    )
+    .unwrap();
+    // The database has its own `orders`: the source shadows it.
+    s.success(&[
+        "query",
+        "--database",
+        "data.duckdb",
+        "--read-write",
+        "--sql",
+        "CREATE TABLE orders AS SELECT 'nope' AS other",
+    ]);
+
+    // Run from the sandbox, not the spec's folder: the glob still resolves.
+    let out = s.object(&["check", "dash/board.dash", "--database", "data.duckdb"]);
+    assert_eq!(out["sources"][0]["name"], "orders");
+    assert_eq!(out["sources"][0]["path"], "exports/orders-*.csv");
+    let resolved = out["sources"][0]["resolved"].as_str().unwrap();
+    assert!(resolved.ends_with("dash/exports/orders-*.csv"), "{resolved}");
+    assert!(std::path::Path::new(resolved).is_absolute(), "{resolved}");
+    let total = &out["queries"][0]["columns"];
+    assert_eq!(total[0]["name"], "total");
+    assert_eq!(out["queries"][1]["columns"][0]["name"], "channel");
+    assert_eq!(out["queries"][2]["columns"][0]["name"], "column_name");
+    assert_eq!(out["plots"][0]["type"], "card");
+    assert_eq!(out["plots"][0]["value"], "total");
+    assert_eq!(out["plots"][0]["width"], 3);
+    assert_eq!(out["plots"][2]["width"], 6);
+
+    // A card's value is checked against the columns like any other.
+    std::fs::write(
+        dash.join("badcard.dash"),
+        "source \"orders\" { path = \"exports/orders-*.csv\" }\nquery \"q\" { sql = \"FROM orders\" }\nplot \"c\" { type = \"card\" query = query.q value = revenue }\n",
+    )
+    .unwrap();
+    let error = s.error(&["check", "dash/badcard.dash", "--database", "data.duckdb"], 2, "spec");
+    let message = error["error"]["message"].as_str().unwrap();
+    assert!(message.contains("value = \"revenue\""), "{message}");
+
+    // A path that matches nothing fails when the query runs, not statically.
+    std::fs::write(
+        dash.join("gone.dash"),
+        "source \"o\" { path = \"missing/*.csv\" }\nquery \"q\" { sql = \"FROM o\" }\n",
+    )
+    .unwrap();
+    s.object(&["check", "dash/gone.dash"]);
+    s.error(&["check", "dash/gone.dash", "--database", "data.duckdb"], 1, "sql");
+
+    // Statically: a workbook, a name SQL cannot read bare, a width off the grid.
+    std::fs::write(
+        dash.join("bad.dash"),
+        r#"
+source "book" { path = "sales.xlsx" }
+source "2026 orders" { path = "o.csv" }
+query "q" { sql = "SELECT 1 AS a" }
+plot "p" { type = "bar" query = query.q x = a y = a width = 13 }
+plot "c" { type = "card" query = query.q x = a }
+"#,
+    )
+    .unwrap();
+    let error = s.error(&["check", "dash/bad.dash"], 2, "spec");
+    let message = error["error"]["message"].as_str().unwrap();
+    assert!(message.contains("bad.dash:2: A workbook"), "{message}");
+    assert!(message.contains("bad.dash:3: source \"2026 orders\""), "{message}");
+    assert!(message.contains("bad.dash:5: width"), "{message}");
+    assert!(message.contains("bad.dash:6: A card shows one value"), "{message}");
+}
+
 /// `check` validates a dashboard spec the way the CLI validates everything:
 /// statically first — no database, nothing executes — and, when `--database`
 /// is given, against the columns the queries really return.
@@ -1088,3 +1187,193 @@ fn export_argument_errors_never_start_an_app() {
     let help = s.text(&["export", "--help"]);
     assert!(help.contains("export --html"), "{help}");
 }
+
+#[test]
+fn open_checks_its_arguments_and_never_starts_a_window_it_was_told_not_to() {
+    let s = Sandbox::new();
+    let output = s.run(&["open", "--help"], None);
+    assert!(output.status.success());
+    assert!(String::from_utf8(output.stdout).unwrap().contains("--no-launch"));
+    for args in [
+        vec!["open"],
+        vec!["open", "--no-launch"],
+        vec!["open", "--run", "a.csv"],
+        vec!["open", "--title", "x", "a.csv"],
+        vec!["open", "--sql", "  "],
+        vec!["open", "--sql", "SELECT 1", "--sql-file", "x.sql"],
+        vec!["open", "--sql", "SELECT 1", "--wat"],
+        vec!["open", "--sql", "SELECT 1", "--run", "--run"],
+    ] {
+        s.error(&args, 2, "argument");
+    }
+    s.error(&["open", "--sql-file", "missing.sql"], 1, "io");
+    // The sandbox's HOME has no endpoint, so no window is reachable — and the
+    // command writes nothing there finding that out (`run` checks).
+    s.error(
+        &["open", "--no-launch", "--sql", "SELECT 1", "--run"],
+        1,
+        "not_running",
+    );
+    s.error(&["open", "--no-launch", "sales.dash"], 1, "not_running");
+}
+
+#[test]
+fn schema_lists_files_and_databases_sized_for_a_prompt() {
+    let s = Sandbox::new();
+    std::fs::create_dir_all(s.0.join("data/nested")).unwrap();
+    std::fs::write(s.0.join("data/orders.csv"), "channel,amount\nweb,10\nshop,20\n").unwrap();
+    std::fs::write(s.0.join("data/nested/notes.txt"), "a,b\n1,2\n").unwrap();
+    s.success(&[
+        "query",
+        "--sql",
+        "COPY (SELECT range AS id FROM range(7)) TO 'data/ids.parquet'",
+    ]);
+
+    // A folder expands as a drop on the window would; every file is whole.
+    let out = s.object(&["schema", "data"]);
+    assert_eq!(out["detail"], "full");
+    let relations = out["relations"].as_array().unwrap();
+    let names: Vec<&str> = relations.iter().map(|r| r["name"].as_str().unwrap()).collect();
+    assert_eq!(names, ["data/ids.parquet", "data/nested/notes.txt", "data/orders.csv"]);
+    // Parquet knows its row count; a CSV would need a scan.
+    assert_eq!(relations[0]["rows"], 7);
+    assert!(relations[2]["rows"].is_null());
+    assert_eq!(relations[2]["from"], "'data/orders.csv'");
+    assert_eq!(relations[2]["columns"][1]["name"], "amount");
+    // A .txt is read as CSV only when asked to.
+    assert_eq!(relations[1]["from"], "read_csv_auto('data/nested/notes.txt')");
+    // `from` is SQL that works as given.
+    let rows = s.success(&[
+        "query",
+        "--sql",
+        &format!("SELECT count(*) AS n FROM {}", relations[1]["from"].as_str().unwrap()),
+    ]);
+    assert_eq!(rows["rows"][0][0], 1);
+
+    // A database past the threshold keeps the largest few whole.
+    let mut ddl = vec!["CREATE TABLE big AS SELECT range AS id FROM range(1000)".to_string()];
+    for i in 0..14 {
+        ddl.push(format!("CREATE TABLE t{i} (a INTEGER, b VARCHAR)"));
+    }
+    for sql in &ddl {
+        s.success(&["query", "--database", "w.duckdb", "--read-write", "--sql", sql]);
+    }
+    let out = s.object(&["schema", "--database", "w.duckdb"]);
+    assert_eq!(out["detail"], "summary");
+    assert_eq!(out["without_columns"], 10);
+    assert!(out["hint"].as_str().unwrap().contains("--table"));
+    let big = out["relations"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|r| r["name"] == "big")
+        .unwrap();
+    assert_eq!(big["columns"][0]["name"], "id");
+    // A database named as a PATH is the same request.
+    let one = s.object(&["schema", "w.duckdb", "--table", "t3"]);
+    assert_eq!(one["relations"][0]["columns"][1]["type"], "VARCHAR");
+    assert_eq!(s.object(&["schema", "w.duckdb", "--full"])["without_columns"], 0);
+
+    s.error(&["schema"], 2, "argument");
+    s.error(&["schema", "missing.csv"], 2, "argument");
+    let error = s.error(&["schema", "w.duckdb", "--table", "nope"], 2, "argument");
+    assert!(error["error"]["hint"].as_str().is_some());
+}
+
+#[test]
+fn errors_say_what_to_do_next() {
+    let s = Sandbox::new();
+    let error = s.error(&["query", "--limt", "5"], 2, "argument");
+    assert_eq!(error["error"]["hint"], "Did you mean --limit?");
+    let error = s.error(&["query", "--sql", "SELECT 1; SELECT 2"], 2, "argument");
+    assert!(error["error"]["hint"].as_str().unwrap().contains("one statement"));
+    let error = s.error(&["query", "--sql", "SELECT * FROM missing_table"], 1, "sql");
+    assert!(error["error"]["hint"].as_str().unwrap().contains("ducklocal schema"));
+    s.success(&["query", "--database", "w.duckdb", "--read-write", "--sql", "CREATE TABLE t(a INT)"]);
+    let error = s.error(&["query", "--database", "w.duckdb", "--sql", "DROP TABLE t"], 1, "sql");
+    assert!(error["error"]["hint"].as_str().unwrap().contains("--read-write"));
+    // A syntax error has nothing to add to DuckDB's own message.
+    let error = s.error(&["query", "--sql", "SELEC 1"], 1, "sql");
+    assert!(error["error"].get("hint").is_none());
+}
+
+#[test]
+fn open_state_reads_a_running_window_and_never_starts_one() {
+    let s = Sandbox::new();
+    let output = s.run(&["open", "--help"], None);
+    assert!(String::from_utf8(output.stdout).unwrap().contains("--state"));
+    let error = s.error(&["open", "--state"], 1, "not_running");
+    assert!(error["error"]["hint"].as_str().unwrap().contains("ducklocal open"));
+    // It reads; mixed with something to open it is a mistake, not a guess.
+    s.error(&["open", "--state", "--sql", "SELECT 1"], 2, "argument");
+    s.error(&["open", "--state", "a.csv"], 2, "argument");
+}
+
+#[test]
+fn schema_stats_profiles_one_relation() {
+    let s = Sandbox::new();
+    std::fs::write(s.0.join("orders.csv"), "day,amount\n2026-01-01,10.5\n2026-01-03,20\n").unwrap();
+    std::fs::write(s.0.join("other.csv"), "a\n1\n").unwrap();
+    let mut stats = s.object(&["schema", "orders.csv", "--stats"]);
+    // The same report the deprecated `profile` gives, timing aside.
+    let mut profiled = s.profile(&["profile", "orders.csv"]);
+    stats.as_object_mut().unwrap().remove("elapsed_ms");
+    profiled.as_object_mut().unwrap().remove("elapsed_ms");
+    assert_eq!(stats, profiled);
+    assert_eq!(stats["row_count"], 2);
+    // Two relations need --table to say which.
+    let error = s.error(&["schema", ".", "--stats"], 2, "argument");
+    assert!(error["error"]["hint"].as_str().unwrap().contains("--table"));
+    let picked = s.object(&["schema", ".", "--stats", "--table", "orders.csv"]);
+    assert_eq!(picked["row_count"], 2);
+    s.success(&["query", "--database", "w.duckdb", "--read-write", "--sql", "CREATE TABLE t AS SELECT 1 AS n"]);
+    let table = s.object(&["schema", "--database", "w.duckdb", "--table", "t", "--stats"]);
+    assert_eq!(table["row_count"], 1);
+    s.error(&["schema", "orders.csv", "--stats", "--full"], 2, "argument");
+    // Help lists five commands; the rest stay callable.
+    let help = String::from_utf8(s.run(&["--help"], None).stdout).unwrap();
+    for gone in ["profile", "lsp", "state"] {
+        assert!(!help.contains(&format!("ducklocal {gone}")), "{help}");
+    }
+}
+
+#[test]
+fn check_reports_filters_and_runs_queries_with_nothing_picked() {
+    let s = Sandbox::new();
+    std::fs::write(
+        s.0.join("orders.csv"),
+        "day,channel,amount\n2026-01-01,web,10\n2026-01-01,shop,20\n2026-01-02,web,5\n",
+    )
+    .unwrap();
+    let spec = r#"
+source "orders" { path = "orders.csv" }
+query "by_channel" { sql = "SELECT channel, sum(amount) AS amount FROM orders WHERE $day GROUP BY 1" }
+query "by_day" { sql = "SELECT day, sum(amount) AS amount FROM orders WHERE $channel AND $day GROUP BY 1" }
+query "days" { sql = "SELECT DISTINCT day FROM orders ORDER BY 1" }
+plot "channels" { type = "bar" query = query.by_channel x = channel y = amount }
+plot "days" { type = "table" query = query.days x = day }
+plot "trend" { type = "line" query = query.by_day x = day y = amount }
+filter "channel" { plot = plot.channels }
+filter "day" {
+  plot = plot.days
+  column = day
+}
+"#;
+    std::fs::write(s.0.join("board.dash"), spec).unwrap();
+    s.success(&["query", "--database", "w.duckdb", "--read-write", "--sql", "CREATE TABLE x(a INT)"]);
+    let out = s.object(&["check", "board.dash", "--database", "w.duckdb"]);
+    let filters = out["filters"].as_array().unwrap();
+    assert_eq!(filters[0]["name"], "channel");
+    assert_eq!(filters[0]["column"], "channel");
+    assert_eq!(filters[0]["queries"], json!(["by_day"]));
+    assert_eq!(filters[1]["queries"], json!(["by_channel", "by_day"]));
+
+    // A placeholder with no filter, and a filter on a column its plot's
+    // query does not return, are both spec mistakes.
+    std::fs::write(s.0.join("typo.dash"), spec.replace("AND $day", "AND $dy")).unwrap();
+    let error = s.error(&["check", "typo.dash"], 2, "spec");
+    assert!(error["error"]["message"].as_str().unwrap().contains("$dy"));
+    std::fs::write(s.0.join("column.dash"), spec.replace("column = day", "column = nope")).unwrap();
+    let error = s.error(&["check", "column.dash", "--database", "w.duckdb"], 2, "spec");
+    assert!(error["error"]["message"].as_str().unwrap().contains("\"nope\""));
+}
diff --git a/tests/lsp.rs b/tests/lsp.rs
index 334c19a..caa1866 100644
--- a/tests/lsp.rs
+++ b/tests/lsp.rs
@@ -337,12 +337,14 @@ fn completion_inside_a_plot_offers_its_attributes() {
             "y",
             "series",
             "title",
+            "width",
             "lat",
             "lng",
             "color",
             "size",
             "size_scale",
-            "tooltip"
+            "tooltip",
+            "value"
         ],
         "{response}"
     );