@@ -176,7 +176,7 @@ hotdata databases load --catalog demo --table listings --file ./listings.parquet
 
 ```sh
 hotdata databases tables list                # every queryable table, as connection.schema.table
-hotdata databases tables list --connection-id <id>  # with column names and types
+hotdata databases tables show <table>        # column names and types for one table
 hotdata query "<sql>" [-o table|json|csv]    # PostgreSQL dialect
 ```
 
 
@@ -106,6 +106,10 @@ pub enum Commands {
         #[arg(long, visible_alias = "in")]
         index: Option<String>,
 
+        /// Database the index lives in (id; defaults to the active database)
+        #[arg(long, short = 'd')]
+        database: Option<String>,
+
         /// Columns to display (comma-separated, defaults to all)
         #[arg(long)]
         select: Option<String>,
 
@@ -9,7 +9,7 @@ use std::io::Write;
 use std::path::PathBuf;
 use std::sync::LazyLock;
 
-/// Subcommands for `hotdata context`.
+/// Subcommands for `hotdata databases context`.
 #[derive(clap::Subcommand)]
 pub enum ContextCommands {
     /// List named contexts in the workspace
@@ -234,8 +234,10 @@ pub fn show(workspace_id: &str, database_id: &str, name: &str) {
             );
             eprintln!(
                 "{}",
-                format!("Create ./{name}.md locally, then run: hotdata context push {name}")
-                    .dark_grey()
+                format!(
+                    "Create ./{name}.md locally, then run: hotdata databases context push {name}"
+                )
+                .dark_grey()
             );
             std::process::exit(1);
         }
 
@@ -178,7 +178,7 @@ pub enum DatabasesCommands {
         upload_id: Option<String>,
 
         /// Load a saved query result by id (e.g. `--result-id rslt…`, from
-        /// `hotdata results` or a query's `[result-id: …]` footer) instead of a
+        /// `hotdata databases results` or a query's `[result-id: …]` footer) instead of a
         /// file. The result must belong to the target database — the one it was
         /// queried in.
         #[arg(long, conflicts_with_all = ["file", "url", "upload_id"])]
@@ -194,7 +194,7 @@ pub enum DatabasesCommands {
         command: Option<DatabaseTablesCommands>,
     },
 
-    /// Sync database context with local Markdown (also at top-level `context`)
+    /// Sync database context with local Markdown
     Context {
         #[command(subcommand)]
         command: crate::commands::context::ContextCommands,
@@ -217,7 +217,7 @@ pub enum DatabasesCommands {
         command: Option<crate::commands::query::QueryCommands>,
     },
 
-    /// Inspect query run history (also at top-level `queries`)
+    /// Inspect query run history
     Queries {
         /// Query run ID to show details
         id: Option<String>,
@@ -234,7 +234,7 @@ pub enum DatabasesCommands {
         command: Option<crate::commands::queries::QueriesCommands>,
     },
 
-    /// Retrieve stored query results (also at top-level `results`)
+    /// Retrieve stored query results
     Results {
         /// Result ID (omit to use a subcommand)
         result_id: Option<String>,
@@ -261,16 +261,28 @@ pub enum DatabaseTablesCommands {
         #[arg(long)]
         database: Option<String>,
 
-        /// Filter by schema name
+        /// Filter by schema name (supports % wildcards)
         #[arg(long)]
         schema: Option<String>,
 
+        /// Filter by table name (supports % wildcards)
+        #[arg(long)]
+        table: Option<String>,
+
+        /// Maximum number of results to return
+        #[arg(long)]
+        limit: Option<u32>,
+
+        /// Pagination cursor from a previous response
+        #[arg(long)]
+        cursor: Option<String>,
+
         /// Output format
         #[arg(long = "output", short = 'o', default_value = "table", value_parser = ["table", "json", "yaml"])]
         output: String,
     },
 
-    /// Show column definitions for a table (also at top-level `tables show`)
+    /// Show column definitions for a table
     Show {
         /// Table as catalog.schema.table (or schema.table with an active database)
         table: String,
@@ -306,7 +318,7 @@ pub enum DatabaseTablesCommands {
         upload_id: Option<String>,
 
         /// Load a saved query result by id (e.g. `--result-id rslt…`, from
-        /// `hotdata results` or a query's `[result-id: …]` footer) instead of a
+        /// `hotdata databases results` or a query's `[result-id: …]` footer) instead of a
         /// file. The result must belong to the target database — the one it was
         /// queried in.
         #[arg(long, conflicts_with_all = ["file", "url", "upload_id"])]
 
@@ -510,9 +510,12 @@ pub fn create(
     }
 }
 
-/// A search index located by name, for `search`'s by-name addressing.
+/// A search index located by name within a managed database, for `search`'s
+/// by-name addressing. Carries the database's real ids (never a `__db_*` label).
 pub struct LocatedIndex {
-    pub connection: String,
+    pub database_id: String,
+    pub connection_id: String,
+    pub catalog: String,
     pub schema: String,
     pub table: String,
     pub index_type: String,
@@ -521,46 +524,55 @@ pub struct LocatedIndex {
     pub metric: Option<String>,
 }
 
-/// Find a search index by name — scoped to the active managed database when one
-/// is set, otherwise across the whole workspace. Errors on no match or on an
-/// ambiguous name (present on more than one table).
-pub fn locate_by_name(workspace_id: &str, name: &str) -> Result<LocatedIndex, String> {
+/// Find a search index by name within a managed database.
+///
+/// The database is required and addressed by id — an explicit `--database`, or
+/// the active one set via `hotdata databases use <id>`. There is no
+/// workspace-wide scan and no fallback to the internal `__db_*` connection
+/// label: the database's own `default_connection_id` addresses the index API and
+/// its `default_catalog` builds search SQL. Errors on no database, no match, or
+/// an ambiguous name.
+pub fn locate_by_name(
+    workspace_id: &str,
+    database: Option<&str>,
+    name: &str,
+) -> Result<LocatedIndex, String> {
     let api = Api::new(Some(workspace_id));
-    // Scope to the active managed database when one is set. Its SQL catalog
-    // alias is what a query must name — the index listing reports the internal
-    // `__db_*` connection label, which `bm25_search`/`vector_distance` cannot
-    // address, so prefer the alias when building the located table below.
-    let active_db = crate::config::load_current_database("default", workspace_id)
-        .and_then(|db_id| databases::get_database(&api, &db_id).ok());
-    let connection_id = active_db
-        .as_ref()
-        .map(|db| db.default_connection_id.clone());
-    let rows = collect_connection_wide(&api, connection_id.as_deref(), None, None)
+    let db_id = database
+        .map(str::to_string)
+        .or_else(|| crate::config::load_current_database("default", workspace_id))
+        .ok_or_else(|| {
+            "no database — pass --database <id> or set one with `hotdata databases use <id>`"
+                .to_string()
+        })?;
+    let db = databases::get_database(&api, &db_id).unwrap_or_else(|e| e.exit());
+    let connection_id = db.default_connection_id;
+    let catalog = db
+        .default_catalog
+        .unwrap_or_else(|| db.name.unwrap_or_else(|| "default".to_string()));
+
+    let rows = collect_connection_wide(&api, Some(&connection_id), None, None)
         .unwrap_or_else(|e| e.exit());
     let matches: Vec<&IndexRow> = rows.iter().filter(|r| r.inner.index_name == name).collect();
     match matches.as_slice() {
         [] => Err(format!(
-            "No search index named '{name}' — run 'hotdata search list' to see indexes."
+            "No search index named '{name}' in this database — run 'hotdata search list' to see indexes."
         )),
         [one] => {
             let loc = one.table.clone().unwrap_or_default();
             let parts: Vec<&str> = loc.splitn(3, '.').collect();
-            let (label_conn, schema, table) = match parts.as_slice() {
-                [c, s, t] => (c.to_string(), s.to_string(), t.to_string()),
+            let (schema, table) = match parts.as_slice() {
+                [_conn, s, t] => (s.to_string(), t.to_string()),
                 _ => return Err(format!("Could not resolve the table for index '{name}'.")),
             };
-            // Prefer the active db's SQL catalog alias over the internal
-            // `__db_*` connection label that the index listing reports.
-            let connection = active_db
-                .as_ref()
-                .and_then(|db| db.default_catalog.clone())
-                .unwrap_or(label_conn);
             let search_column = one
                 .inner
                 .search_column()
                 .ok_or_else(|| format!("Index '{name}' has no columns."))?;
             Ok(LocatedIndex {
-                connection,
+                database_id: db_id,
+                connection_id,
+                catalog,
                 schema,
                 table,
                 index_type: one.inner.index_type.clone(),
@@ -570,7 +582,7 @@ pub fn locate_by_name(workspace_id: &str, name: &str) -> Result<LocatedIndex, St
             })
         }
         _ => Err(format!(
-            "Multiple indexes named '{name}' across tables — this by-name form needs a unique name."
+            "Multiple indexes named '{name}' on this database — this by-name form needs a unique name."
         )),
     }
 }