datanotes 3.3.1 → 3.4.0

package/dist/datanotes.cjs

@@ -264,7 +264,7 @@ var init_catalog = __esm({
       },
       {
         "name": "list_tables",
-        "description": "List every table: `name`, `catalog`, `schema`, `qualified` (`personal.metrics.mood` \u2014 use it\nwherever a table is expected; `metrics.mood` or `mood` also work when unambiguous), `path` and,\nwhen declared, `description`, `aliases` (other words for what it records) and `tags`. Tables are\ndefined in `metastore.yaml` (catalog \u2192 schema \u2192 table): read it freely, but it is read-only for\nagents and changes only through the schema operations (create_table, add_column, \u2026). Returns `{tables, views}`: `views` lists the stored views (same fields, no\npath): select them like tables. `system.information_schema` is read with `select_rows`.\n\nCall this first to find the table for what the user reports (match their words against\nname, description and aliases), and before creating tables or columns so you reuse existing\nones instead of creating duplicates.",
+        "description": "List every table: `name`, `catalog`, `schema`, `qualified` (`personal.metrics.mood` \u2014 use it\nwherever a table is expected; `metrics.mood` or `mood` also work when unambiguous), `path` and,\nwhen declared, `description`, `aliases` (other words for what it records) and `tags`. Tables are\ndefined in `metastore.yaml` (catalog \u2192 schema \u2192 table): read it freely, but it is read-only for\nagents and changes only through the schema operations (create_table, add_column, \u2026). Returns `{tables, views}`: `views` lists the stored views (same fields, no\npath): select them like tables. `system.information_schema` is read with `select_rows`.\nA token with `read` patterns sees only the tables and views it may read.\n\nCall this first to find the table for what the user reports (match their words against\nname, description and aliases), and before creating tables or columns so you reuse existing\nones instead of creating duplicates.",
         "inputSchema": {
           "additionalProperties": false,
           "properties": {},
@@ -529,7 +529,7 @@ var init_catalog = __esm({
                   },
                   "generated": {
                     "type": "string",
-                    "description": "Expression of a generated column."
+                    "description": 'Expression of a generated column: a column, `date(col)\xB1N`, a template like `{name} {surname}`, `link(<template>)`, or an aggregate of a json list of objects like `count(feeds, side = "left")` or `sum(feeds.min)`.'
                   },
                   "dense": {
                     "type": "boolean",
@@ -650,7 +650,7 @@ var init_catalog = __esm({
       },
       {
         "name": "create_table",
-        "description": 'Create a table: `name`, in `catalog` and `schema` (default: the database\'s defaults); the definition\ngoes in metastore.yaml, the rows in `<root>/<catalog>/<schema>/<name>/`. Names: lowercase letters,\ndigits, `_` (no dots: pass the catalog and the schema as their own arguments).\n- `description` (required): what a row of the table records. Every column needs its own `description`\n  too, what it holds: the table is refused otherwise, with every missing one listed. Descriptions are how\n  agents and people understand the schema, so write them for a reader who never saw the notes. The\n  engine writes those of `id` and of `identity` "uuid" / "created" columns.\n- `columns`: specs like `{"name": "kind", "type": "enum", "values": ["a","b"], "required": true,\n  "description": "What kind of entry the row is"}`.\n  Types: string, integer, number, boolean, date, datetime, enum, link, list (+ `items`), json.\n  Attributes: required, default (`"{now}"`/`"{today}"`), min, max, step, values, `ordered` (enum in\n  order: filters/avg use the position), ref (link target, full `catalog.schema.table` or "self"),\n  unique, label, description, aliases, `generated` (e.g. `"date(occurred_at)"`, `"{name} {surname}"`),\n  `identity` ("filename" | "created"), `vocabulary` (allowed values = names of another table\'s rows),\n  `hierarchy: true` (one parent link to its own table), `acyclic: true` (links to rows of its own table that never loop back, such as tasks blocked by tasks; with `inverse`, the rule holds on both sides), `dense` (written on every row),\n  `inverse` on a link column: the column of the `ref` table that links back (`friends` \u2194\n  `friends`, `children` \u2194 `parents`, `partner` \u2194 `partner`); writes keep both sides in step.\n- `time_column`: rows named by that date/datetime; otherwise `filename` (e.g. `"{name}"`).\n- The table\'s options, as alter_table names them: `aliases` (how agents find it, with the\n  description), `partition`, `exclude`, `archive`, `history` (keep its versions; default: the\n  database\'s setting), `autolink_target` (true / false: may automatic links link its rows? default:\n  yes, unless its rows are named by a date or a time, as with `time_column`).\n- `row_template`: markdown body of new rows. Shared columns come from bases: `set_table_bases`.\n- `instructions`: how to fill a row, for agents (Markdown); describe_table returns them.\n- `tags`: key/value labels of the table, strings (`{"domain": "health"}`); list_tables and\n  describe_table return them, alter_table changes them.\nEnum columns: `values` and, for each, its meaning in `value_descriptions` (`{"stated": "the user said it", \u2026}`): describe_table shows them and a refused value lists them.\nGenerated link columns: `generated: "link({occurred_at:YYYY-MM-DD})"` with `ref` = the days table links each row to the row of `ref` named by the template (its folder read from the schema; the target may not exist yet).\nFiltered link targets (link columns): `ref_where` (a `where` every target must match) and `ref_by` (a column of the row picks the target level: `{"column": "kind", "levels": ["area", "project", "workstream"]}` or `{"column": "kind", "map": {"area": null, "project": ["area"]}}`; null = top level, no link; `target_column` when the target names it differently: an enum target column must have every value the map allows, a string one takes any value). A link to no row of the table, or to the row itself, is refused too. Existing rows that break them refuse the change; `list_link_targets` lists the valid targets of a row.\n\nThe schema changes only through operations like this one: never edit metastore.yaml by hand (no validation, no undo).',
+        "description": 'Create a table: `name`, in `catalog` and `schema` (default: the database\'s defaults); the definition\ngoes in metastore.yaml, the rows in `<root>/<catalog>/<schema>/<name>/`. Names: lowercase letters,\ndigits, `_` (no dots: pass the catalog and the schema as their own arguments).\n- `description` (required): what a row of the table records. Every column needs its own `description`\n  too, what it holds: the table is refused otherwise, with every missing one listed. Descriptions are how\n  agents and people understand the schema, so write them for a reader who never saw the notes. The\n  engine writes those of `id` and of `identity` "uuid" / "created" columns.\n- `columns`: specs like `{"name": "kind", "type": "enum", "values": ["a","b"], "required": true,\n  "description": "What kind of entry the row is"}`.\n  Types: string, integer, number, boolean, date, datetime, enum, link, list (+ `items`), json.\n  Attributes: required, default (`"{now}"`/`"{today}"`), min, max, step, values, `ordered` (enum in\n  order: filters/avg use the position), ref (link target, full `catalog.schema.table` or "self"),\n  unique, label, description, aliases, `generated` (e.g. `"date(occurred_at)"`, `"{name} {surname}"`),\n  `identity` ("filename" | "created"), `vocabulary` (allowed values = names of another table\'s rows),\n  `hierarchy: true` (one parent link to its own table), `acyclic: true` (links to rows of its own table that never loop back, such as tasks blocked by tasks; with `inverse`, the rule holds on both sides), `dense` (written on every row),\n  `inverse` on a link column: the column of the `ref` table that links back (`friends` \u2194\n  `friends`, `children` \u2194 `parents`, `partner` \u2194 `partner`); writes keep both sides in step.\n- `time_column`: rows named by that date/datetime; otherwise `filename` (e.g. `"{name}"`).\n- The table\'s options, as alter_table names them: `aliases` (how agents find it, with the\n  description), `partition`, `exclude`, `archive`, `history` (keep its versions; default: the\n  database\'s setting), `autolink_target` (true / false: may automatic links link its rows? default:\n  yes, unless its rows are named by a date or a time, as with `time_column`).\n- `row_template`: markdown body of new rows. Shared columns come from bases: `set_table_bases`.\n- `instructions`: how to fill a row, for agents (Markdown); describe_table returns them.\n- `tags`: key/value labels of the table, strings (`{"domain": "health"}`); list_tables and\n  describe_table return them, alter_table changes them.\nEnum columns: `values` and, for each, its meaning in `value_descriptions` (`{"stated": "the user said it", \u2026}`): describe_table shows them and a refused value lists them.\nGenerated link columns: `generated: "link({occurred_at:YYYY-MM-DD})"` with `ref` = the days table links each row to the row of `ref` named by the template (its folder read from the schema; the target may not exist yet).\nGenerated aggregates of a json column holding a list of objects (integer or number columns; avg: number): `count(feeds)`, `count(feeds.min)` (the items with a min), `sum(feeds.min)`, `avg(\u2026)`, `min(\u2026)`, `max(\u2026)`, with an optional filter on one field: `count(feeds, side = "left")`, `sum(feeds.min, min > 0)` (=, !=, <, <=, >, >=; "text", a number, true or false). Recomputed on every write; no list: count and sum 0, avg/min/max empty; a field that is not a number: empty.\nFiltered link targets (link columns): `ref_where` (a `where` every target must match) and `ref_by` (a column of the row picks the target level: `{"column": "kind", "levels": ["area", "project", "workstream"]}` or `{"column": "kind", "map": {"area": null, "project": ["area"]}}`; null = top level, no link; `target_column` when the target names it differently: an enum target column must have every value the map allows, a string one takes any value). A link to no row of the table, or to the row itself, is refused too. Existing rows that break them refuse the change; `list_link_targets` lists the valid targets of a row.\n\nThe schema changes only through operations like this one: never edit metastore.yaml by hand (no validation, no undo).',
         "inputSchema": {
           "additionalProperties": false,
           "properties": {
@@ -1744,7 +1744,7 @@ var init_catalog = __esm({
       },
       {
         "name": "add_column",
-        "description": 'Add a typed column. Sparse by default (written only on rows that have a value \u2014 use for\nmetrics, e.g. `{"name": "metric_mood", "type": "integer", "min": 1, "max": 5, "label":\n"Mood", "aliases": ["mood"], "description": "Mood of the day, 1 = bad, 5 = great"}`).\n`description` is required: what the column holds, for the agents and people who read the schema\n(the engine writes it for `identity` "uuid" / "created" columns).\n`dense: true` in the spec adds it to every row with its `default`. Call `describe_table` first: never add\na column whose meaning an existing column (name/label/aliases/description) already covers.\nColumn names are permanent identifiers; only `rename_column` changes them.\nEnum columns: `values` and, for each, its meaning in `value_descriptions` (`{"stated": "the user said it", \u2026}`): describe_table shows them and a refused value lists them.\nGenerated link columns: `generated: "link({occurred_at:YYYY-MM-DD})"` with `ref` = the days table links each row to the row of `ref` named by the template (its folder read from the schema; the target may not exist yet).\nFiltered link targets (link columns): `ref_where` (a `where` every target must match) and `ref_by` (a column of the row picks the target level: `{"column": "kind", "levels": ["area", "project", "workstream"]}` or `{"column": "kind", "map": {"area": null, "project": ["area"]}}`; null = top level, no link; `target_column` when the target names it differently: an enum target column must have every value the map allows, a string one takes any value). A link to no row of the table, or to the row itself, is refused too. Existing rows that break them refuse the change; `list_link_targets` lists the valid targets of a row.\nAcyclic links: `acyclic: true` on a link (or list of links) to the table itself refuses every write that closes a cycle, on either side of an `inverse`; refused while existing rows form one (they are listed).\n\nThe schema changes only through operations like this one: never edit metastore.yaml by hand (no validation, no undo).',
+        "description": 'Add a typed column. Sparse by default (written only on rows that have a value \u2014 use for\nmetrics, e.g. `{"name": "metric_mood", "type": "integer", "min": 1, "max": 5, "label":\n"Mood", "aliases": ["mood"], "description": "Mood of the day, 1 = bad, 5 = great"}`).\n`description` is required: what the column holds, for the agents and people who read the schema\n(the engine writes it for `identity` "uuid" / "created" columns).\n`dense: true` in the spec adds it to every row with its `default`. Call `describe_table` first: never add\na column whose meaning an existing column (name/label/aliases/description) already covers.\nColumn names are permanent identifiers; only `rename_column` changes them.\nEnum columns: `values` and, for each, its meaning in `value_descriptions` (`{"stated": "the user said it", \u2026}`): describe_table shows them and a refused value lists them.\nGenerated link columns: `generated: "link({occurred_at:YYYY-MM-DD})"` with `ref` = the days table links each row to the row of `ref` named by the template (its folder read from the schema; the target may not exist yet).\nGenerated aggregates of a json column holding a list of objects (integer or number columns; avg: number): `count(feeds)`, `count(feeds.min)` (the items with a min), `sum(feeds.min)`, `avg(\u2026)`, `min(\u2026)`, `max(\u2026)`, with an optional filter on one field: `count(feeds, side = "left")`, `sum(feeds.min, min > 0)` (=, !=, <, <=, >, >=; "text", a number, true or false). Recomputed on every write; no list: count and sum 0, avg/min/max empty; a field that is not a number: empty.\nFiltered link targets (link columns): `ref_where` (a `where` every target must match) and `ref_by` (a column of the row picks the target level: `{"column": "kind", "levels": ["area", "project", "workstream"]}` or `{"column": "kind", "map": {"area": null, "project": ["area"]}}`; null = top level, no link; `target_column` when the target names it differently: an enum target column must have every value the map allows, a string one takes any value). A link to no row of the table, or to the row itself, is refused too. Existing rows that break them refuse the change; `list_link_targets` lists the valid targets of a row.\nAcyclic links: `acyclic: true` on a link (or list of links) to the table itself refuses every write that closes a cycle, on either side of an `inverse`; refused while existing rows form one (they are listed).\n\nThe schema changes only through operations like this one: never edit metastore.yaml by hand (no validation, no undo).',
         "inputSchema": {
           "additionalProperties": false,
           "properties": {
@@ -5143,7 +5143,7 @@ var init_catalog = __esm({
       },
       {
         "name": "describe_database",
-        "description": "Describe the database: its folder (`root`), `metastore` (`metastore.yaml`: read it freely,\nbut it is read-only for agents and changes only through the schema operations), configuration\n(default catalog and schema, row partition and file-name formats, archive folder, time zone,\nhistory, automatic links),\njournal folder, `bases` (shared column sets and the tables using them), `catalogs` \u2192 `schemas` \u2192 `tables` (with `row_count`, `tags`, and `unreadable_count` when some rows' front matter cannot be read) and `views`;\ncatalogs and schemas show their `comment` (set with `comment_on`). A table or base defined before\ndescriptions were required has `missing_descriptions`: what lacks one, for alter_table / alter_column\n(define_base for a base) to fill, so every table and column says what it holds.",
+        "description": "Describe the database: its folder (`root`), `metastore` (`metastore.yaml`: read it freely,\nbut it is read-only for agents and changes only through the schema operations), configuration\n(default catalog and schema, row partition and file-name formats, archive folder, time zone,\nhistory, automatic links),\njournal folder, `bases` (shared column sets and the tables using them), `catalogs` \u2192 `schemas` \u2192 `tables` (with `row_count`, `tags`, and `unreadable_count` when some rows' front matter cannot be read) and `views`;\ncatalogs and schemas show their `comment` (set with `comment_on`). A table or base defined before\ndescriptions were required has `missing_descriptions`: what lacks one, for alter_table / alter_column\n(define_base for a base) to fill, so every table and column says what it holds.\nA token with `read` patterns sees only the tables, views and bases it may read.",
         "inputSchema": {
           "additionalProperties": false,
           "properties": {},
@@ -11707,6 +11707,141 @@ var init_catalog = __esm({
           ]
         }
       },
+      {
+        "name": "search",
+        "description": "Search the notes by their words and, when semantic search is on, by their meaning:\n`{query, results: [{path, table?, score, heading, snippet, matched_by}], meaning}`, one result per\nnote, best first. It always works: with semantic search off it ranks by words alone (BM25:\nrare words count more; a word in the note's name or properties counts more), with it on it fuses\nboth rankings (Reciprocal Rank Fusion), so a note found only by its words or only by its meaning\nis still there. `matched_by` says which (`words`, `meaning`); `meaning` is `on`, `off` or `failed`\n(the embedding provider failed: words only, `meaning_error` says why). Query syntax as search_docs:\n`\"a phrase\"` and `+word` must appear, `-word` must not (both rankings); words in any language,\ncase and accents ignored, no stemming. Filters: `tables` (qualified or short names), `folder`,\n`min_score` (the meaning ranking's cosine floor). `limit`: default 10, max 100. Then read_note /\nselect_rows for the details.",
+        "inputSchema": {
+          "additionalProperties": false,
+          "properties": {
+            "query": {
+              "type": "string"
+            },
+            "limit": {
+              "default": 10,
+              "type": "integer"
+            },
+            "tables": {
+              "anyOf": [
+                {
+                  "items": {
+                    "type": "string"
+                  },
+                  "type": "array"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "default": null
+            },
+            "folder": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "default": null
+            },
+            "min_score": {
+              "anyOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "default": null
+            }
+          },
+          "required": [
+            "query"
+          ],
+          "type": "object"
+        },
+        "annotations": {
+          "title": "Search",
+          "readOnlyHint": true,
+          "destructiveHint": false,
+          "idempotentHint": true,
+          "openWorldHint": false
+        },
+        "responseSchema": {
+          "type": "object",
+          "properties": {
+            "query": {
+              "type": "string"
+            },
+            "results": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "path": {
+                    "type": "string"
+                  },
+                  "table": {
+                    "type": "string",
+                    "description": "Qualified table of a row note."
+                  },
+                  "score": {
+                    "type": "number",
+                    "description": "BM25 when ranked by words alone; the Reciprocal Rank Fusion score when fused."
+                  },
+                  "heading": {
+                    "type": "string",
+                    "description": "Heading above the match (empty before the first heading)."
+                  },
+                  "snippet": {
+                    "type": "string",
+                    "description": "About 200 characters around the first match, or the best passage by meaning."
+                  },
+                  "matched_by": {
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "enum": [
+                        "words",
+                        "meaning"
+                      ]
+                    },
+                    "description": "The rankings the note is in."
+                  }
+                },
+                "required": [
+                  "path",
+                  "score",
+                  "heading",
+                  "snippet",
+                  "matched_by"
+                ]
+              },
+              "description": "One result per note, best first."
+            },
+            "meaning": {
+              "type": "string",
+              "enum": [
+                "on",
+                "off",
+                "failed"
+              ],
+              "description": "on: words and meaning fused; off: semantic search is off, words only; failed: the embedding provider failed, words only."
+            },
+            "meaning_error": {
+              "type": "string",
+              "description": "Why the meaning ranking failed (with meaning: failed)."
+            }
+          },
+          "required": [
+            "query",
+            "results",
+            "meaning"
+          ]
+        }
+      },
       {
         "name": "describe_semantic_index",
         "description": "The semantic search index: `enabled`, `provider`, `model`, `files`, `passages`, `pending`,\n`running`, `last_sync`, `last_error`. sync_semantic_index brings it up to date.",
@@ -17839,6 +17974,7 @@ var init_catalog = __esm({
       list_folder: "queries",
       search_notes: "queries",
       semantic_search: "queries",
+      search: "queries",
       graph_neighbors: "queries",
       graph_traverse: "queries",
       graph_path: "queries",
@@ -18558,14 +18694,14 @@ var require_identity = __commonJS({
     var ALIAS = Symbol.for("yaml.alias");
     var DOC = Symbol.for("yaml.document");
     var MAP = Symbol.for("yaml.map");
-    var PAIR = Symbol.for("yaml.pair");
+    var PAIR2 = Symbol.for("yaml.pair");
     var SCALAR = Symbol.for("yaml.scalar");
     var SEQ = Symbol.for("yaml.seq");
     var NODE_TYPE = Symbol.for("yaml.node.type");
     var isAlias = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === ALIAS;
     var isDocument = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === DOC;
     var isMap2 = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === MAP;
-    var isPair = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === PAIR;
+    var isPair = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === PAIR2;
     var isScalar2 = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === SCALAR;
     var isSeq = (node2) => !!node2 && typeof node2 === "object" && node2[NODE_TYPE] === SEQ;
     function isCollection(node2) {
@@ -18593,7 +18729,7 @@ var require_identity = __commonJS({
     exports2.DOC = DOC;
     exports2.MAP = MAP;
     exports2.NODE_TYPE = NODE_TYPE;
-    exports2.PAIR = PAIR;
+    exports2.PAIR = PAIR2;
     exports2.SCALAR = SCALAR;
     exports2.SEQ = SEQ;
     exports2.hasAnchor = hasAnchor;
@@ -24080,8 +24216,8 @@ var require_cst_visit = __commonJS({
     visit.REMOVE = REMOVE;
     visit.itemAtPath = (cst, path23) => {
       let item = cst;
-      for (const [field2, index] of path23) {
-        const tok = item?.[field2];
+      for (const [field3, index] of path23) {
+        const tok = item?.[field3];
         if (tok && "items" in tok) {
           item = tok.items[index];
         } else
@@ -24091,8 +24227,8 @@ var require_cst_visit = __commonJS({
     };
     visit.parentCollection = (cst, path23) => {
       const parent2 = visit.itemAtPath(cst, path23.slice(0, -1));
-      const field2 = path23[path23.length - 1][0];
-      const coll = parent2?.[field2];
+      const field3 = path23[path23.length - 1][0];
+      const coll = parent2?.[field3];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
@@ -24101,11 +24237,11 @@ var require_cst_visit = __commonJS({
       let ctrl = visitor(item, path23);
       if (typeof ctrl === "symbol")
         return ctrl;
-      for (const field2 of ["key", "value"]) {
-        const token = item[field2];
+      for (const field3 of ["key", "value"]) {
+        const token = item[field3];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path23.concat([[field2, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path23.concat([[field3, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -24115,7 +24251,7 @@ var require_cst_visit = __commonJS({
               i -= 1;
             }
           }
-          if (typeof ctrl === "function" && field2 === "key")
+          if (typeof ctrl === "function" && field3 === "key")
             ctrl = ctrl(item, path23);
         }
       }
@@ -26239,6 +26375,7 @@ var init_hints = __esm({
       renameColumn: "/guides/database-objects/columns.md#rename-a-column",
       generated: "/guides/data-quality/hand-edits.md#recompute-generated-columns-after-a-hand-edit",
       computed: "/guides/database-objects/columns.md#compute-a-column-from-other-columns",
+      jsonAggregates: "/guides/database-objects/columns.md#count-and-total-the-items-of-a-json-list",
       partition: "/guides/database-objects/columns.md#partition-rows-into-folders",
       filters: "/guides/read-and-write/read-and-filter.md#compare-values-with-operators",
       logical: "/guides/read-and-write/read-and-filter.md#combine-filters-with-or-and-and-not",
@@ -26297,10 +26434,12 @@ var init_hints = __esm({
       graph: "/guides/search/link-graph.md#walk-the-links-from-a-note",
       graphTables: "/guides/search/link-graph.md#read-the-whole-graph-in-one-call",
       semantic: "/guides/search/semantic.md#turn-on-semantic-search",
+      search: "/guides/search/hybrid.md#search-by-words-and-meaning",
       docsSearch: "/guides/agents/docs-offline.md#search-by-words-and-by-meaning",
       tokens: "/guides/security/tokens.md#choose-what-a-token-can-do",
       manageTokens: "/guides/security/tokens.md#manage-your-tokens",
       tokenAutolink: "/guides/security/tokens.md#turn-automatic-links-off-for-a-sync-program",
+      tokenRead: "/guides/security/tokens.md#limit-what-a-token-can-read",
       reportAgents: "/guides/security/who-did-what.md#report-what-an-agent-does",
       auth: "/develop/http-api.md#authenticate-your-requests",
       routes: "/develop/http-api.md#call-the-engines-routes",
@@ -26703,6 +26842,64 @@ var init_datetime = __esm({
 });
 
 // src/core/generated.ts
+function filterValue(text5) {
+  if (text5 === "true" || text5 === "false") return text5 === "true";
+  if (NUMBER_LITERAL.test(text5)) return Number(text5);
+  if (/^'[^']*'$/.test(text5)) return text5.slice(1, -1);
+  if (/^"[\s\S]*"$/.test(text5)) {
+    try {
+      return JSON.parse(text5);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function parseAggregate(expr) {
+  const e = expr.trim();
+  if (!AGGREGATE_START.test(e)) return null;
+  const fail2 = (message) => new GeneratedExpressionError(message, AGGREGATE_GUIDANCE);
+  const m = e.match(AGGREGATE_EXPR);
+  if (!m) throw fail2(`"${expr}" is not an aggregate: write count(column), count(column, field = value) or sum|avg|min|max(column.field), with an optional filter`);
+  const fn = m[1];
+  const column = m[2];
+  if (fn !== "count" && m[3] === void 0) throw fail2(`"${expr}": ${fn}() needs a field of the items, like ${fn}(${column}.minutes)`);
+  const out2 = { fn, column, ...m[3] !== void 0 ? { field: m[3] } : {} };
+  if (m[4] === void 0) return out2;
+  const f = m[4].match(FILTER_EXPR);
+  if (!f) throw fail2(`"${expr}": the filter "${m[4]}" must compare a field with a value, like side = "left"`);
+  const op2 = f[2];
+  const raw = f[3].trim();
+  const value = filterValue(raw);
+  if (value === void 0) throw fail2(`"${expr}": the filter value ${raw} is not "text", a number, true or false`);
+  if (op2 !== "=" && op2 !== "!=" && typeof value !== "number") throw fail2(`"${expr}": ${op2} compares numbers: the filter value must be a number, like min ${op2} 5`);
+  return { ...out2, filter: { field: f[1], op: op2, value } };
+}
+function passes(item, filter) {
+  const v = fieldOf(item, filter.field);
+  if (filter.op === "=") return v === filter.value;
+  if (filter.op === "!=") return v !== filter.value;
+  if (typeof v !== "number" || !Number.isFinite(v)) return false;
+  const n = filter.value;
+  if (filter.op === "<") return v < n;
+  if (filter.op === "<=") return v <= n;
+  if (filter.op === ">") return v > n;
+  return v >= n;
+}
+function evalAggregate(a, value) {
+  const list4 = value === void 0 || value === null ? [] : value;
+  if (!Array.isArray(list4)) return null;
+  const items3 = a.filter ? list4.filter((x) => passes(x, a.filter)) : list4;
+  if (a.field === void 0) return items3.length;
+  const values = items3.map((x) => fieldOf(x, a.field)).filter((v) => v !== void 0 && v !== null);
+  if (a.fn === "count") return values.length;
+  if (values.some((v) => typeof v !== "number" || !Number.isFinite(v))) return null;
+  const nums = values;
+  if (a.fn === "sum") return tidy(nums.reduce((s, n) => s + n, 0));
+  if (nums.length === 0) return null;
+  if (a.fn === "avg") return tidy(nums.reduce((s, n) => s + n, 0) / nums.length);
+  return a.fn === "min" ? Math.min(...nums) : Math.max(...nums);
+}
 function placeholderCols(m) {
   return m[2] ? m[2].split(",").map((c) => c.trim()) : [m[3]];
 }
@@ -26714,6 +26911,8 @@ function isTemplateExpression(expr) {
 }
 function generatedRefs(expr) {
   const e = expr.trim();
+  const agg = parseAggregate(expr);
+  if (agg) return [agg.column];
   const lm = e.match(LINK_EXPR);
   if (lm) {
     if (!lm[1].includes("{")) throw new GeneratedExpressionError(`"${expr}": link() needs a name template with at least one {column}`);
@@ -26755,6 +26954,8 @@ function display(value) {
 function evalGenerated(expr, get, path23, linkFolder) {
   const e = expr.trim();
   const read3 = (col) => col === "path" ? path23 : get(col);
+  const agg = parseAggregate(e);
+  if (agg) return evalAggregate(agg, read3(agg.column));
   const lm = e.match(LINK_EXPR);
   if (lm) {
     const tpl = lm[1];
@@ -26766,8 +26967,8 @@ function evalGenerated(expr, get, path23, linkFolder) {
   }
   if (isTemplateExpression(e)) {
     const out2 = e.replace(PLACEHOLDER_RE, (...args) => placeholderText(args, read3));
-    const tidy = out2.replace(/\s+/g, " ").replace(/\(\s*\)|\[\s*\]/g, "").replace(/\s+/g, " ").trim();
-    return tidy === "" ? null : tidy;
+    const tidy2 = out2.replace(/\s+/g, " ").replace(/\(\s*\)|\[\s*\]/g, "").replace(/\s+/g, " ").trim();
+    return tidy2 === "" ? null : tidy2;
   }
   const m = e.match(DATE_EXPR);
   if (m) {
@@ -26785,18 +26986,30 @@ function placeholderText(m, read3) {
   if (m[1] === "max") return [...texts].sort().pop();
   return texts[0];
 }
-var GeneratedExpressionError, PLACEHOLDER_RE, LINK_EXPR, DATE_EXPR, COLUMN_EXPR;
+var GeneratedExpressionError, AGGREGATE_GUIDANCE, AGGREGATE_START, AGGREGATE_EXPR, FILTER_EXPR, NUMBER_LITERAL, isObject, fieldOf, tidy, PLACEHOLDER_RE, LINK_EXPR, DATE_EXPR, COLUMN_EXPR;
 var init_generated = __esm({
   "src/core/generated.ts"() {
     "use strict";
     init_validate();
     init_datetime();
-    GeneratedExpressionError = class extends Error {
+    init_hints();
+    GeneratedExpressionError = class extends GuidedError {
       constructor() {
         super(...arguments);
         this.name = "GeneratedExpressionError";
       }
     };
+    AGGREGATE_GUIDANCE = guide(
+      `An aggregate reads a json column holding a list of objects: count(feeds), count(feeds, side = "left"), count(feeds.min) (the items with a min), sum(feeds.min), avg|min|max(feeds.min, side != "right"). A filter compares one field of the item with "text", a number, true or false, using =, !=, <, <=, > or >=.`,
+      "jsonAggregates"
+    );
+    AGGREGATE_START = /^(count|sum|avg|min|max)\s*\(/;
+    AGGREGATE_EXPR = /^(count|sum|avg|min|max)\s*\(\s*([A-Za-z][A-Za-z0-9_-]*)(?:\.([A-Za-z_][A-Za-z0-9_-]*))?\s*(?:,\s*([\s\S]*?))?\s*\)$/;
+    FILTER_EXPR = /^([A-Za-z_][A-Za-z0-9_-]*)\s*(!=|<=|>=|=|<|>)\s*([\s\S]*)$/;
+    NUMBER_LITERAL = /^-?\d+(?:\.\d+)?$/;
+    isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+    fieldOf = (item, field3) => isObject(item) ? item[field3] : void 0;
+    tidy = (n) => Number(n.toPrecision(15));
     PLACEHOLDER_RE = /\{(?:(min|max|coalesce)\(\s*([A-Za-z][A-Za-z0-9_-]*(?:\s*,\s*[A-Za-z][A-Za-z0-9_-]*)*)\s*\)|([A-Za-z][A-Za-z0-9_-]*))(?::([^}]+))?\}/g;
     LINK_EXPR = /^link\(\s*([\s\S]+?)\s*\)$/;
     DATE_EXPR = /^date\(\s*([A-Za-z][A-Za-z0-9_-]*)\s*\)\s*(?:([+-])\s*(\d+))?$/;
@@ -27147,7 +27360,7 @@ function checkGeneratedColumns(specs, known) {
     try {
       refs = generatedRefs(c.generated);
     } catch (e) {
-      throw new MalformedColumnError(index, messageOf(e));
+      throw new MalformedColumnError(index, messageOf(e), guidanceOf(e) ?? void 0);
     }
     if (isTemplateExpression(c.generated) && c.type !== "string") {
       throw new MalformedColumnError(index, `a template expression makes text: "${c.name}" must be a string column`);
@@ -27164,8 +27377,37 @@ function checkGeneratedColumns(specs, known) {
         throw new MalformedColumnError(index, `"generated" reads generated column "${ref2}", declared after it`);
       }
     }
+    const agg = parseAggregate(c.generated);
+    if (agg) checkAggregate(c, index, agg, specs);
   });
 }
+function checkAggregate(c, index, agg, specs) {
+  const source = specs.find((s) => s.name === agg.column);
+  if (source?.type !== "json" && !(source?.type === "list" && source.items === "json")) {
+    const what = !source ? `"${agg.column}" is ${agg.column === "path" ? "the row's path" : "an untyped field"}` : source.type === "list" ? (
+      // parseColumn gives every list its items ("string" when the spec has none)
+      `"${agg.column}" is a list of ${source.items}`
+    ) : `"${agg.column}" has type ${source.type}`;
+    throw new MalformedColumnError(
+      index,
+      `"generated" aggregates "${agg.column}", which is not a json column`,
+      guide(`${agg.fn}() reads a json column (type json, or a list of json) holding a list of objects, such as [{side: left, min: 12}]; ${what}. describe_table shows the type of each column.`, "jsonAggregates")
+    );
+  }
+  const fits = agg.fn === "avg" ? c.type === "number" : c.type === "number" || c.type === "integer";
+  if (fits) return;
+  if (agg.fn === "count") {
+    throw new MalformedColumnError(index, `count() makes a whole number: "${c.name}" must be an integer or number column`, guide(`Give "${c.name}" type "integer" or "number".`, "jsonAggregates"));
+  }
+  if (agg.fn === "avg") {
+    throw new MalformedColumnError(index, `avg() makes a number: "${c.name}" must be a number column`, guide(`Give "${c.name}" type "number": an average is seldom a whole number.`, "jsonAggregates"));
+  }
+  throw new MalformedColumnError(
+    index,
+    `${agg.fn}() makes a number: "${c.name}" must be a number or integer column`,
+    guide(`Give "${c.name}" type "number", or "integer" when the field holds only whole numbers.`, "jsonAggregates")
+  );
+}
 function tableDefinitionFromOrdered(ref2, schemaPath, ordered, settings) {
   const reserved = new Set(TABLE_META_KEYS);
   const options = parseTableOptions(fmGet(ordered, TABLE_KEY));
@@ -28817,6 +29059,89 @@ var init_database_move = __esm({
   }
 });
 
+// src/core/read-scope.ts
+function runWithReadScope(scope, fn) {
+  if (!storage2) {
+    if (scope) throw new Error("read permissions need Node's AsyncLocalStorage");
+    return fn();
+  }
+  if (!scope && !storage2.getStore()) return fn();
+  return storage2.run({ scope }, fn);
+}
+function currentReadScope() {
+  return storage2?.getStore()?.scope ?? null;
+}
+function matchesTablePattern(full, patterns) {
+  return patterns.some((p) => {
+    if (p === "*") return true;
+    if (p.endsWith(".*")) return full.startsWith(p.slice(0, -1));
+    return p === full;
+  });
+}
+function tableReadable(full, scope = currentReadScope()) {
+  return scope === null || matchesTablePattern(full, scope.patterns);
+}
+function tableReadDenied(token, full) {
+  return new ReadDeniedError(`token ${token} may not read ${full}`);
+}
+function pathReadDenied(token, path23) {
+  return new ReadDeniedError(`token ${token} may not read the note ${path23}`);
+}
+function assertTableReadable(full) {
+  const scope = currentReadScope();
+  if (scope && !matchesTablePattern(full, scope.patterns)) throw tableReadDenied(scope.token, full);
+}
+function tableOfPath(app, settings, path23) {
+  const idx = vaultIndex(app, settings);
+  if (idx && !idx.hasFailures) return idx.note(path23)?.table ?? null;
+  const model = cachedMetastore(app, settings);
+  const file = app.vault.getAbstractFileByPath(path23);
+  if (!model || !file || !("extension" in file)) return null;
+  let value;
+  try {
+    value = app.metadataCache.getFileCache(file)?.frontmatter?.[settings.tableKey];
+  } catch {
+    return null;
+  }
+  return rowTableFull(model, value);
+}
+function pathReadable(app, settings, path23, scope = currentReadScope()) {
+  if (scope === null) return true;
+  const table = tableOfPath(app, settings, path23);
+  return table !== null && matchesTablePattern(table, scope.patterns);
+}
+function assertPathReadable(app, settings, path23) {
+  const scope = currentReadScope();
+  if (scope && !pathReadable(app, settings, path23, scope)) throw pathReadDenied(scope.token, path23);
+}
+var storage2, READ_SCOPE_SUPPORTED, READ_DENIED_GUIDANCE, ReadDeniedError;
+var init_read_scope = __esm({
+  "src/core/read-scope.ts"() {
+    "use strict";
+    init_hints();
+    init_metastore();
+    init_vault_index();
+    storage2 = null;
+    try {
+      const { AsyncLocalStorage: AsyncLocalStorage2 } = require("node:async_hooks");
+      storage2 = new AsyncLocalStorage2();
+    } catch {
+      storage2 = null;
+    }
+    READ_SCOPE_SUPPORTED = storage2 !== null;
+    READ_DENIED_GUIDANCE = guide(
+      `The owner grants reads with tokens/update/ and "read" patterns (catalog.schema.table, catalog.schema.*, catalog.* or *). list_tables lists the tables this token may read.`,
+      "tokenRead"
+    );
+    ReadDeniedError = class extends GuidedError {
+      constructor(message) {
+        super(message, READ_DENIED_GUIDANCE);
+        this.name = "ReadDeniedError";
+      }
+    };
+  }
+});
+
 // src/core/journal.ts
 function pad(n) {
   return String(n).padStart(2, "0");
@@ -28984,7 +29309,11 @@ async function readJournal(app, settings, migrationId) {
 async function markUndone(app, settings, migrationId, undoneBy, now) {
   await appendLine(app, journalFileFor(settings, migrationId), { type: "undone", migration_id: migrationId, undone_by: undoneBy, at: now.toISOString() });
 }
+function tableOfEntry(e) {
+  return e.schema?.includes("#") ? e.schema.slice(e.schema.indexOf("#") + 1) : void 0;
+}
 async function listMigrations(app, settings, input = {}) {
+  const scope = currentReadScope();
   const files = (await storeList(app, journalDir(settings))).files.filter((f) => f.endsWith(".jsonl")).sort().reverse();
   const limit = Math.max(1, Math.min(input.limit ?? 50, 1e3));
   const since = input.since ? Date.parse(input.since) : NaN;
@@ -29000,13 +29329,17 @@ async function listMigrations(app, settings, input = {}) {
       if (input.op && e.op !== input.op) continue;
       if (input.table && !(e.schema ?? "").includes(input.table) && !e.summary.includes(input.table)) continue;
       if (!Number.isNaN(since) && Date.parse(e.executed_at) < since) continue;
+      if (scope) {
+        const table = tableOfEntry(e);
+        if (table === void 0 || !tableReadable(table, scope)) continue;
+      }
       total++;
       if (out2.length >= limit) continue;
       out2.push({
         migration_id: e.migration_id,
         op: e.op,
         summary: e.summary,
-        ...e.schema?.includes("#") ? { table: e.schema.slice(e.schema.indexOf("#") + 1) } : {},
+        ...tableOfEntry(e) !== void 0 ? { table: tableOfEntry(e) } : {},
         executed_at: e.executed_at,
         notes_changed: e.rows.length,
         files_changed: e.creates.length + e.moves.length + e.references.length + (e.deleted?.length ?? 0),
@@ -29116,6 +29449,7 @@ var init_journal = __esm({
     init_store();
     init_database_move();
     init_tracing();
+    init_read_scope();
     BLOB_MIN = 2048;
     MigrationNotFoundError = class extends Error {
       constructor(migrationId) {
@@ -31624,10 +31958,146 @@ var init_link_paths = __esm({
   }
 });
 
+// src/core/query-tables.ts
+function refOf2(model, name, kind) {
+  try {
+    return resolveCatalogRef(model, name, kind)?.full ?? null;
+  } catch {
+    return null;
+  }
+}
+function isSystemTable(name) {
+  const t = name.trim();
+  if (t.startsWith(`${SYSTEM_CATALOG}.`)) return true;
+  const parts = t.split(".");
+  return parts.length === 2 && parts[0] === "information_schema";
+}
+function queryTables(q, model, out2, depth) {
+  const text5 = JSON.stringify(q);
+  const r = { vault: false, today: text5.includes("{today"), now: text5.includes("{now") };
+  if (depth > 8) return { ...r, vault: true };
+  if (text5.includes("within") || text5.includes("{this")) r.vault = true;
+  if (DOTTED_KEY.test(text5) && !linkedTables(q, model, out2)) r.vault = true;
+  if (text5.includes("file_backlink_count")) r.links = true;
+  if (Object.keys(q).some((k) => !PLAIN_SELECT_KEYS.has(k))) r.vault = true;
+  const sources = [q.table];
+  if (q.join && typeof q.join === "object") sources.push(q.join.table);
+  if (Array.isArray(q.union)) for (const b of q.union) sources.push(b && typeof b === "object" ? b.table : void 0);
+  for (const name of sources) {
+    if (typeof name === "string" && isSystemTable(name)) {
+      r.store = true;
+      continue;
+    }
+    if (typeof name !== "string" || name.startsWith("base:")) {
+      r.vault = true;
+      continue;
+    }
+    const table = refOf2(model, name, "table");
+    const view = refOf2(model, name, "view");
+    if (!table && !view) r.vault = true;
+    if (table) out2.add(table);
+    const v = view ? viewQuery(model, view) : null;
+    if (view && !v) r.vault = true;
+    if (v) {
+      const sub = queryTables(v, model, out2, depth + 1);
+      r.vault ||= sub.vault;
+      r.links ||= sub.links;
+      r.store ||= sub.store;
+      r.today ||= sub.today;
+      r.now ||= sub.now;
+    }
+  }
+  return r;
+}
+function plainTable(model, name) {
+  return typeof name === "string" && !refOf2(model, name, "view") ? refOf2(model, name, "table") : null;
+}
+function linkedTables(q, model, out2) {
+  const join = isRecord2(q.join) ? q.join : null;
+  const branches = Array.isArray(q.union) ? q.union : null;
+  const rest = {
+    ...q,
+    where: void 0,
+    join: join ? { ...join, where: void 0 } : q.join,
+    union: branches ? branches.map((b) => isRecord2(b) ? { ...b, where: void 0 } : b) : q.union
+  };
+  if (DOTTED_KEY.test(JSON.stringify(rest))) return false;
+  const roots = branches ? branches.map((b) => isRecord2(b) ? plainTable(model, b.table) : null) : [plainTable(model, q.table)];
+  if (roots.length === 0) return false;
+  for (const table of roots) if (!followKeys(q.where, table, model, out2)) return false;
+  if (join && !followKeys(join.where, plainTable(model, join.table), model, out2)) return false;
+  for (const b of branches ?? []) if (isRecord2(b) && !followKeys(b.where, plainTable(model, b.table), model, out2)) return false;
+  return true;
+}
+function followKeys(where, table, model, out2) {
+  if (where === null || typeof where !== "object") return true;
+  if (Array.isArray(where)) return where.every((w) => followKeys(w, table, model, out2));
+  for (const [key2, cond] of Object.entries(where)) {
+    if (key2 === "and" || key2 === "or" || key2 === "not") {
+      if (!followKeys(cond, table, model, out2)) return false;
+    } else if (key2.indexOf(".") > 0 && (table === null || !followPath(key2, table, model, out2))) return false;
+  }
+  return true;
+}
+function followPath(key2, table, model, out2) {
+  let current2 = table;
+  for (const column of key2.split(".").slice(0, -1)) {
+    const next = linkTarget(model, current2, column);
+    if (!next) return false;
+    out2.add(next);
+    current2 = next;
+  }
+  return true;
+}
+function linkTarget(model, full, column) {
+  const t = catalogTables(model).find((x) => x.ref.full === full);
+  if (!t) return null;
+  let columns;
+  try {
+    columns = effectiveColumns(model, t.ref, t.entry);
+  } catch {
+    return null;
+  }
+  const c = columns.find((x) => x.name === column);
+  const link = c !== void 0 && (c.type === "link" || c.type === "list" && c.items === "link");
+  return link && typeof c.ref === "string" ? refOf2(model, c.ref, "table") : null;
+}
+function viewQuery(model, full) {
+  const [catalog, schema, name] = full.split(".");
+  const q = model.catalogs[catalog]?.schemas[schema]?.views[name]?.query;
+  return q && typeof q === "object" ? q : null;
+}
+function tablesReadByQuery(q, model) {
+  const found = /* @__PURE__ */ new Set();
+  const r = queryTables(q, model, found, 0);
+  return { tables: [...found].sort(), complete: !r.vault };
+}
+function tablesReadByView(model, viewFull) {
+  const q = viewQuery(model, viewFull);
+  return q ? tablesReadByQuery(q, model) : { tables: [], complete: false };
+}
+var PLAIN_SELECT_KEYS, DOTTED_KEY, isRecord2;
+var init_query_tables = __esm({
+  "src/core/query-tables.ts"() {
+    "use strict";
+    init_metastore();
+    PLAIN_SELECT_KEYS = /* @__PURE__ */ new Set(["table", "columns", "where", "order_by", "limit", "offset", "group_by", "aggregates", "include_body", "join", "union"]);
+    DOTTED_KEY = /"[^"]*\.[^"]*"\s*:/;
+    isRecord2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+  }
+});
+
 // src/core/table-registry.ts
+function viewReadable(model, viewFull, scope = currentReadScope()) {
+  if (scope === null) return true;
+  if (!tableReadable(viewFull, scope)) return false;
+  const reads = tablesReadByView(model, viewFull);
+  return reads.complete && reads.tables.every((t) => tableReadable(t, scope));
+}
 function tableNotFound(ref2, model, kind = "table") {
-  const tables = model ? catalogTables(model).map(({ ref: r, entry }) => ({ r, aliases: entry.aliases })) : [];
-  const views = model ? catalogViews(model).map(({ ref: r, view }) => ({ r, aliases: view.aliases })) : [];
+  const scope = currentReadScope();
+  const tables = model ? catalogTables(model).filter(({ ref: r }) => tableReadable(r.full, scope)).map(({ ref: r, entry }) => ({ r, aliases: entry.aliases })) : [];
+  const views = model ? catalogViews(model).filter(({ ref: r }) => viewReadable(model, r.full, scope)).map(({ ref: r, view }) => ({ r, aliases: view.aliases })) : [];
   if (model && kind === "table") {
     const view = views.find(({ r }) => r.full === ref2.trim() || r.table === ref2.trim() || `${r.schema}.${r.table}` === ref2.trim());
     if (view) {
@@ -31654,7 +32124,7 @@ function tableNotFound(ref2, model, kind = "table") {
     guide(
       sentences(
         near.length > 0 ? `Did you mean ${near.join(" or ")}?` : "",
-        kind !== "view" ? tableNames.length > 0 ? `Tables: ${nameList(tableNames)}.` : "There are no tables yet (create_table makes one)." : "",
+        kind !== "view" ? tableNames.length > 0 ? `Tables: ${nameList(tableNames)}.` : scope ? `Token ${scope.token} may read no table.` : "There are no tables yet (create_table makes one)." : "",
         kind !== "table" && viewNames.length > 0 ? `Views: ${nameList(viewNames)}.` : kind === "view" ? "There are no views." : "",
         "list_tables lists them with their descriptions and aliases."
       ),
@@ -31791,6 +32261,8 @@ var init_table_registry = __esm({
     init_vault_index();
     init_hints();
     init_db_paths();
+    init_read_scope();
+    init_query_tables();
     TableNotFoundError = class extends GuidedError {
       constructor(ref2, guidance) {
         super(`Table not found: ${ref2}`, guidance);
@@ -32099,57 +32571,68 @@ async function describeDatabase(app, settings) {
   const config2 = await readDatabaseConfig(app, settings);
   const ms = await loadMetastore(app, settings);
   const catalogs = [];
+  const scope = currentReadScope();
+  const readable = (full) => tableReadable(full, scope);
   if (ms) {
-    const byTable = new Map(catalogTables(ms.model).map((x) => [x.ref.full, catalogLoadedTable(settings, ms, x.ref)]));
+    const byTable = new Map(catalogTables(ms.model).filter((x) => readable(x.ref.full)).map((x) => [x.ref.full, catalogLoadedTable(settings, ms, x.ref)]));
     const rowFiles = catalogRowFilesOf(app, settings, [...byTable].map(([full, t]) => ({ full, def: t.def })));
     const unreadable = /* @__PURE__ */ new Map();
     for (const u of await unreadableRows(app, settings, ms.model)) unreadable.set(u.table, (unreadable.get(u.table) ?? 0) + 1);
     for (const [catalog, cat] of Object.entries(ms.model.catalogs)) {
+      const schemas = Object.entries(cat.schemas).map(([schema, sch]) => ({
+        schema,
+        ...sch.description ? { description: sch.description } : {},
+        tables: Object.entries(sch.tables).filter(([name]) => readable(`${catalog}.${schema}.${name}`)).map(([name, entry]) => {
+          const full = `${catalog}.${schema}.${name}`;
+          const t = byTable.get(full);
+          const tags = tableTags(entry);
+          const missing = missingDescriptions(t.def.options.description, t.def.columns);
+          return {
+            name,
+            qualified: full,
+            row_count: rowFiles.get(full).length,
+            ...entry.description ? { description: entry.description } : {},
+            ...tags ? { tags } : {},
+            ...missing ? { missing_descriptions: missing } : {},
+            ...unreadable.has(full) ? { unreadable_count: unreadable.get(full) } : {}
+          };
+        }),
+        views: Object.entries(sch.views).filter(([name]) => viewReadable(ms.model, `${catalog}.${schema}.${name}`, scope)).map(([name, v]) => ({
+          name,
+          qualified: `${catalog}.${schema}.${name}`,
+          ...v.description ? { description: v.description } : {}
+        }))
+      })).filter((x) => !scope || x.tables.length > 0 || x.views.length > 0);
+      if (scope && schemas.length === 0) continue;
       catalogs.push({
         catalog,
         ...cat.description ? { description: cat.description } : {},
         ...catalog === config2.default_catalog ? { default: true } : {},
-        schemas: Object.entries(cat.schemas).map(([schema, sch]) => ({
-          schema,
-          ...sch.description ? { description: sch.description } : {},
-          tables: Object.entries(sch.tables).map(([name, entry]) => {
-            const full = `${catalog}.${schema}.${name}`;
-            const t = byTable.get(full);
-            const tags = tableTags(entry);
-            const missing = missingDescriptions(t.def.options.description, t.def.columns);
-            return {
-              name,
-              qualified: full,
-              row_count: rowFiles.get(full).length,
-              ...entry.description ? { description: entry.description } : {},
-              ...tags ? { tags } : {},
-              ...missing ? { missing_descriptions: missing } : {},
-              ...unreadable.has(full) ? { unreadable_count: unreadable.get(full) } : {}
-            };
-          }),
-          views: Object.entries(sch.views).map(([name, v]) => ({
-            name,
-            qualified: `${catalog}.${schema}.${name}`,
-            ...v.description ? { description: v.description } : {}
-          }))
-        }))
+        schemas
       });
     }
   }
+  const extending = (name, seen = /* @__PURE__ */ new Set()) => {
+    if (!ms || seen.has(name)) return [];
+    seen.add(name);
+    const direct = catalogTables(ms.model).filter(({ entry }) => (entry.bases ?? []).includes(name)).map(({ ref: ref2 }) => ref2.full);
+    const via = Object.entries(ms.model.bases).filter(([, b]) => (b.bases ?? []).includes(name)).flatMap(([n]) => extending(n, seen));
+    return [...direct, ...via];
+  };
   return {
     root,
     metastore: metastorePath(settings),
     journal: storePath("journal"),
     config: config2,
     catalogs,
-    bases: ms ? Object.entries(ms.model.bases).map(([name, b]) => {
+    bases: ms ? Object.entries(ms.model.bases).filter(([name]) => !scope || extending(name).some(readable)).map(([name, b]) => {
       const missing = missingDescriptions(b.description, b.columns);
       return {
         name,
         ...b.description ? { description: b.description } : {},
         ...b.bases ? { bases: b.bases } : {},
         columns: b.columns.map((c) => String(c.name)),
-        tables: catalogTables(ms.model).filter(({ entry }) => (entry.bases ?? []).includes(name)).map(({ ref: ref2 }) => ref2.full),
+        tables: catalogTables(ms.model).filter(({ ref: ref2, entry }) => (entry.bases ?? []).includes(name) && readable(ref2.full)).map(({ ref: ref2 }) => ref2.full),
         ...missing ? { missing_descriptions: { base: missing.table, columns: missing.columns } } : {}
       };
     }) : []
@@ -32392,6 +32875,8 @@ var init_database = __esm({
     init_descriptions();
     init_db_paths();
     init_unreadable();
+    init_read_scope();
+    init_table_registry();
     DatabaseConfigError = class extends GuidedError {
       constructor() {
         super(...arguments);
@@ -32419,7 +32904,7 @@ var init_database = __esm({
 
 // src/core/write-check.ts
 function staleWrite(app) {
-  const ctx = storage2?.getStore();
+  const ctx = storage3?.getStore();
   if (ctx === void 0 || ctx.gen === generation(app)) return false;
   ctx.stale = true;
   return true;
@@ -32427,12 +32912,12 @@ function staleWrite(app) {
 function wrote(app) {
   const next = generation(app) + 1;
   GENERATION.set(app, next);
-  const ctx = storage2?.getStore();
+  const ctx = storage3?.getStore();
   if (ctx) ctx.gen = next;
 }
 async function runWrite(app, fn, isStale) {
-  if (!storage2) return fn();
-  const s = storage2;
+  if (!storage3) return fn();
+  const s = storage3;
   let ctx = { gen: 0, stale: false };
   const attempt = () => s.run(ctx = { gen: generation(app), stale: false }, fn);
   let result = await attempt();
@@ -32442,19 +32927,19 @@ async function runWrite(app, fn, isStale) {
 function holdsStaleWrite(value) {
   return JSON.stringify(value ?? null).includes(STALE_WRITE);
 }
-var STALE_WRITE, WRITE_ATTEMPTS, GENERATION, storage2, generation;
+var STALE_WRITE, WRITE_ATTEMPTS, GENERATION, storage3, generation;
 var init_write_check = __esm({
   "src/core/write-check.ts"() {
     "use strict";
     STALE_WRITE = "the database changed while this write was being checked";
     WRITE_ATTEMPTS = 5;
     GENERATION = /* @__PURE__ */ new WeakMap();
-    storage2 = null;
+    storage3 = null;
     try {
       const { AsyncLocalStorage: AsyncLocalStorage2 } = require("node:async_hooks");
-      storage2 = new AsyncLocalStorage2();
+      storage3 = new AsyncLocalStorage2();
     } catch {
-      storage2 = null;
+      storage3 = null;
     }
     generation = (app) => GENERATION.get(app) ?? 0;
   }
@@ -32591,10 +33076,10 @@ var init_query = __esm({
 });
 
 // src/core/this-tokens.ts
-function hostValue(host2, field2) {
-  const own2 = THIS_NOTE_FIELDS.get(field2);
+function hostValue(host2, field3) {
+  const own2 = THIS_NOTE_FIELDS.get(field3);
   if (own2) return own2(host2);
-  return field2.split(".").reduce((v, k) => v && typeof v === "object" ? v[k] : void 0, host2.frontmatter);
+  return field3.split(".").reduce((v, k) => v && typeof v === "object" ? v[k] : void 0, host2.frontmatter);
 }
 function shiftDate3(value, sign, n, unit) {
   const s = typeof value === "string" ? value : value instanceof Date ? value.toISOString() : null;
@@ -32815,6 +33300,7 @@ async function resolveWithin(app, settings, t, where) {
       const viaLink = via && (via.type === "link" || via.type === "list" && via.items === "link");
       if (!via || !viaLink || !via.ref) throw new OperationInputError(`where "${col}": "${head}" is not a link column with ref`, notALink(head, t));
       const target2 = via.ref === t.catalog.ref.full ? t : await loadTable(app, settings, via.ref);
+      assertTableReadable(target2.catalog.ref.full);
       const sub = await resolveWithin(app, settings, target2, { [tail]: cond });
       const pred = compileWhere(sub, target2, settings, rowGetter(app, target2, settings));
       const hits = (await loadRows(app, settings, target2)).filter(pred).map((r) => `[[${basenameOf(r.file.path)}]]`);
@@ -32830,6 +33316,7 @@ async function resolveWithin(app, settings, t, where) {
     const isLink2 = spec2 && (spec2.type === "link" || spec2.type === "list" && spec2.items === "link");
     if (!spec2 || !isLink2 || !spec2.ref) throw new OperationInputError(`"within" needs a link column with ref: "${col}" is not one`, notALink(col, t));
     const target = spec2.ref === t.catalog.ref.full ? t : await loadTable(app, settings, spec2.ref);
+    assertTableReadable(target.catalog.ref.full);
     const h = target.def.columns.find((c) => c.hierarchy);
     if (!h) throw new OperationInputError(`"within": ${spec2.ref} has no hierarchy column (e.g. parent with hierarchy: true)`, guide(`"within" follows a tree: give ${spec2.ref} a parent link with hierarchy: true (add_column), or filter with "eq" / "in" instead.`, "tree"));
     const raw = cond.within;
@@ -32932,6 +33419,7 @@ var init_where = __esm({
     init_path_templates();
     init_this_tokens();
     init_hints();
+    init_read_scope();
     LOGICAL_HINT = guide(`"and" and "or" take a list of where objects, "not" one: {"or": [{"status": "watched"}, {"rating": {"gte": 4}}]}.`, "logical");
     LOGICAL_KEYS = /* @__PURE__ */ new Set(["or", "and", "not"]);
     OPERATORS = /* @__PURE__ */ new Set(["eq", "ne", "gt", "gte", "lt", "lte", "in", "contains", "icontains", "exists", "within"]);
@@ -33297,12 +33785,16 @@ async function linkTargetRule(t, settings, links, c, loadSource = true) {
     }
     const out2 = [];
     const shown = () => {
+      const scope = currentReadScope();
+      if (scope && [target.catalog.ref.full, ...links.reads(target, c.ref_where)].some((full) => !tableReadable(full, scope))) {
+        return `the link must name a row of ${c.name}'s target table`;
+      }
       const ok2 = targets(d).filter((p) => p !== row.file.path).map(basenameOf);
-      return ok2.length === 0 ? "none" : `${ok2.slice(0, VALID_TARGETS_SHOWN).join(", ")}${ok2.length > VALID_TARGETS_SHOWN ? ` (+${ok2.length - VALID_TARGETS_SHOWN} more)` : ""}`;
+      return `valid: ${ok2.length === 0 ? "none" : `${ok2.slice(0, VALID_TARGETS_SHOWN).join(", ")}${ok2.length > VALID_TARGETS_SHOWN ? ` (+${ok2.length - VALID_TARGETS_SHOWN} more)` : ""}`}`;
     };
     const missing = given.filter((_, i) => paths[i] == null || !rows.has(paths[i])).map((x) => `[[${basenameOf(parseWikilink(x) ?? String(x))}]]`);
     if (missing.length > 0) {
-      out2.push({ column: c.name, code: "broken_link", message: `${missing.join(", ")} ${missing.length > 1 ? "are not rows" : "is not a row"} of ${target.catalog.ref.full}; valid: ${shown()}`, value: v });
+      out2.push({ column: c.name, code: "broken_link", message: `${missing.join(", ")} ${missing.length > 1 ? "are not rows" : "is not a row"} of ${target.catalog.ref.full}; ${shown()}`, value: v });
     }
     if (paths.includes(row.file.path)) {
       out2.push({ column: c.name, code: "ref", message: `${list4 ? `${c.name} cannot hold` : `a ${c.name} cannot be`} the row itself`, value: v });
@@ -33313,7 +33805,7 @@ async function linkTargetRule(t, settings, links, c, loadSource = true) {
     });
     if (bad.length > 0) {
       const what = list4 ? `${bad.length > 1 ? "are not valid targets" : "is not a valid target"} in ${c.name}` : `is not a valid ${c.name}`;
-      out2.push({ column: c.name, code: "ref", message: `${bad.map((p) => `[[${basenameOf(p)}]]`).join(", ")} ${what}${of} (needs ${needs(d)}); valid: ${shown()}`, value: v });
+      out2.push({ column: c.name, code: "ref", message: `${bad.map((p) => `[[${basenameOf(p)}]]`).join(", ")} ${what}${of} (needs ${needs(d)}); ${shown()}`, value: v });
     }
     return out2;
   };
@@ -33408,6 +33900,7 @@ function findRow(rows, ref2, table) {
 }
 async function linkOptionsImpl(app, settings, input) {
   const t = await loadTable(app, settings, input.table);
+  assertTableReadable(t.catalog.ref.full);
   const c = refLinkColumn(t, input.column);
   if (!c) {
     const links2 = t.def.columns.filter((x) => refLinkColumn(t, x.name)).map((x) => x.name);
@@ -33426,6 +33919,9 @@ async function linkOptionsImpl(app, settings, input) {
   const links = new CheckLinks(app, settings);
   const given = input.row !== void 0 && input.row !== null && String(input.row).trim() !== "";
   const rule = await linkTargetRule(t, settings, links, c, given);
+  if (currentReadScope()) {
+    for (const full of [rule.target.catalog.ref.full, ...links.reads(rule.target, c.ref_where)]) assertTableReadable(full);
+  }
   let ordered = [];
   let self;
   if (given) {
@@ -33484,6 +33980,7 @@ var init_link_targets = __esm({
     init_where();
     init_check_links();
     init_hints();
+    init_read_scope();
     VALID_TARGETS_SHOWN = 20;
   }
 });
@@ -33491,9 +33988,51 @@ var init_link_targets = __esm({
 // src/core/changeset-checks.ts
 var changeset_checks_exports = {};
 __export(changeset_checks_exports, {
+  HIDDEN_CHECK_MESSAGE: () => HIDDEN_CHECK_MESSAGE,
   linkedCheckViolations: () => linkedCheckViolations,
-  metastoreLeftBy: () => metastoreLeftBy
+  metastoreLeftBy: () => metastoreLeftBy,
+  pathHidden: () => pathHidden
 });
+function pathHidden(app, settings, path23, scope = currentReadScope()) {
+  if (scope === null || path23 === "" || app.vault.getAbstractFileByPath(path23) === null) return false;
+  return !pathReadable(app, settings, path23, scope);
+}
+function movedOffHiddenRows(app, settings, cs, written2, consequential, out2, scope) {
+  const reported = new Map(written2);
+  for (const m of cs.moves) reported.set(m.from, written2.get(m.to) ?? m.from);
+  for (const p of cs.deletes) reported.set(p, p);
+  const visible = (p) => !pathHidden(app, settings, p, scope);
+  const moved = /* @__PURE__ */ new Map();
+  const add = (path23, v) => {
+    const list4 = moved.get(path23) ?? [];
+    if (!list4.some((x) => x.code === v.code && x.column === v.column && x.message === v.message)) list4.push(v);
+    moved.set(path23, list4);
+  };
+  for (const [path23, violations] of out2) {
+    if (visible(path23)) {
+      for (const v of violations) add(path23, v);
+      continue;
+    }
+    const file = app.vault.getAbstractFileByPath(path23);
+    const fm = app.metadataCache.getFileCache(file)?.frontmatter ?? {};
+    const targets = [];
+    for (const [key2, value] of Object.entries(fm)) {
+      for (const x of Array.isArray(value) ? value : [value]) {
+        const lp = parseWikilink(x);
+        const dest = lp == null ? null : app.metadataCache.getFirstLinkpathDest(lp, path23);
+        const to = dest ? reported.get(dest.path) : void 0;
+        if (to !== void 0 && visible(to)) targets.push([to, key2]);
+      }
+    }
+    const own2 = [...new Set(written2.values())].filter((p) => !consequential.has(p) && visible(p)).sort();
+    for (const v of violations) {
+      for (const [to, column] of targets) add(to, { column, code: v.code, message: HIDDEN_CHECK_MESSAGE });
+      if (targets.length > 0) continue;
+      for (const to of own2.length > 0 ? own2 : [""]) add(to, { code: v.code, message: HIDDEN_CHECK_MESSAGE });
+    }
+  }
+  return moved;
+}
 async function metastoreLeftBy(app, settings, cs) {
   const path23 = metastorePath(settings);
   const text5 = cs.texts.filter((t) => t.path === path23).pop()?.after;
@@ -33593,9 +34132,9 @@ async function linkedCheckViolationsImpl(app, settings, cs, consequential = /* @
       const affected = restored || [...after.reads(s, where)].some((full) => after.changes(full));
       if (!affected && !rows.some((r) => written2.has(r.file.path))) continue;
       const heads = [...linkHeads(where)];
-      let passes;
+      let passes2;
       try {
-        passes = compileCheck(where, s, settings, after);
+        passes2 = compileCheck(where, s, settings, after);
       } catch (e) {
         for (const r of rows) {
           const p = written2.get(r.file.path);
@@ -33607,7 +34146,7 @@ async function linkedCheckViolationsImpl(app, settings, cs, consequential = /* @
       for (const r of rows) {
         const own2 = written2.get(r.file.path);
         if (own2 === void 0 && !affected) continue;
-        if (passes(r)) continue;
+        if (passes2(r)) continue;
         const message = `violates CHECK ${name}: ${JSON.stringify(where)}`;
         if (own2 === void 0 && restored) {
           add(r.file.path, { constraint: name, code: "check", message: `${message} (CHECK ${name} comes back with this change)`, ...ownHint });
@@ -33625,7 +34164,9 @@ async function linkedCheckViolationsImpl(app, settings, cs, consequential = /* @
       }
     }
   }
-  return [...out2].map(([path23, violations]) => ({ path: path23, violations }));
+  const scope = currentReadScope();
+  const answer = scope ? movedOffHiddenRows(app, settings, cs, written2, consequential, out2, scope) : out2;
+  return [...answer].map(([path23, violations]) => ({ path: path23, violations }));
 }
 function linkedCheckViolations(...args) {
   return phase("engine.checks", async (span) => {
@@ -33634,6 +34175,7 @@ function linkedCheckViolations(...args) {
     return v;
   }, { "datanotes.checks.kind": "linked" });
 }
+var HIDDEN_CHECK_MESSAGE;
 var init_changeset_checks = __esm({
   "src/core/changeset-checks.ts"() {
     "use strict";
@@ -33645,6 +34187,9 @@ var init_changeset_checks = __esm({
     init_link_targets();
     init_message();
     init_tracing();
+    init_read_scope();
+    init_validate();
+    HIDDEN_CHECK_MESSAGE = "a linked row of a table this token may not read breaks one of its CHECKs";
   }
 });
 
@@ -33897,10 +34442,13 @@ async function checkOne(app, settings, table, everyUnreadable) {
 async function checkImpl(app, settings, input) {
   const limit = Math.min(Math.max(Math.trunc(input.limit ?? CHECK_LIMIT), 1), CHECK_MAX);
   const offset = Math.max(Math.trunc(input.offset ?? 0), 0);
-  const rowsOf = (list4, table) => list4.map((r) => ({ path: r.path, ...table ? { table } : {}, violations: r.violations.map(checkViolation) }));
+  const scope = currentReadScope();
+  const rowsOf = (list4, table) => list4.filter((r) => scope === null || pathReadable(app, settings, r.path, scope) || r.violations.every((v) => v.code === "unreadable")).map((r) => ({ path: r.path, ...table ? { table } : {}, violations: r.violations.map(checkViolation) }));
   if (input.table) {
+    if (scope) assertTableReadable((await loadTable(app, settings, input.table)).catalog.ref.full);
     const r = await checkOne(app, settings, input.table);
-    return { table: r.table, rows_checked: r.rows, total: r.violations.length, violations: rowsOf(r.violations).slice(offset, offset + limit) };
+    const shown = rowsOf(r.violations);
+    return { table: r.table, rows_checked: r.rows, total: shown.length, violations: shown.slice(offset, offset + limit) };
   }
   const model = (await loadMetastore(app, settings))?.model;
   const all = [];
@@ -33908,7 +34456,7 @@ async function checkImpl(app, settings, input) {
   let rows = 0;
   let tables = 0;
   const everyUnreadable = model ? { model, rows: await unreadableRows(app, settings, model) } : void 0;
-  for (const full of (model ? catalogTables(model).map(({ ref: ref2 }) => ref2.full) : []).sort()) {
+  for (const full of (model ? catalogTables(model).map(({ ref: ref2 }) => ref2.full) : []).filter((full2) => tableReadable(full2, scope)).sort()) {
     let r;
     try {
       r = await checkOne(app, settings, full, everyUnreadable);
@@ -33965,6 +34513,7 @@ var init_row_checks = __esm({
     init_acyclic();
     init_unreadable();
     init_tracing();
+    init_read_scope();
     CHECK_LIMIT = 500;
     CHECK_MAX = 5e3;
   }
@@ -34198,9 +34747,9 @@ async function checkExternalEdits(app, settings, input) {
     const s = await table(ref2.full);
     for (const [name, where] of checks) {
       await after.prepare(s, where);
-      let passes;
+      let passes2;
       try {
-        passes = compileCheck(where, s, settings, after);
+        passes2 = compileCheck(where, s, settings, after);
       } catch {
         continue;
       }
@@ -34218,7 +34767,7 @@ async function checkExternalEdits(app, settings, input) {
         return failure2(passed(r));
       };
       const chains = linkChains(where);
-      for (const r of after.rowsOf(s)) await report(s, chains, r, () => failure2(passes(r)), before ? prior(r) : void 0);
+      for (const r of after.rowsOf(s)) await report(s, chains, r, () => failure2(passes2(r)), before ? prior(r) : void 0);
     }
     for (const c of filteredLinkColumns(s).filter((x) => filtered.has(x.name))) {
       const check2 = await linkTargetCheck(s, settings, after, c);
@@ -36555,10 +37104,10 @@ function pbValue(v) {
   if (typeof v === "boolean") return new Pb().uint(2, v ? 1 : 0);
   return Number.isInteger(v) ? new Pb().uint(3, BigInt(v)) : new Pb().double(4, v);
 }
-function pbAttrs(m, field2, a) {
+function pbAttrs(m, field3, a) {
   for (const [k, v] of Object.entries(a)) {
     if (v === void 0 || v === null) continue;
-    m.message(field2, new Pb().string(1, k).message(2, pbValue(v)));
+    m.message(field3, new Pb().string(1, k).message(2, pbValue(v)));
   }
   return m;
 }
@@ -36650,48 +37199,48 @@ var init_otlp = __esm({
         }
         this.parts.push(Number(x));
       }
-      tag(field2, wire) {
-        this.varint(field2 << 3 | wire);
+      tag(field3, wire) {
+        this.varint(field3 << 3 | wire);
       }
-      uint(field2, v) {
-        this.tag(field2, 0);
+      uint(field3, v) {
+        this.tag(field3, 0);
         this.varint(v);
         return this;
       }
-      fixed32(field2, v) {
-        this.tag(field2, 5);
+      fixed32(field3, v) {
+        this.tag(field3, 5);
         for (let i = 0; i < 4; i++) this.parts.push(v >>> 8 * i & 255);
         return this;
       }
-      fixed64(field2, v) {
-        this.tag(field2, 1);
+      fixed64(field3, v) {
+        this.tag(field3, 1);
         for (let i = 0; i < 8; i++) this.parts.push(Number(v >> BigInt(8 * i) & BigInt(255)));
         return this;
       }
-      double(field2, v) {
-        this.tag(field2, 1);
+      double(field3, v) {
+        this.tag(field3, 1);
         const b = new DataView(new ArrayBuffer(8));
         b.setFloat64(0, v, true);
         for (let i = 0; i < 8; i++) this.parts.push(b.getUint8(i));
         return this;
       }
-      bytes(field2, data) {
-        this.tag(field2, 2);
+      bytes(field3, data) {
+        this.tag(field3, 2);
         this.varint(data.length);
         for (const x of data) this.parts.push(x);
         return this;
       }
       /** An id given in hex (trace and span ids), as bytes. */
-      hex(field2, hex) {
+      hex(field3, hex) {
         const out2 = [];
         for (let i = 0; i < hex.length; i += 2) out2.push(parseInt(hex.slice(i, i + 2), 16));
-        return this.bytes(field2, out2);
+        return this.bytes(field3, out2);
       }
-      string(field2, s) {
-        return this.bytes(field2, new TextEncoder().encode(s));
+      string(field3, s) {
+        return this.bytes(field3, new TextEncoder().encode(s));
       }
-      message(field2, m) {
-        return this.bytes(field2, m.finish());
+      message(field3, m) {
+        return this.bytes(field3, m.finish());
       }
       finish() {
         return Uint8Array.from(this.parts);
@@ -36939,23 +37488,23 @@ var init_redact = __esm({
 
 // src/api/extension-record.ts
 function recordProblems(v, prefix = "") {
-  if (!isObject(v)) return [`"${prefix.replace(/\.$/, "") || "record"}" must be an object`];
+  if (!isObject2(v)) return [`"${prefix.replace(/\.$/, "") || "record"}" must be an object`];
   const out2 = [];
-  const bad = (field2, what) => out2.push(`"${prefix}${field2}" must be ${what}`);
+  const bad = (field3, what) => out2.push(`"${prefix}${field3}" must be ${what}`);
   if (typeof v.name !== "string" || !RECORD_NAME.test(v.name)) bad("name", "2 to 40 lowercase letters, digits or -, starting with a letter");
   for (const k of ["version", "commit", "manifest_sha256", "entry_sha256", "token", "installed_at", "updated_at"]) if (!nonEmpty(v[k])) bad(k, "a non-empty string");
   if (typeof v.description !== "string") bad("description", "a string");
   if (typeof v.api !== "number" || !Number.isInteger(v.api) || v.api < 1) bad("api", "an integer of 1 or more");
-  if (!isObject(v.source)) bad("source", "an object");
+  if (!isObject2(v.source)) bad("source", "an object");
   else if (v.source.kind !== "git" && v.source.kind !== "local") bad("source.kind", '"git" or "local"');
-  if (!isObject(v.tables) || Object.values(v.tables).some((t) => !isObject(t) || typeof t.table !== "string" || typeof t.owned !== "boolean")) bad("tables", "an object of roles");
+  if (!isObject2(v.tables) || Object.values(v.tables).some((t) => !isObject2(t) || typeof t.table !== "string" || typeof t.owned !== "boolean")) bad("tables", "an object of roles");
   if (!isStrings(v.tools)) bad("tools", "a list of strings");
   if (!isStrings(v.write)) bad("write", "a list of strings");
   if (v.migration_id !== null && typeof v.migration_id !== "string") bad("migration_id", "a string or null");
   if (v.previous !== null) out2.push(...recordProblems(v.previous, `${prefix}previous.`));
   return out2;
 }
-var RECORD_NAME, RECORD_COMMIT, DATABASE_ID, MAX_RECORD_CHARS, isObject, isStrings, nonEmpty;
+var RECORD_NAME, RECORD_COMMIT, DATABASE_ID, MAX_RECORD_CHARS, isObject2, isStrings, nonEmpty;
 var init_extension_record = __esm({
   "src/api/extension-record.ts"() {
     "use strict";
@@ -36963,7 +37512,7 @@ var init_extension_record = __esm({
     RECORD_COMMIT = /^(?:[0-9a-f]{40}|local-[0-9a-z.-]+)$/;
     DATABASE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     MAX_RECORD_CHARS = 1e6;
-    isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
     isStrings = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
     nonEmpty = (v) => typeof v === "string" && v !== "";
   }
@@ -37566,7 +38115,7 @@ function satisfiesEngine(range, engineVersion) {
   }
   return true;
 }
-function isObject2(v) {
+function isObject3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function bindRoles(value, tables) {
@@ -37580,7 +38129,7 @@ function bindRoles(value, tables) {
       return exact ? table(exact[1]) : v.replace(new RegExp(ROLE_TEXT.source, "g"), (_m, role) => table(role));
     }
     if (Array.isArray(v)) return v.map(walk);
-    if (isObject2(v)) {
+    if (isObject3(v)) {
       const out2 = {};
       for (const k of Object.keys(v)) out2[k] = walk(v[k]);
       return out2;
@@ -37601,7 +38150,7 @@ function rolesNamed(value) {
       const re = new RegExp(ROLE_TEXT.source, "g");
       for (let m = re.exec(v); m; m = re.exec(v)) add(m[1]);
     } else if (Array.isArray(v)) v.forEach(walk);
-    else if (isObject2(v)) Object.keys(v).forEach((k) => walk(v[k]));
+    else if (isObject3(v)) Object.keys(v).forEach((k) => walk(v[k]));
   };
   walk(value);
   return out2;
@@ -37616,7 +38165,7 @@ function parseManifest(text5, file = MANIFEST_FILE) {
   return validateManifest(raw, file);
 }
 function validateManifest(raw, file = MANIFEST_FILE) {
-  if (!isObject2(raw)) throw new ExtensionManifestError(["the manifest must be a JSON object"], file);
+  if (!isObject3(raw)) throw new ExtensionManifestError(["the manifest must be a JSON object"], file);
   const problems = [];
   const m = JSON.parse(JSON.stringify(raw));
   const add = (path23, text5) => {
@@ -37634,10 +38183,10 @@ function validateManifest(raw, file = MANIFEST_FILE) {
   const needDescription = (o, path23) => {
     if (!nonEmpty2(o.description)) add(`${path23}.description`, "is required");
   };
-  const tablesRaw = isObject2(m.tables) ? m.tables : {};
+  const tablesRaw = isObject3(m.tables) ? m.tables : {};
   const roles = Object.keys(tablesRaw);
-  const basesRaw = isObject2(m.bases) ? m.bases : {};
-  const permWrite = isObject2(m.permissions) && Array.isArray(m.permissions.write) ? m.permissions.write : [];
+  const basesRaw = isObject3(m.bases) ? m.bases : {};
+  const permWrite = isObject3(m.permissions) && Array.isArray(m.permissions.write) ? m.permissions.write : [];
   const roleList = (v, path23, allowed, notText) => {
     if (!Array.isArray(v)) return add(path23, "must be a list of roles");
     v.forEach((r, i) => {
@@ -37645,7 +38194,7 @@ function validateManifest(raw, file = MANIFEST_FILE) {
     });
   };
   const column = (c, path23, refs, inBase) => {
-    if (!isObject2(c)) return add(path23, "must be an object");
+    if (!isObject3(c)) return add(path23, "must be an object");
     keys(c, COLUMN_KEYS, path23);
     if (!ident2(c.name)) add(`${path23}.name`, `must be ${IDENT_TEXT}`);
     else if (c.name === "id") add(path23, `"id" is the engine's own column: leave it out`);
@@ -37665,7 +38214,7 @@ function validateManifest(raw, file = MANIFEST_FILE) {
     const seen = /* @__PURE__ */ new Set();
     v.forEach((c, i) => {
       column(c, `${path23}[${i}]`, refs, inBase);
-      const name = isObject2(c) ? c.name : void 0;
+      const name = isObject3(c) ? c.name : void 0;
       if (typeof name !== "string") return;
       if (seen.has(name)) add(path23, `column "${name}" twice`);
       seen.add(name);
@@ -37690,7 +38239,7 @@ function validateManifest(raw, file = MANIFEST_FILE) {
     const path23 = `tables.${role}`;
     const t = tablesRaw[role];
     if (!IDENT3.test(role)) add(path23, `a role is ${IDENT_TEXT}`);
-    if (!isObject2(t)) return add(path23, "must be an object");
+    if (!isObject3(t)) return add(path23, "must be an object");
     keys(t, TABLE_KEYS, path23);
     if (typeof t.owned !== "boolean") add(`${path23}.owned`, "must be true or false");
     for (const k of ["name", "schema"]) if (t[k] !== void 0 && !ident2(t[k])) add(`${path23}.${k}`, `must be ${IDENT_TEXT}`);
@@ -37710,14 +38259,14 @@ function validateManifest(raw, file = MANIFEST_FILE) {
         const seen = /* @__PURE__ */ new Set();
         t.constraints.forEach((c, i) => {
           const cp = `${path23}.constraints[${i}]`;
-          if (!isObject2(c)) return add(cp, "must be an object");
+          if (!isObject3(c)) return add(cp, "must be an object");
           keys(c, CONSTRAINT_KEYS2, cp);
           if (!ident2(c.name)) add(`${cp}.name`, `must be ${IDENT_TEXT}`);
           else {
             if (seen.has(c.name)) add(`${path23}.constraints`, `constraint "${c.name}" twice`);
             seen.add(c.name);
           }
-          if (!isObject2(c.check)) add(`${cp}.check`, "must be an object");
+          if (!isObject3(c.check)) add(`${cp}.check`, "must be an object");
           if (typeof c.hint !== "string") add(`${cp}.hint`, "must be a string");
         });
       }
@@ -37732,12 +38281,12 @@ function validateManifest(raw, file = MANIFEST_FILE) {
       }
     }
   });
-  if (m.bases !== void 0 && !isObject2(m.bases)) add("bases", "must be an object");
+  if (m.bases !== void 0 && !isObject3(m.bases)) add("bases", "must be an object");
   for (const b of Object.keys(basesRaw)) {
     const path23 = `bases.${b}`;
     const base = basesRaw[b];
     if (!IDENT3.test(b)) add(path23, `a base name is ${IDENT_TEXT}`);
-    if (!isObject2(base)) {
+    if (!isObject3(base)) {
       add(path23, "must be an object");
       continue;
     }
@@ -37745,21 +38294,21 @@ function validateManifest(raw, file = MANIFEST_FILE) {
     needDescription(base, path23);
     columns(base.columns, `${path23}.columns`, [], true);
   }
-  if (m.views !== void 0 && !isObject2(m.views)) add("views", "must be an object");
-  const viewsRaw = isObject2(m.views) ? m.views : {};
+  if (m.views !== void 0 && !isObject3(m.views)) add("views", "must be an object");
+  const viewsRaw = isObject3(m.views) ? m.views : {};
   for (const v of Object.keys(viewsRaw)) {
     const path23 = `views.${v}`;
     const view = viewsRaw[v];
     if (!/^vw_[a-z0-9_]+$/.test(v)) add(path23, `a view name starts with vw_ and is ${IDENT_TEXT}`);
-    if (!isObject2(view)) {
+    if (!isObject3(view)) {
       add(path23, "must be an object");
       continue;
     }
     keys(view, VIEW_KEYS, path23);
     needDescription(view, path23);
-    if (!isObject2(view.query)) add(`${path23}.query`, "must be an object");
+    if (!isObject3(view.query)) add(`${path23}.query`, "must be an object");
   }
-  if (!isObject2(m.permissions)) add("permissions", `must be an object with a "write" list of roles`);
+  if (!isObject3(m.permissions)) add("permissions", `must be an object with a "write" list of roles`);
   else {
     keys(m.permissions, ["write"], "permissions");
     roleList(m.permissions.write, "permissions.write", roles, (r) => `"${r}" is not a role`);
@@ -37769,7 +38318,7 @@ function validateManifest(raw, file = MANIFEST_FILE) {
     const seen = /* @__PURE__ */ new Set();
     m.tools.forEach((t, i) => {
       const path23 = `tools[${i}]`;
-      if (!isObject2(t)) return add(path23, "must be an object");
+      if (!isObject3(t)) return add(path23, "must be an object");
       keys(t, TOOL_KEYS, path23);
       if (typeof t.name !== "string" || !TOOL_NAME.test(t.name)) add(`${path23}.name`, "must be snake_case, 1 to 64 characters");
       else {
@@ -37777,10 +38326,10 @@ function validateManifest(raw, file = MANIFEST_FILE) {
         seen.add(t.name);
       }
       if (!nonEmpty2(t.description)) add(`${path23}.description`, "is required");
-      if (!isObject2(t.inputSchema) || t.inputSchema.type !== "object" || t.inputSchema.additionalProperties !== false) {
+      if (!isObject3(t.inputSchema) || t.inputSchema.type !== "object" || t.inputSchema.additionalProperties !== false) {
         add(`${path23}.inputSchema`, `must be an object schema with "type": "object" and "additionalProperties": false`);
       }
-      const readOnly = isObject2(t.annotations) ? t.annotations.readOnlyHint : void 0;
+      const readOnly = isObject3(t.annotations) ? t.annotations.readOnlyHint : void 0;
       if (readOnly !== void 0 && typeof readOnly !== "boolean") add(`${path23}.annotations.readOnlyHint`, "must be true or false");
       if (t.tables !== void 0) roleList(t.tables, `${path23}.tables`, roles, (r) => `"${r}" is not a role`);
       if (t.writes !== void 0) roleList(t.writes, `${path23}.writes`, permWrite, (r) => `"${r}" is not in permissions.write`);
@@ -37793,7 +38342,7 @@ function validateManifest(raw, file = MANIFEST_FILE) {
   let previous = null;
   (Array.isArray(m.migrations) ? m.migrations : []).forEach((g, i) => {
     const path23 = `migrations[${i}]`;
-    if (!isObject2(g)) return add(path23, "must be an object");
+    if (!isObject3(g)) return add(path23, "must be an object");
     keys(g, MIGRATION_KEYS, path23);
     const at = g.version;
     if (typeof at !== "string" || !parseVersion(at)) add(`${path23}.version`, `"${String(at)}" is not a version`);
@@ -37806,7 +38355,7 @@ function validateManifest(raw, file = MANIFEST_FILE) {
     if (!Array.isArray(g.operations)) add(`${path23}.operations`, "must be a list");
     else {
       g.operations.forEach((o, j) => {
-        const op2 = isObject2(o) ? o.op : void 0;
+        const op2 = isObject3(o) ? o.op : void 0;
         if (typeof op2 !== "string" || !BATCH_OPERATIONS2.includes(op2)) add(`${path23}.operations[${j}].op`, `"${String(op2)}" is not an operation a batch takes`);
       });
     }
@@ -37822,7 +38371,7 @@ function validateManifest(raw, file = MANIFEST_FILE) {
       const re = new RegExp(ROLE_TEXT.source, "g");
       for (let r = re.exec(v); r; r = re.exec(v)) if (!known.has(r[1])) add(path23, `"@{${r[1]}}" names no role`);
     } else if (Array.isArray(v)) v.forEach((x, i) => names2(x, `${path23}[${i}]`));
-    else if (isObject2(v)) for (const k of Object.keys(v)) names2(v[k], `${path23}.${k}`);
+    else if (isObject3(v)) for (const k of Object.keys(v)) names2(v[k], `${path23}.${k}`);
   };
   for (const part of ["tables", "bases", "views", "migrations"]) if (m[part] !== void 0) names2(m[part], part);
   if (problems.length > 0) throw new ExtensionManifestError(problems, file);
@@ -38079,7 +38628,7 @@ async function loadExtensions(o) {
     let manifest;
     try {
       manifest = parseManifest(import_node_fs17.default.readFileSync(manifestFile, "utf8"));
-      const odd = manifest.tools.findIndex((t) => !isObject3(t.annotations));
+      const odd = manifest.tools.findIndex((t) => !isObject4(t.annotations));
       if (odd >= 0) throw new Error(`tools[${odd}].annotations: must be an object`);
     } catch (e) {
       skip("entry", `the code of ${r.name} did not load: ${e.message}`);
@@ -38240,7 +38789,7 @@ Docs: read_docs(${JSON.stringify(`extensions/${name}`)})`);
   }
   return { name, version: r.version, servedBy, tools, instructions, has: (tool) => defs.has(tool), call };
 }
-var import_node_fs17, import_node_path19, import_node_url2, noLog, ClientTokens, isObject3, matches2, cut;
+var import_node_fs17, import_node_path19, import_node_url2, noLog, ClientTokens, isObject4, matches2, cut;
 var init_extension_host = __esm({
   "src/api/extension-host.ts"() {
     "use strict";
@@ -38285,7 +38834,7 @@ var init_extension_host = __esm({
         return value;
       }
     };
-    isObject3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    isObject4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
     matches2 = (v, rule) => typeof v === "string" && rule.test(v);
     cut = (s, n) => s.length > n ? s.slice(0, n) : s;
   }
@@ -38295,7 +38844,7 @@ var init_extension_host = __esm({
 function stable(v) {
   const walk = (x) => {
     if (Array.isArray(x)) return x.map(walk);
-    if (isObject4(x)) {
+    if (isObject5(x)) {
       const out2 = {};
       for (const k of Object.keys(x).sort()) out2[k] = walk(x[k]);
       return out2;
@@ -38915,7 +39464,7 @@ function renderPlan(plan) {
   lines.push("", plan.agent_message, plan.summary);
   return lines.join("\n");
 }
-var AGENT_MESSAGE, MAX_OPERATIONS, isObject4, obj3, list2, tableName, isLink;
+var AGENT_MESSAGE, MAX_OPERATIONS, isObject5, obj3, list2, tableName, isLink;
 var init_extension_plan = __esm({
   "src/api/extension-plan.ts"() {
     "use strict";
@@ -38923,8 +39472,8 @@ var init_extension_plan = __esm({
     init_guidance();
     AGENT_MESSAGE = `For the agent installing this extension: show this plan to the user before anything is written. Where a table says "proposed", the installer chose it: ask the user to confirm it, to pick another table (--map <role>=<catalog.schema.table>, --map <role>.<column>=<column>), or to create it (--create <role>). Add a missing column only after the user agrees (--add <role>.<column>). Solve each problem the same way. Then run the same command again with the user's choices and --yes, only once the user approved the tables it creates or changes, the tools and the token's permissions.`;
     MAX_OPERATIONS = 200;
-    isObject4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-    obj3 = (v) => isObject4(v) ? v : {};
+    isObject5 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    obj3 = (v) => isObject5(v) ? v : {};
     list2 = (v) => Array.isArray(v) ? v : [];
     tableName = (t, role) => t.name ?? role;
     isLink = (c) => c.type === "link" || c.type === "list" && c.items === "link";
@@ -40051,7 +40600,7 @@ __export(util_exports, {
   hexToUint8Array: () => hexToUint8Array,
   hide: () => hide,
   installLazyProp: () => installLazyProp,
-  isObject: () => isObject5,
+  isObject: () => isObject6,
   isPlainObject: () => isPlainObject2,
   issue: () => issue,
   joinValues: () => joinValues,
@@ -40258,11 +40807,11 @@ function esc(str3) {
 function slugify(input) {
   return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function isObject5(data) {
+function isObject6(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 function isPlainObject2(o) {
-  if (isObject5(o) === false)
+  if (isObject6(o) === false)
     return false;
   const ctor = o.constructor;
   if (ctor === void 0)
@@ -40270,7 +40819,7 @@ function isPlainObject2(o) {
   if (typeof ctor !== "function")
     return true;
   const prot = ctor.prototype;
-  if (isObject5(prot) === false)
+  if (isObject6(prot) === false)
     return false;
   if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
     return false;
@@ -42656,20 +43205,20 @@ var init_schemas = __esm({
         const shape = zod.def.shape;
         const propValues = {};
         for (const key2 in shape) {
-          const field2 = shape[key2]._zod;
-          if (field2.values) {
+          const field3 = shape[key2]._zod;
+          if (field3.values) {
             if (!Object.prototype.hasOwnProperty.call(propValues, key2)) {
               assignProp(propValues, key2, /* @__PURE__ */ new Set());
             }
-            for (const v of field2.values)
+            for (const v of field3.values)
               propValues[key2].add(v);
-            if (field2.optin !== void 0)
+            if (field3.optin !== void 0)
               propValues[key2].add(void 0);
           }
         }
         return propValues;
       });
-      const isObject6 = isObject5;
+      const isObject7 = isObject6;
       const catchall = def.catchall;
       let value;
       const memo2 = globalConfig.memoizer;
@@ -42677,7 +43226,7 @@ var init_schemas = __esm({
       inst._zod.parse = (payload, ctx) => {
         value ?? (value = _normalized.value);
         const input = payload.value;
-        if (!isObject6(input)) {
+        if (!isObject7(input)) {
           payload.issues.push({
             expected: "object",
             code: "invalid_type",
@@ -42813,7 +43362,7 @@ var init_schemas = __esm({
         return doc.compile();
       };
       let fastpass;
-      const isObject6 = isObject5;
+      const isObject7 = isObject6;
       const jit = !globalConfig.jitless;
       const allowsEval2 = allowsEval;
       const fastEnabled = jit && allowsEval2.value;
@@ -42822,7 +43371,7 @@ var init_schemas = __esm({
       inst._zod.parse = (payload, ctx) => {
         value ?? (value = _normalized.value);
         const input = payload.value;
-        if (!isObject6(input)) {
+        if (!isObject7(input)) {
           payload.issues.push({
             expected: "object",
             code: "invalid_type",
@@ -42922,7 +43471,7 @@ var init_schemas = __esm({
       const disc = cached(() => discriminatorMap(def));
       inst._zod.parse = (payload, ctx) => {
         const input = payload.value;
-        if (!isObject5(input)) {
+        if (!isObject6(input)) {
           payload.issues.push({
             code: "invalid_type",
             expected: "object",
@@ -45285,8 +45834,8 @@ var init_json_schema_processors = __esm({
       }
       const requiredKeys = [];
       for (const key2 of Object.keys(shape)) {
-        const field2 = def.shape[key2];
-        if (ctx.io === "input" ? inputOptin(field2) === void 0 : field2._zod.optout === void 0) {
+        const field3 = def.shape[key2];
+        if (ctx.io === "input" ? inputOptin(field3) === void 0 : field3._zod.optout === void 0) {
           requiredKeys.push(key2);
         }
       }
@@ -61187,6 +61736,7 @@ init_metastore();
 init_table_registry();
 init_hints();
 init_tracing();
+init_read_scope();
 var HISTORY_OFF = (full) => guide(`Turn history on for it with alter_table("${full}", history: true), or for every table with configure_database(history: true); versions are kept from then on.`, "history");
 var ASOF_HINT = guide(`Pass "version" (an integer from describe_history) or "timestamp" (an ISO date-time), not both.`, "readAsOf");
 async function historyTableName(app, settings, table) {
@@ -61268,6 +61818,7 @@ async function newestHistory(app, settings, full, limit) {
 }
 async function describeHistory(app, settings, input) {
   const ref2 = await historyTableName(app, settings, input.table);
+  assertTableReadable(ref2.full);
   const limit = input.limit ?? 50;
   if (input.since === void 0) return { table: ref2.full, history: await newestHistory(app, settings, ref2.full, limit) };
   const from = sinceMs(input.since);
@@ -61383,6 +61934,7 @@ function rowValues(content, settings) {
 }
 async function tableChanges(app, settings, input) {
   const ref2 = await historyTableName(app, settings, input.table);
+  assertTableReadable(ref2.full);
   const versions = await listVersions(app, settings, ref2.full);
   if (versions.length === 0) throw new OperationInputError(`${ref2.full} has no history`, HISTORY_OFF(ref2.full));
   const latest = versions[versions.length - 1];
@@ -61449,6 +62001,8 @@ init_check_links();
 init_changeset_checks();
 init_computed_columns();
 init_path_templates();
+init_read_scope();
+init_query_tables();
 init_where();
 init_link_paths();
 init_validate();
@@ -61507,10 +62061,10 @@ async function addConstraintImpl(app, settings, input, opts = {}) {
   if (cat.entry.constraints?.[input.name]) throw new OperationInputError(`constraint "${input.name}" already exists; drop it first`, guide(`Choose another name, or drop_constraint "${input.name}" first to replace it; describe_table lists the constraints.`, "check"));
   const links = new CheckLinks(app, settings);
   await links.prepare(t, input.check);
-  const passes = compileCheck(input.check, t, settings, links);
+  const passes2 = compileCheck(input.check, t, settings, links);
   const conflicts = [];
   for (const r of await loadRows(app, settings, t)) {
-    if (!passes(r)) conflicts.push({ path: r.file.path, message: `violates CHECK ${input.name}` });
+    if (!passes2(r)) conflicts.push({ path: r.file.path, message: `violates CHECK ${input.name}` });
   }
   const hints = { ...constraintHints(cat.entry), ...hint ? { [input.name]: hint } : {} };
   const { constraint_hints: _h, ...withoutHints } = cat.entry;
@@ -61620,6 +62174,7 @@ async function resolveViewSelect(app, settings, input) {
   if (tableRef) return null;
   const ref2 = resolveCatalogRef(ms.model, input.table, "view");
   if (!ref2) return null;
+  assertTableReadable(ref2.full);
   const view = ms.model.catalogs[ref2.catalog].schemas[ref2.schema].views[ref2.table];
   const base = viewQueryToSelect(input.host ? resolveThisTokens(view.query, input.host) : view.query);
   let where = { ...base.where ?? {} };
@@ -61719,13 +62274,17 @@ async function informationRows(app, settings, name) {
   const ms = await loadMetastore(app, settings);
   const model = ms?.model ?? parseMetastore("");
   const cfg = await readDatabaseConfig(app, settings);
-  const tables = catalogTables(model);
+  const scope = currentReadScope();
+  const tables = catalogTables(model).filter(({ ref: ref2 }) => tableReadable(ref2.full, scope));
+  const views = catalogViews(model).filter(({ ref: ref2 }) => viewReadable2(model, ref2.full, scope));
+  const visible = new Set([...tables, ...views].map(({ ref: ref2 }) => `${ref2.catalog}.${ref2.schema}`));
+  const shown = (catalog, schema) => scope === null || (schema !== void 0 ? visible.has(`${catalog}.${schema}`) : [...visible].some((k) => k.startsWith(`${catalog}.`)));
   switch (name) {
     case "catalogs":
-      return Object.entries(model.catalogs).map(([c, cat]) => ({ catalog_name: c, comment: cat.description ?? null, is_default: c === cfg.default_catalog }));
+      return Object.entries(model.catalogs).filter(([c]) => shown(c)).map(([c, cat]) => ({ catalog_name: c, comment: cat.description ?? null, is_default: c === cfg.default_catalog }));
     case "schemata":
       return Object.entries(model.catalogs).flatMap(
-        ([c, cat]) => Object.entries(cat.schemas).map(([s, sch]) => ({ catalog_name: c, schema_name: s, comment: sch.description ?? null }))
+        ([c, cat]) => Object.entries(cat.schemas).filter(([s]) => shown(c, s)).map(([s, sch]) => ({ catalog_name: c, schema_name: s, comment: sch.description ?? null }))
       );
     case "tables": {
       const out2 = [];
@@ -61746,7 +62305,7 @@ async function informationRows(app, settings, name) {
           instructions: tableInstructions(entry) ?? null
         });
       }
-      for (const { ref: ref2, view } of catalogViews(model)) {
+      for (const { ref: ref2, view } of views) {
         out2.push({
           table_catalog: ref2.catalog,
           table_schema: ref2.schema,
@@ -61784,7 +62343,7 @@ async function informationRows(app, settings, name) {
         }));
       });
     case "views":
-      return catalogViews(model).map(({ ref: ref2, view }) => ({
+      return views.map(({ ref: ref2, view }) => ({
         table_catalog: ref2.catalog,
         table_schema: ref2.schema,
         table_name: ref2.table,
@@ -61807,6 +62366,12 @@ async function informationRows(app, settings, name) {
       });
   }
 }
+function viewReadable2(model, full, scope) {
+  if (scope === null) return true;
+  if (!tableReadable(full, scope)) return false;
+  const r = tablesReadByView(model, full);
+  return r.complete && r.tables.every((t) => tableReadable(t, scope));
+}
 async function informationSchemaTableData(app, settings, name) {
   const ref2 = refOf(SYSTEM_CATALOG, "information_schema", name);
   const entry = { columns: INFO_COLUMNS[name].map(([n, type]) => ({ name: n, type })) };
@@ -62069,6 +62634,8 @@ var setTableBases = instrumented("set_table_bases", setTableBasesImpl, (i) => ({
 // src/core/select.ts
 init_this_tokens();
 init_metastore();
+init_query_tables();
+init_read_scope();
 init_engine();
 init_file_cache();
 init_frontmatter();
@@ -62167,9 +62734,11 @@ async function loadJoin(app, settings, t, left, join, env, asOf2) {
   if (pairs.length !== 1) throw new OperationInputError(`join.on must contain exactly one "left": "right" pair`, JOIN_HINT);
   const [leftText, rightText] = pairs[0];
   if (typeof rightText !== "string") throw new OperationInputError(`join.on values must be strings`, JOIN_HINT);
+  if (asOf2.timestamp !== void 0) await assertRefReadable(app, settings, join.table);
   const hist = asOf2.timestamp !== void 0 ? await loadTableAsOf(app, settings, join.table, { timestamp: asOf2.timestamp }) : null;
   if (hist) asOf2.read.set(hist.table.catalog.ref.full, hist.version);
   const rt = hist?.table ?? await loadTable(app, settings, join.table);
+  assertTableReadable(rt.catalog.ref.full);
   const rKnown = readableKeys(rt, settings);
   const lGet = rowGetter(app, t, settings, env.tz);
   const rGet = rowGetter(app, rt, settings, env.tz);
@@ -62197,6 +62766,12 @@ async function loadJoin(app, settings, t, left, join, env, asOf2) {
   };
 }
 var MAX_VIEW_DEPTH = 8;
+async function assertRefReadable(app, settings, ref2) {
+  if (!currentReadScope()) return;
+  const model = (await loadMetastore(app, settings))?.model;
+  const full = model ? refOf2(model, ref2, "table") : null;
+  if (full) assertTableReadable(full);
+}
 var UNION_BRANCH_MAX = 1e3;
 function perTableVersion(what) {
   return new OperationInputError(
@@ -62214,7 +62789,7 @@ async function selectBase(app, settings, input, depth, read3) {
   const tables = catalogTables(model).filter(({ entry }) => {
     const ext = entry.bases ?? [];
     return ext.length > 0 && baseChain(model.bases, ext).includes(name);
-  }).map(({ ref: ref2 }) => ref2.full);
+  }).map(({ ref: ref2 }) => ref2.full).filter((full) => tableReadable(full));
   const own2 = /* @__PURE__ */ new Set([SYSTEM_ID_COLUMN, ...baseChain(model.bases, [name]).flatMap((b) => model.bases[b].columns.map((c) => String(c.name)))]);
   const columns = input.columns ?? [...own2];
   for (const c of [...columns, ...Object.keys(input.where ?? {}).filter((k) => !["and", "or", "not"].includes(k))]) {
@@ -62299,10 +62874,12 @@ async function selectImpl(app, settings, input, depth = 0, read3 = /* @__PURE__
   }
   if (input.version === void 0 && input.timestamp === void 0) return selectOn(app, settings, input, null, read3);
   if (input.join && input.version !== void 0) throw perTableVersion("a join reads two tables");
+  await assertRefReadable(app, settings, input.table);
   const hist = await loadTableAsOf(app, settings, input.table, {
     ...input.version !== void 0 ? { version: input.version } : {},
     ...input.timestamp !== void 0 ? { timestamp: input.timestamp } : {}
   });
+  assertTableReadable(hist.table.catalog.ref.full);
   read3.set(hist.table.catalog.ref.full, hist.version);
   const r = await selectOn(app, settings, input, hist, read3);
   return { ...r, version: hist.version, timestamp: hist.timestamp, ...input.join ? { versions: sortedVersions(read3) } : {} };
@@ -62321,6 +62898,7 @@ async function selectOn(app, settings, input, hist, read3) {
   const t = hist?.table ?? await loadTable(app, settings, input.table).catch(async (e) => {
     throw e instanceof TableNotFoundError ? tableNotFound(input.table, (await loadMetastore(app, settings))?.model, "any") : e;
   });
+  if (!hist) assertTableReadable(t.catalog.ref.full);
   const known = readableKeys(t, settings);
   const tz = (await readDatabaseConfig(app, settings)).timezone;
   const now = /* @__PURE__ */ new Date();
@@ -62352,7 +62930,7 @@ async function selectOn(app, settings, input, hist, read3) {
     const linkpath = parseWikilink(v);
     if (linkpath == null) return v;
     const dest = app.metadataCache.getFirstLinkpathDest(linkpath, sourcePath);
-    if (!dest || isArchivedPath(app, settings, dest.path)) return v;
+    if (!dest || isArchivedPath(app, settings, dest.path) || !pathReadable(app, settings, dest.path)) return v;
     const fm = app.metadataCache.getFileCache(dest)?.frontmatter ?? {};
     return { path: dest.path, ...fm };
   };
@@ -62454,15 +63032,16 @@ function select(app, settings, input) {
   return traced(
     "datanotes select",
     { "datanotes.op": "select", table: input.table },
-    async () => selectImpl(app, settings, input.thisNote === void 0 ? input : { ...input, host: await noteHost(app, input.thisNote) }),
+    async () => selectImpl(app, settings, input.thisNote === void 0 ? input : { ...input, host: await noteHost(app, settings, input.thisNote) }),
     (r) => ({ attributes: { total: r.total, returned: r.rows.length } })
   );
 }
 var THIS_NOTE_HINT = guide(`Give "this_note" the vault path of an existing note, with ".md" (list_folder or search_notes find it).`, "thisNote");
-async function noteHost(app, path23) {
+async function noteHost(app, settings, path23) {
   const why = unsafeVaultPath(path23);
   if (why) throw new OperationInputError(`this_note: ${why}`, THIS_NOTE_HINT);
   const file = app.vault.getAbstractFileByPath(path23);
+  assertPathReadable(app, settings, file?.path ?? path23);
   if (file == null || !("extension" in file)) throw new OperationInputError(`this_note: no note at "${path23}" (give its vault path, e.g. "Journal/2026-10-06.md")`, THIS_NOTE_HINT);
   const { ordered } = readOrderedFromMarkdown(await app.vault.read(file));
   return { path: file.path, frontmatter: Object.fromEntries(ordered) };
@@ -62551,6 +63130,7 @@ init_file_cache();
 init_inverse();
 init_metastore();
 init_tracing();
+init_read_scope();
 init_vault_index();
 var MIN_NAME_LENGTH = 3;
 var MAX_NAME_WORDS = 12;
@@ -62921,7 +63501,7 @@ function standsAlone(text5, start, end) {
   if (after === "." || after === ":") return !/[\p{L}\p{N}_/\\]/u.test(text5[end + 1] ?? "");
   return true;
 }
-function matchesIn(text5, tokens, ix, self) {
+function matchesIn(text5, tokens, ix, self, visible) {
   const out2 = [];
   for (let i = 0; i < tokens.length; i++) {
     let key2 = tokens[i].norm;
@@ -62935,9 +63515,10 @@ function matchesIn(text5, tokens, ix, self) {
         let any = false;
         let isSelf = false;
         for (const p of paths.keys()) {
-          any = true;
           if (self.has(p)) isSelf = true;
-          else cands.push(p);
+          else if (visible(p)) cands.push(p);
+          else continue;
+          any = true;
         }
         if (any) out2.push({ ti: i, tj: j, start: tokens[i].start, end: tokens[j].end, key: key2, cands: isSelf ? [] : cands.sort(), self: isSelf });
       }
@@ -62950,7 +63531,7 @@ function matchesIn(text5, tokens, ix, self) {
   }
   return out2.sort((a, b) => a.start - b.start || b.end - a.end);
 }
-function mentionsIn(text5, frag, ix, self) {
+function mentionsIn(text5, frag, ix, self, visible) {
   const out2 = [];
   for (const [a, b] of freeSegments(text5)) {
     const tokens = [...text5.slice(a, b).matchAll(WORD_RE)].map((m) => ({
@@ -62958,7 +63539,7 @@ function mentionsIn(text5, frag, ix, self) {
       end: a + m.index + m[0].length,
       norm: m[0].normalize("NFC").toLowerCase()
     }));
-    const matches3 = matchesIn(text5, tokens, ix, self);
+    const matches3 = matchesIn(text5, tokens, ix, self, visible);
     if (matches3.length === 0) continue;
     const inMatch = /* @__PURE__ */ new Set();
     for (const m of matches3) for (let t = m.ti; t <= m.tj; t++) inMatch.add(t);
@@ -63064,7 +63645,15 @@ async function autolinkFragmentsImpl(app, settings, input) {
   if (input.fragments.every((f) => f.trim() === "")) return { fragments: [...input.fragments], report };
   const ix = await nameIndex(app, settings);
   const self = /* @__PURE__ */ new Set([input.path, ...input.self ?? []]);
-  const mentions = input.fragments.flatMap((text5, i) => mentionsIn(text5, i, ix, self));
+  const scope = currentReadScope();
+  const seenVisible = /* @__PURE__ */ new Map();
+  const visible = (p) => {
+    if (!scope) return true;
+    let v = seenVisible.get(p);
+    if (v === void 0) seenVisible.set(p, v = pathReadable(app, settings, p, scope));
+    return v;
+  };
+  const mentions = input.fragments.flatMap((text5, i) => mentionsIn(text5, i, ix, self, visible));
   const doubtful = new Set(mentions.filter((m) => m.kind !== "clear" && m.kind !== "self" && m.kind !== "sentence_start").flatMap((m) => m.keys));
   const linked = linkedTargets(app, input.body, input.path);
   const edits = [];
@@ -63708,6 +64297,13 @@ function clearLinksTo(app, sourcePath, ordered, targets) {
     return pointsAt(v) ? [k, null] : [k, v];
   });
 }
+function referencedBy(app, settings, sources) {
+  const shown = sources.filter((p) => !pathHidden(app, settings, p));
+  const hidden2 = sources.length - shown.length;
+  if (hidden2 === 0) return `referenced by ${sources.join(", ")}`;
+  const rest = `${hidden2} ${hidden2 === 1 ? "row" : "rows"} this token may not read`;
+  return `referenced by ${shown.length > 0 ? `${shown.join(", ")} and ${rest}` : rest}`;
+}
 async function deleteRowsImpl(app, settings, input, opts = {}) {
   const t = await loadTable(app, settings, input.table);
   const pred = compileWhere(await resolveWithin(app, settings, t, input.where), t, settings);
@@ -63722,7 +64318,7 @@ async function deleteRowsImpl(app, settings, input, opts = {}) {
   for (const r of rows) {
     const sources = inbound.get(r.file.path) ?? [];
     if (sources.length > 0 && policy === "restrict") {
-      conflicts.push({ path: r.file.path, message: `referenced by ${sources.join(", ")}` });
+      conflicts.push({ path: r.file.path, message: referencedBy(app, settings, sources) });
     }
     sources.forEach((s) => referrers.add(s));
   }
@@ -63795,6 +64391,7 @@ init_where();
 init_row_checks();
 init_changeset_checks();
 init_message();
+init_read_scope();
 init_link_paths();
 function checkRetarget(dst, settings, r) {
   const dstKnown = knownKeys(dst, settings);
@@ -63970,7 +64567,7 @@ async function adoptRowsImpl(app, settings, input, opts = {}) {
       /* @__PURE__ */ new Set([settings.tableKey])
     );
     const owner = model ? rowTableFull(model, fmGet(ordered, settings.tableKey)) : null;
-    if (owner) conflicts.push({ path: p, message: `already a row of ${owner}: use move_rows` });
+    if (owner) conflicts.push({ path: p, message: `already a row of ${tableReadable(owner) ? owner : "another table"}: use move_rows` });
     notes.push({ path: p, ordered });
   }
   const cs = emptyChangeSet("adopt_rows", `adopt ${notes.length} notes into ${dst.def.name}`, dst.def.schemaPath);
@@ -64593,13 +65190,36 @@ init_engine();
 init_hints();
 init_journal();
 init_metastore();
+init_read_scope();
 async function describeDatabaseHistory(app, settings, input = {}) {
   const from = input.since === void 0 ? void 0 : sinceMs(input.since);
   const tables = await loggedTables(app, settings);
   const limit = Math.max(input.limit ?? 50, 0);
+  const batchOf = await batchMembership(app, settings);
+  const scope = currentReadScope();
+  if (!scope) return databaseCommits(tables, await newestOf(app, settings, tables, limit, from), batchOf, limit);
+  const readable = tables.filter((t) => tableReadable(t, scope));
+  if (!(limit > 0)) return { tables: readable, history: [] };
+  for (let depth = limit; ; depth *= 2) {
+    const mine = await newestOf(app, settings, readable, depth, from);
+    const oldest = mine.reduce((m, c) => Math.min(m, Date.parse(c.timestamp)), Infinity);
+    const others = oldest === Infinity ? [] : await newestOf(app, settings, tables.filter((t) => !readable.includes(t)), Infinity, Math.max(from ?? -Infinity, oldest - 6e4));
+    const all = databaseCommits(tables, [...mine, ...others], batchOf, Infinity);
+    const shown = all.history.filter((c) => tableReadable(c.table, scope) && (c.tables ?? []).every((t) => tableReadable(t, scope)));
+    const last = shown.length >= limit ? shown[limit - 1].timestamp : null;
+    const complete = readable.every((t) => {
+      const read3 = mine.filter((c) => c.table === t);
+      return read3.length < depth || last !== null && read3[read3.length - 1].timestamp < last;
+    });
+    if (complete) return { tables: readable, history: shown.slice(0, limit) };
+  }
+}
+async function newestOf(app, settings, tables, limit, from) {
   const all = [];
   for (const table of tables) for (const c of await newestCommitInfos(app, settings, table, limit, from)) all.push({ table, ...c });
-  const batchOf = await batchMembership(app, settings);
+  return all;
+}
+function databaseCommits(tables, all, batchOf, limit) {
   const groupOf = (c) => c.migrationId === void 0 ? void 0 : batchOf.get(c.migrationId) ?? c.migrationId;
   const groups = /* @__PURE__ */ new Map();
   for (const c of all) {
@@ -64757,6 +65377,8 @@ init_metastore();
 init_descriptions();
 init_row_files();
 init_table_registry();
+init_read_scope();
+init_query_tables();
 
 // src/core/graph.ts
 init_engine();
@@ -64812,6 +65434,7 @@ init_table_registry();
 init_validate();
 init_hints();
 init_tracing();
+init_read_scope();
 var LINK_LABEL = "link";
 var MAX_GRAPH_DEPTH = 10;
 var MAX_GRAPH_NODES = 5e3;
@@ -64833,7 +65456,10 @@ function addEdge(g, keys, from, to, label) {
   back.push({ to: from, label });
   g.in.set(to, back);
 }
-async function graphIndex(app, settings) {
+function graphIndex(app, settings) {
+  return runWithReadScope(null, () => sharedGraph(app, settings));
+}
+async function sharedGraph(app, settings) {
   const generation2 = vaultGeneration(app);
   let metastore = cachedMetastore(app, settings);
   const attempt = `${generation2}\0${metastorePath(settings)}`;
@@ -65110,7 +65736,7 @@ function tablesOf(app, settings, names2, what) {
   for (const n of names2) {
     if (TABLE_PATTERN.test(n)) {
       const prefix = n.slice(0, -1);
-      for (const t of all) if (t.qualified.startsWith(prefix)) out2.add(t.qualified);
+      for (const t of all) if (t.qualified.startsWith(prefix) && tableReadable(t.qualified)) out2.add(t.qualified);
       continue;
     }
     if (n.includes("*")) throw new OperationInputError(`${what}: "${n}" is not a table pattern`, NODE_SET_HINT);
@@ -65124,10 +65750,12 @@ async function resolveNodes(app, settings, set, what) {
   for (const p of set.paths ?? []) {
     const path23 = p.endsWith(".md") ? p : `${p}.md`;
     if (app.vault.getAbstractFileByPath(path23) == null) throw new OperationInputError(`${what}: note not found: ${path23}`);
+    assertPathReadable(app, settings, path23);
     out2.add(path23);
   }
   if (set.table !== void 0) {
     const t = await loadTable(app, settings, set.table);
+    assertTableReadable(t.catalog.ref.full);
     const pred = compileWhere(await resolveWithin(app, settings, t, set.where), t, settings);
     for (const r of await loadRows(app, settings, t)) if (pred(r)) out2.add(r.file.path);
   } else if (set.where !== void 0) {
@@ -65141,13 +65769,24 @@ async function resolveNodes(app, settings, set, what) {
   if (!set.paths && set.table === void 0 && set.tables === void 0) throw new OperationInputError(`"${what}" needs "paths", "table" or "tables"`, NODE_SET_HINT);
   return [...out2].sort();
 }
-function stepsFrom(g, node2, direction, labels) {
+function visibleNodes(app, settings) {
+  const scope = currentReadScope();
+  if (!scope) return null;
+  const known = /* @__PURE__ */ new Map();
+  return (path23) => {
+    let ok2 = known.get(path23);
+    if (ok2 === void 0) known.set(path23, ok2 = pathReadable(app, settings, path23, scope));
+    return ok2;
+  };
+}
+function stepsFrom(g, node2, direction, labels, visible) {
   const steps = [];
+  const follow = (e) => (!labels || labels.has(e.label)) && (!visible || visible(e.to));
   if (direction !== "in") {
-    for (const e of g.out.get(node2) ?? []) if (!labels || labels.has(e.label)) steps.push({ ...e, dir: "out" });
+    for (const e of g.out.get(node2) ?? []) if (follow(e)) steps.push({ ...e, dir: "out" });
   }
   if (direction !== "out") {
-    for (const e of g.in.get(node2) ?? []) if (!labels || labels.has(e.label)) steps.push({ ...e, dir: "in" });
+    for (const e of g.in.get(node2) ?? []) if (follow(e)) steps.push({ ...e, dir: "in" });
   }
   return steps;
 }
@@ -65163,11 +65802,12 @@ async function graphNeighbors(app, settings, input) {
   const direction = checkDirection(input.direction);
   const g = await graphIndex(app, settings);
   const labels = labelSet(input.edges);
+  const visible = visibleNodes(app, settings);
   const nodes = await resolveNodes(app, settings, input.from, "from");
   if (nodes.length > MAX_GRAPH_NODES) throw new OperationInputError(`"from" matches ${nodes.length} notes (max ${MAX_GRAPH_NODES}): narrow it`);
   return {
     nodes: nodes.map((path23) => {
-      const edges = stepsFrom(g, path23, direction, labels).map((s) => ({
+      const edges = stepsFrom(g, path23, direction, labels, visible).map((s) => ({
         path: s.to,
         ...g.tableOf.has(s.to) ? { table: g.tableOf.get(s.to) } : {},
         label: s.label,
@@ -65182,11 +65822,18 @@ async function graphNeighbors(app, settings, input) {
 function qualifiedTables(app, settings, names2, what) {
   if (!names2 || names2.length === 0) return null;
   const all = listTables(app, settings.databaseFolder);
+  const scope = currentReadScope();
+  const known = scope ? all.filter((t) => tableReadable(t.qualified, scope)) : all;
   const out2 = /* @__PURE__ */ new Set();
   for (const n of names2) {
-    const hits = all.filter((t) => t.qualified === n || t.qualified.endsWith(`.${n}`));
+    let hits = all.filter((t) => t.qualified === n || t.qualified.endsWith(`.${n}`));
+    if (scope) {
+      const readable = hits.filter((t) => tableReadable(t.qualified, scope));
+      if (readable.length === 0 && hits.length > 0) throw tableReadDenied(scope.token, hits[0].qualified);
+      hits = readable;
+    }
     if (hits.length === 0) {
-      throw new OperationInputError(`${what}: unknown table "${n}"`, unknownName(n.split(".").pop(), all.map((t) => t.name), "tables", "list_tables lists them.", "graph"));
+      throw new OperationInputError(`${what}: unknown table "${n}"`, unknownName(n.split(".").pop(), known.map((t) => t.name), "tables", "list_tables lists them.", "graph"));
     }
     if (hits.length > 1) {
       throw new OperationInputError(`${what}: "${n}" matches ${hits.map((h) => h.qualified).join(", ")}`, guide(`Name the table in full: ${hits.map((h) => h.qualified).join(" or ")}.`, "graph"));
@@ -65207,6 +65854,7 @@ async function graphTraverse(app, settings, input) {
   const labels = labelSet(input.edges);
   const want = qualifiedTables(app, settings, input.tables, "tables");
   const through = qualifiedTables(app, settings, input.through, "through");
+  const visible = visibleNodes(app, settings);
   const starts = await resolveNodes(app, settings, input.from, "from");
   const via = new Map(starts.map((s) => [s, []]));
   let frontier = starts;
@@ -65227,7 +65875,7 @@ async function graphTraverse(app, settings, input) {
     const next = [];
     for (const node2 of frontier) {
       if (depth > 1 && through && !through.has(g.tableOf.get(node2) ?? "")) continue;
-      for (const s of stepsFrom(g, node2, direction, labels)) {
+      for (const s of stepsFrom(g, node2, direction, labels, visible)) {
         if (via.has(s.to)) continue;
         via.set(s.to, [...via.get(node2), { from: node2, label: s.label, direction: s.dir, to: s.to }]);
         next.push(s.to);
@@ -65247,6 +65895,7 @@ async function graphPath(app, settings, input) {
   }
   const g = await graphIndex(app, settings);
   const labels = labelSet(input.edges);
+  const visible = visibleNodes(app, settings);
   const sources = await resolveNodes(app, settings, input.from, "from");
   const targets = new Set(await resolveNodes(app, settings, input.to, "to"));
   const via = new Map(sources.map((s) => [s, []]));
@@ -65256,7 +65905,7 @@ async function graphPath(app, settings, input) {
   for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) {
     const next = [];
     for (const node2 of frontier) {
-      for (const s of stepsFrom(g, node2, direction, labels)) {
+      for (const s of stepsFrom(g, node2, direction, labels, visible)) {
         if (via.has(s.to)) continue;
         const steps = [...via.get(node2), { from: node2, label: s.label, direction: s.dir, to: s.to }];
         if (targets.has(s.to)) return { found: true, length: depth, via: steps, from: steps[0].from, to: s.to };
@@ -65273,6 +65922,7 @@ async function graphPath(app, settings, input) {
 init_engine();
 init_metastore();
 init_table_registry();
+init_read_scope();
 var DATE_RE2 = /^\d{4}-\d{2}-\d{2}$/;
 var DATETIME_RE2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?$/;
 var LINK_RE2 = /^\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]$/;
@@ -65310,14 +65960,16 @@ function tableNameFor(folder) {
 }
 function filesOf(app, settings, input) {
   const out2 = /* @__PURE__ */ new Map();
+  const scope = currentReadScope();
   if (input.folder !== void 0) {
     const prefix = input.folder.replace(/^\/+|\/+$/g, "");
     for (const f of app.vault.getMarkdownFiles()) {
-      if (prefix === "" || f.path.startsWith(`${prefix}/`)) out2.set(f.path, f);
+      if ((prefix === "" || f.path.startsWith(`${prefix}/`)) && pathReadable(app, settings, f.path, scope)) out2.set(f.path, f);
     }
   }
   for (const p of input.paths ?? []) {
     const path23 = p.endsWith(".md") ? p : `${p}.md`;
+    assertPathReadable(app, settings, path23);
     const f = app.vault.getAbstractFileByPath(path23);
     if (f && "extension" in f) out2.set(path23, f);
   }
@@ -65355,7 +66007,7 @@ function inferColumns(app, settings, observed, files, maxEnum) {
         col.items = itemKind === "list" ? "string" : itemKind;
       }
       if (col.items === "link") {
-        const ref2 = refOf2(app, settings, filled.flatMap((x) => Array.isArray(x.value) ? x.value.map((v) => ({ path: x.path, value: v })) : [x]));
+        const ref2 = refOf3(app, settings, filled.flatMap((x) => Array.isArray(x.value) ? x.value.map((v) => ({ path: x.path, value: v })) : [x]));
         if (ref2) col.ref = ref2;
       }
     } else if (kind === "string") {
@@ -65370,7 +66022,7 @@ function inferColumns(app, settings, observed, files, maxEnum) {
     } else {
       col.type = kind;
       if (kind === "link") {
-        const ref2 = refOf2(app, settings, filled);
+        const ref2 = refOf3(app, settings, filled);
         if (ref2) col.ref = ref2;
       }
     }
@@ -65386,7 +66038,7 @@ function frequencyOrder(values) {
   for (const v of values) n.set(v, (n.get(v) ?? 0) + 1);
   return [...n.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([v]) => v);
 }
-function refOf2(app, settings, links) {
+function refOf3(app, settings, links) {
   const counts = /* @__PURE__ */ new Map();
   let resolved = 0;
   for (const { path: path23, value } of links) {
@@ -65400,7 +66052,7 @@ function refOf2(app, settings, links) {
     if (owner) counts.set(owner, (counts.get(owner) ?? 0) + 1);
   }
   const best = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
-  return best && resolved > 0 && best[1] >= resolved * 0.8 ? best[0] : void 0;
+  return best && resolved > 0 && best[1] >= resolved * 0.8 && tableReadable(best[0]) ? best[0] : void 0;
 }
 function frontmatter(app, f) {
   const fm = app.metadataCache.getFileCache(f)?.frontmatter;
@@ -65412,6 +66064,7 @@ async function inferTable(app, settings, input) {
   const notes = [];
   if (input.table !== void 0) {
     const t = await loadTable(app, settings, input.table);
+    assertTableReadable(t.catalog.ref.full);
     const rows = await loadRows(app, settings, t);
     const declared = /* @__PURE__ */ new Set([...t.def.columns.map((c) => c.name), ...t.def.untypedFields]);
     const observed2 = /* @__PURE__ */ new Map();
@@ -65575,7 +66228,8 @@ init_hints();
 var FOLLOW_HINT = (topic) => guide("They run while the engine follows the vault: start it with datanotes serve --vault <folder>.", topic);
 async function listTablesAndViews(app, settings) {
   const ms = await loadMetastore(app, settings);
-  const views = ms ? catalogViews(ms.model).map(({ ref: ref2, view }) => ({
+  const scope = currentReadScope();
+  const views = ms ? catalogViews(ms.model).filter(({ ref: ref2 }) => viewReadable(ms.model, ref2.full, scope)).map(({ ref: ref2, view }) => ({
     name: ref2.table,
     catalog: ref2.catalog,
     schema: ref2.schema,
@@ -65583,10 +66237,17 @@ async function listTablesAndViews(app, settings) {
     ...view.description ? { description: view.description } : {},
     ...view.aliases && view.aliases.length > 0 ? { aliases: view.aliases } : {}
   })) : [];
-  return { tables: listTables(app, settings.databaseFolder), views };
+  return { tables: listTables(app, settings.databaseFolder).filter((t) => tableReadable(t.qualified, scope)), views };
 }
 async function describeTable(app, settings, table) {
+  const scope = currentReadScope();
+  if (scope) {
+    const model = (await loadMetastore(app, settings))?.model;
+    const view = model && typeof table === "string" && refOf2(model, table, "table") === null ? refOf2(model, table, "view") : null;
+    if (model && view && !viewReadable(model, view, scope)) throw tableReadDenied(scope.token, view);
+  }
   const t = await loadTable(app, settings, table);
+  assertTableReadable(t.catalog.ref.full);
   const { def } = t;
   const o = def.options;
   const e = t.catalog.entry;
@@ -65831,6 +66492,7 @@ init_metastore();
 init_store();
 init_engine();
 init_message();
+init_read_scope();
 var SHARDS = 16;
 var FORMAT = 1;
 function quantizeValues(v) {
@@ -66151,13 +66813,23 @@ var SemanticIndex = class {
     const q = await this.queryVector(input.query.trim());
     const limit = Math.min(Math.max(1, input.limit ?? 10), 100);
     const folder = input.folder?.replace(/^\/+|\/+$/g, "");
-    const wantTable = (t) => !input.tables || input.tables.length === 0 || t !== void 0 && input.tables.some((x) => t === x || t.endsWith(`.${x}`));
+    const scope = currentReadScope();
+    const settings = this.getSettings();
+    if (scope) {
+      const model = cachedMetastore(this.app, settings);
+      for (const name of input.tables ?? []) {
+        const full = model ? rowTableFull(model, name) : null;
+        if (full !== null) assertTableReadable(full);
+      }
+    }
+    const wantTable2 = (t) => !input.tables || input.tables.length === 0 || t !== void 0 && input.tables.some((x) => t === x || t.endsWith(`.${x}`));
     const min = input.minScore;
     const passing = (f) => f.passages.map((p) => ({ p, estimate: estimateOf(q, p) })).filter(({ p, estimate }) => min === void 0 || estimate >= min + SCORE_SLACK || estimate >= min - SCORE_SLACK && scoreOf(q, p) >= min);
     const notes = [];
     for (const [path23, f] of this.files) {
       if (folder && !path23.startsWith(`${folder}/`)) continue;
-      if (!wantTable(f.table)) continue;
+      if (!wantTable2(f.table)) continue;
+      if (scope && !pathReadable(this.app, settings, path23, scope)) continue;
       let estimate = -Infinity;
       for (const x of passing(f)) estimate = Math.max(estimate, x.estimate);
       if (estimate > -Infinity) notes.push({ path: path23, f, estimate });
@@ -66613,6 +67285,536 @@ init_actor();
 init_changeset();
 init_engine();
 init_vault_settle();
+
+// src/core/note-search.ts
+init_file_cache();
+init_hints();
+init_engine();
+init_metastore();
+init_read_scope();
+
+// src/core/vault-read.ts
+init_file_cache();
+init_database();
+init_datetime();
+init_hints();
+init_read_scope();
+var VaultPathNotFoundError = class extends GuidedError {
+  constructor() {
+    super(...arguments);
+    this.name = "VaultPathNotFoundError";
+  }
+};
+var VaultPathError = class extends GuidedError {
+  constructor() {
+    super(...arguments);
+    this.name = "VaultPathError";
+  }
+};
+var FIND_NOTE = guide("Give the vault path of the note, with .md: list_folder lists a folder, search_notes finds notes by their words.", "readNote");
+function clean(path23) {
+  return path23.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+}
+function readableFilter(app, settings) {
+  const scope = currentReadScope();
+  if (scope === null) return null;
+  if (!settings) return () => false;
+  return (path23) => pathReadable(app, settings, path23, scope);
+}
+async function readNote(app, settings, path23) {
+  const rel = clean(path23);
+  if (rel === "" || /\/$/.test(path23.trim())) {
+    throw new VaultPathError("path must name a file, not a folder", guide('Pass the vault path of a note, e.g. "Films/Metropolis.md"; list_folder lists a folder.', "readNote"));
+  }
+  const f = app.vault.getAbstractFileByPath(rel);
+  if (!f || !("extension" in f)) {
+    if (f) throw new VaultPathError(`${rel} is a folder: list_folder lists it`, FIND_NOTE);
+    throw new VaultPathNotFoundError(`no file ${rel} in the vault`, FIND_NOTE);
+  }
+  const file = f;
+  assertPathReadable(app, settings, file.path);
+  const { content } = await readHashed(app, file);
+  const cache = app.metadataCache.getFileCache(file);
+  const { position: _position, ...frontMatter } = cache?.frontmatter ?? {};
+  const fmTags = frontMatter.tags;
+  const tags = [
+    ...(cache?.tags ?? []).map((t) => t.tag.replace(/^#/, "")),
+    ...Array.isArray(fmTags) ? fmTags.map(String) : typeof fmTags === "string" ? [fmTags] : []
+  ];
+  const stat = file.stat;
+  const tz = (await readDatabaseConfig(app, settings)).timezone;
+  const at = (ms) => typeof ms === "number" && ms > 0 ? isoAt(ms, tz) : null;
+  return {
+    path: file.path,
+    content,
+    front_matter: frontMatter,
+    tags: [...new Set(tags)],
+    modified_at: at(stat?.mtime),
+    created_at: at(stat?.ctime),
+    size: typeof stat?.size === "number" ? stat.size : null
+  };
+}
+function listFolder(app, folder, settings) {
+  const rel = clean(folder);
+  const node2 = rel === "" ? app.vault.getRoot?.() ?? app.vault.getAbstractFileByPath("/") : app.vault.getAbstractFileByPath(rel);
+  if (!node2 || !("children" in node2)) {
+    if (node2) throw new VaultPathError(`${rel} is a file: read_note reads it`, guide('Pass a folder of the vault ("" is the vault root); read_note reads a file.', "readNote"));
+    throw new VaultPathNotFoundError(`no folder ${rel} in the vault`, guide('list_folder with folder "" lists the vault root; pass one of its folders.', "readNote"));
+  }
+  const readable = readableFilter(app, settings);
+  let shown = null;
+  if (readable) {
+    shown = /* @__PURE__ */ new Set();
+    const prefix = rel === "" ? "" : `${rel}/`;
+    for (const f of app.vault.getMarkdownFiles()) {
+      if (!f.path.startsWith(prefix) || !readable(f.path)) continue;
+      shown.add(f.path);
+      for (let i = f.path.indexOf("/", prefix.length); i >= 0; i = f.path.indexOf("/", i + 1)) shown.add(f.path.slice(0, i));
+    }
+  }
+  const folders = [];
+  const files = [];
+  for (const child of node2.children) {
+    const name = child.name ?? child.path.split("/").pop();
+    if (name.startsWith(".")) continue;
+    const path23 = rel === "" ? name : `${rel}/${name}`;
+    if (shown && !shown.has(path23)) continue;
+    ("children" in child ? folders : files).push(path23);
+  }
+  return { folder: rel, folders: folders.sort(), files: files.sort() };
+}
+function fold5(s) {
+  return s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+}
+var searchFold = fold5;
+var ONE_TO_ONE = /^[\u0000-˿]*$/;
+var BMP_FOLDED = new Uint8Array(65536).fill(255);
+function foldedLength(cp, ch) {
+  if (cp > 65535) return fold5(ch).length;
+  let n = BMP_FOLDED[cp];
+  if (n === 255) BMP_FOLDED[cp] = n = fold5(ch).length;
+  return n;
+}
+function foldedOffsets(content) {
+  if (ONE_TO_ONE.test(content)) return null;
+  const starts = [];
+  const ends = [];
+  let aligned = true;
+  for (let o = 0; o < content.length; ) {
+    const cp = content.codePointAt(o);
+    const width = cp > 65535 ? 2 : 1;
+    const n = cp < 768 ? 1 : foldedLength(cp, content.slice(o, o + width));
+    if (n !== width) aligned = false;
+    if (n === 0 && ends.length > 0) {
+      for (let k = ends.length - 1; k >= 0 && ends[k] === o; k--) ends[k] = o + width;
+    }
+    for (let k = 0; k < n; k++) {
+      starts.push(o);
+      ends.push(o + width);
+    }
+    o += width;
+  }
+  if (aligned) return null;
+  return {
+    // a match covers at least one folded character: its start and its last character are in the text
+    start: (i) => starts[i],
+    end: (i) => ends[i - 1]
+  };
+}
+var SEARCH_CACHE = { maxChars: 64 * 1024 * 1024 };
+var FOLDED = /* @__PURE__ */ new WeakMap();
+function foldedCache(app) {
+  let cache = FOLDED.get(app);
+  if (!cache) FOLDED.set(app, cache = { notes: /* @__PURE__ */ new Map(), chars: 0 });
+  return cache;
+}
+function keptFolded(app, path23, hash) {
+  const kept2 = foldedCache(app).notes.get(path23);
+  return kept2 && kept2.hash === hash ? kept2 : void 0;
+}
+function foldedNote(app, path23, hash, content, keep) {
+  const note = { hash, text: fold5(content), name: fold5(path23) };
+  if (!keep) return note;
+  const cache = foldedCache(app);
+  const kept2 = cache.notes.get(path23);
+  const size = note.text.length + note.name.length;
+  if (kept2) {
+    cache.chars += size - kept2.text.length - kept2.name.length;
+    cache.notes.set(path23, note);
+  } else if (cache.chars + size <= SEARCH_CACHE.maxChars) {
+    cache.chars += size;
+    cache.notes.set(path23, note);
+  }
+  return note;
+}
+function forgetFolded(app, present2) {
+  const cache = foldedCache(app);
+  for (const [path23, note] of cache.notes) {
+    if (present2.has(path23)) continue;
+    cache.notes.delete(path23);
+    cache.chars -= note.text.length + note.name.length;
+  }
+}
+var SEARCH_SOURCES = /* @__PURE__ */ new WeakMap();
+function setSearchSource(app, source) {
+  if (source) SEARCH_SOURCES.set(app, source);
+  else SEARCH_SOURCES.delete(app);
+}
+function searchCandidates(app, words) {
+  return SEARCH_SOURCES.get(app)?.candidates(words) ?? null;
+}
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function indexableWord(w) {
+  if (w.indexOf("\0") >= 0 || LONE_SURROGATE.test(w)) return false;
+  let n = 0;
+  for (const _ of w) if (++n >= 3) return true;
+  return false;
+}
+var HIDDEN = /(^|\/)\./;
+var MAX_RESULTS = 200;
+function scoreOf2(n, words) {
+  let hits = 0;
+  for (const w of words) {
+    for (let i = n.text.indexOf(w); i >= 0 && hits < 20; i = n.text.indexOf(w, i + w.length)) hits++;
+    if (hits >= 20) break;
+  }
+  return hits + words.filter((w) => n.name.includes(w)).length * 5;
+}
+function matchesOf(text5, content, words, ctx) {
+  const spans = [];
+  for (const w of words) {
+    for (let i = text5.indexOf(w); i >= 0; i = text5.indexOf(w, i + w.length)) spans.push({ start: i, end: i + w.length });
+  }
+  spans.sort((x, y) => x.start - y.start || y.end - x.end);
+  const merged = [];
+  for (const sp of spans) {
+    const last = merged[merged.length - 1];
+    if (last && (sp.start <= last.end || !/[\p{L}\p{N}]/u.test(text5.slice(last.end, sp.start)))) last.end = Math.max(last.end, sp.end);
+    else merged.push({ ...sp });
+  }
+  const at = merged.length > 0 ? foldedOffsets(content) : null;
+  return merged.slice(0, 20).map((m) => {
+    const start = at ? at.start(m.start) : m.start;
+    const end = at ? at.end(m.end) : m.end;
+    return { start, end, context: content.slice(Math.max(0, start - ctx), end + ctx) };
+  });
+}
+function candidateFiles(app, c) {
+  const out2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const list4 of [c.hits, c.unsure]) {
+    for (const p of list4) {
+      if (seen.has(p)) continue;
+      seen.add(p);
+      const f = app.vault.getAbstractFileByPath(p);
+      if (f && "extension" in f && f.extension === "md") out2.push(f);
+    }
+  }
+  return out2;
+}
+async function searchNotes(app, query, contextLength = 100, settings) {
+  const words = [...new Set(fold5(query).split(/\s+/).filter(Boolean))];
+  if (words.length === 0) return { query, results: [], total: 0 };
+  const ctx = Number.isFinite(contextLength) && contextLength >= 0 ? Math.min(Math.floor(contextLength), 1e3) : 100;
+  const indexable = words.filter(indexableWord);
+  const narrowed = indexable.length > 0 ? searchCandidates(app, indexable) : null;
+  const files = narrowed ? candidateFiles(app, narrowed) : app.vault.getMarkdownFiles();
+  const keep = narrowed === null;
+  const present2 = keep ? /* @__PURE__ */ new Set() : null;
+  const has2 = (n) => words.every((w) => n.text.includes(w) || n.name.includes(w));
+  const readable = readableFilter(app, settings);
+  const found = [];
+  for (const f of files) {
+    if (HIDDEN.test(f.path)) continue;
+    present2?.add(f.path);
+    if (readable && !readable(f.path)) continue;
+    let content;
+    let folded = keptFolded(app, f.path, await readHash(app, f));
+    if (!folded) {
+      const r = await readHashed(app, f);
+      content = r.content;
+      folded = foldedNote(app, f.path, r.hash, content, keep);
+    }
+    if (!has2(folded)) continue;
+    if (content === void 0) {
+      const r = await readHashed(app, f);
+      content = r.content;
+      if (r.hash !== folded.hash && !has2(folded = foldedNote(app, f.path, r.hash, content, keep))) continue;
+    }
+    found.push({ path: f.path, score: scoreOf2(folded, words), folded, content });
+  }
+  if (present2) forgetFolded(app, present2);
+  found.sort((x, y) => y.score - x.score || x.path.localeCompare(y.path));
+  const results = found.slice(0, MAX_RESULTS).map((r) => ({ path: r.path, score: r.score, matches: matchesOf(r.folded.text, r.content, words, ctx) }));
+  return { query, results, total: found.length };
+}
+
+// src/core/note-search.ts
+init_message();
+var K12 = 1.2;
+var B2 = 0.75;
+var NAME = 3;
+var FRONT_MATTER = 1;
+var PAIR = 0.75;
+var RRF_K2 = 60;
+var FUSION_DEPTH2 = 50;
+var MEANING_DEPTH = 100;
+var SNIPPET = 200;
+var SEARCH_GUIDE = (hint) => guide(hint, "search");
+function searchTerms(text5) {
+  return (searchFold(text5).match(/[\p{L}\p{N}]+/gu) ?? []).filter((w) => w.length > 1 || new RegExp("\\p{N}", "u").test(w));
+}
+function parseSearchQuery(query) {
+  const words = [];
+  const required2 = [];
+  const excluded = [];
+  const quoted3 = query.replace(/[“”„«»]/g, '"');
+  for (const m of quoted3.matchAll(/([+-]?)(?:"([^"]*)"?|([^\s"]+))/g)) {
+    const [, sign, phrase, word] = m;
+    if (word !== void 0 && (sign === "" || word.startsWith("-"))) {
+      words.push(`${sign}${word}`);
+      continue;
+    }
+    const content = phrase ?? word;
+    const terms = searchTerms(content);
+    if (sign === "-") {
+      if (terms.length > 0) excluded.push(terms);
+      continue;
+    }
+    words.push(content);
+    if (terms.length > 0) required2.push(terms);
+  }
+  return { text: words.join(" "), required: required2, excluded };
+}
+function field2(text5) {
+  const terms = searchTerms(text5);
+  const counts = /* @__PURE__ */ new Map();
+  for (const t of terms) counts.set(t, (counts.get(t) ?? 0) + 1);
+  return { terms, counts };
+}
+function occurrences2(f, terms) {
+  if (terms.length === 1) return f.counts.get(terms[0]) ?? 0;
+  let n = 0;
+  for (let i = 0; i + terms.length <= f.terms.length; i++) if (terms.every((s, j) => f.terms[i + j] === s)) n++;
+  return n;
+}
+function adjacent2(f, a, b) {
+  for (let i = 0; i + 1 < f.terms.length; i++) if (f.terms[i] === a && f.terms[i + 1] === b) return true;
+  return false;
+}
+function linkText(text5) {
+  return text5.replace(/\[\[([^\]|#]*)(?:#[^\]|]*)?(?:\|([^\]]*))?\]\]/g, (_, target, alias) => alias ?? target.split("/").pop());
+}
+function splitNote(content) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(content);
+  return m ? { frontMatter: m[1], body: content.slice(m[0].length) } : { frontMatter: null, body: content };
+}
+function frontMatterValues(yaml, tableKey) {
+  const skip = /* @__PURE__ */ new Set(["id", tableKey]);
+  const out2 = [];
+  let key2 = null;
+  for (const line of yaml.split(/\r?\n/)) {
+    const entry = /^([^\s:#-][^:]*):\s*(.*)$/.exec(line);
+    if (entry) {
+      key2 = entry[1].trim().replace(/^["']|["']$/g, "");
+      if (!skip.has(key2) && entry[2].trim() !== "") out2.push(linkText(entry[2].trim()));
+      continue;
+    }
+    if (key2 !== null && !skip.has(key2) && line.trim() !== "") out2.push(linkText(line.trim().replace(/^-\s*/, "")));
+  }
+  return out2;
+}
+function fieldsOf(path23, hash, content, tableKey) {
+  const { frontMatter, body } = splitNote(content);
+  const lines = frontMatter === null ? [] : frontMatterValues(frontMatter, tableKey);
+  const name = path23.split("/").pop().replace(/\.md$/i, "");
+  return { hash, name: field2(name), frontMatter: field2(lines.join("\n")), body: field2(linkText(body)), frontMatterLines: lines, bodyText: body };
+}
+var SEARCH_TERMS_CACHE = { maxTerms: 8e6 };
+var KEPT2 = /* @__PURE__ */ new WeakMap();
+var sizeOf = (n) => n.name.terms.length + n.frontMatter.terms.length + n.body.terms.length;
+function keptNotes(app) {
+  let kept2 = KEPT2.get(app);
+  if (!kept2) KEPT2.set(app, kept2 = { notes: /* @__PURE__ */ new Map(), terms: 0 });
+  return kept2;
+}
+async function noteFields(app, f, tableKey) {
+  const kept2 = keptNotes(app);
+  const old = kept2.notes.get(f.path);
+  if (old && old.hash === await readHash(app, f)) return old;
+  const { content, hash } = await readHashed(app, f);
+  const n = fieldsOf(f.path, hash, content, tableKey);
+  if (old) {
+    kept2.terms += sizeOf(n) - sizeOf(old);
+    kept2.notes.set(f.path, n);
+  } else if (kept2.terms + sizeOf(n) <= SEARCH_TERMS_CACHE.maxTerms) {
+    kept2.terms += sizeOf(n);
+    kept2.notes.set(f.path, n);
+  }
+  return n;
+}
+function forgetGone(app, present2) {
+  const kept2 = keptNotes(app);
+  for (const [path23, n] of kept2.notes) {
+    if (present2.has(path23)) continue;
+    kept2.notes.delete(path23);
+    kept2.terms -= sizeOf(n);
+  }
+}
+function allows2(n, q) {
+  const holds = (terms) => occurrences2(n.name, terms) + occurrences2(n.frontMatter, terms) + occurrences2(n.body, terms) > 0;
+  return q.required.every(holds) && !q.excluded.some(holds);
+}
+var wantTable = (tables, table) => !tables || tables.length === 0 || table !== null && tables.some((x) => table === x || table.endsWith(`.${x}`));
+function headingAt(body, at) {
+  let heading = "";
+  for (const m of body.slice(0, at).matchAll(/^#{1,6}[ \t]+(.+?)[ \t#]*$/gm)) heading = m[1];
+  return heading;
+}
+function around(text5, at) {
+  const start = Math.max(0, at - 60);
+  const cut2 = text5.slice(start, start + SNIPPET).replace(/\s+/g, " ").trim();
+  return `${start > 0 ? "\u2026" : ""}${cut2}${start + SNIPPET < text5.length ? "\u2026" : ""}`;
+}
+function firstMatch(text5, terms) {
+  for (const m of text5.matchAll(/[\p{L}\p{M}\p{N}]+/gu)) if (searchTerms(m[0]).some((t) => terms.has(t))) return m.index;
+  return -1;
+}
+function excerptOf(n, terms) {
+  const prose = n.bodyText.split("\n").filter((l) => !/^(#{1,6}\s|\s*```|\s*~~~)/.test(l)).join(" ").replace(/\s+/g, " ").trim();
+  const at = firstMatch(n.bodyText, terms);
+  if (at >= 0) return { heading: headingAt(n.bodyText, at), snippet: around(prose, Math.max(0, firstMatch(prose, terms))) };
+  const line = n.frontMatterLines.find((l) => firstMatch(l, terms) >= 0);
+  if (line !== void 0) return { heading: "", snippet: around(line, 0) };
+  return { heading: "", snippet: around(prose, 0) };
+}
+function rankByWords(notes, corpus, q, terms) {
+  const df = terms.map((t) => notes.filter((n) => occurrences2(n.fields.name, [t]) + occurrences2(n.fields.frontMatter, [t]) + occurrences2(n.fields.body, [t]) > 0).length);
+  const idf = df.map((d) => Math.log(1 + (corpus - d + 0.5) / (d + 0.5)));
+  const avg = notes.length === 0 ? 1 : Math.max(1, notes.reduce((s, n) => s + n.fields.body.terms.length, 0) / notes.length);
+  const out2 = [];
+  for (const n of notes) {
+    if (!allows2(n.fields, q)) continue;
+    const { name, frontMatter, body } = n.fields;
+    let score = 0;
+    let matched = 0;
+    terms.forEach((t, i) => {
+      const w = idf[i];
+      const count2 = body.counts.get(t) ?? 0;
+      const s = (count2 > 0 ? w * count2 * (K12 + 1) / (count2 + K12 * (1 - B2 + B2 * body.terms.length / avg)) : 0) + (name.counts.has(t) ? NAME * w : 0) + (frontMatter.counts.has(t) ? FRONT_MATTER * w : 0);
+      if (s > 0) matched++;
+      score += s;
+    });
+    if (matched === 0) continue;
+    for (let i = 0; i + 1 < terms.length; i++) {
+      const [a, b] = [terms[i], terms[i + 1]];
+      if (adjacent2(name, a, b) || adjacent2(frontMatter, a, b) || adjacent2(body, a, b)) score += PAIR * Math.min(idf[i], idf[i + 1]);
+    }
+    score *= (matched / terms.length) ** 2;
+    out2.push({ path: n.path, score, fields: n.fields });
+  }
+  return out2.sort((x, y) => y.score - x.score || x.path.localeCompare(y.path));
+}
+var HIDDEN2 = /(^|\/)\./;
+async function searchVault(app, settings, input, semantic) {
+  if (typeof input.query !== "string" || input.query.trim() === "") throw new OperationInputError(`"query" is required`, SEARCH_GUIDE(`Give a few words, for example search({query: "pasta al pomodoro"}).`));
+  await loadMetastore(app, settings);
+  const q = parseSearchQuery(input.query);
+  const terms = [...new Set(searchTerms(q.text))];
+  if (terms.length === 0) {
+    throw new OperationInputError(
+      "search: the query has no words to look for",
+      SEARCH_GUIDE(`Give at least one word to rank by: "-word" only leaves notes out, and single letters are not searched. Example: search({query: "uovo -latte"}).`)
+    );
+  }
+  const limit = Math.min(Math.max(1, Math.floor(input.limit ?? 10)), 100);
+  const folder = input.folder?.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  const scope = currentReadScope();
+  if (scope) {
+    const model = cachedMetastore(app, settings);
+    for (const name of input.tables ?? []) {
+      const full = model ? rowTableFull(model, name) : null;
+      if (full !== null) assertTableReadable(full);
+    }
+  }
+  const files = app.vault.getMarkdownFiles();
+  const corpus = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    if (HIDDEN2.test(f.path)) continue;
+    if (folder && !f.path.startsWith(`${folder}/`)) continue;
+    if (scope && !pathReadable(app, settings, f.path, scope)) continue;
+    const table = input.tables && input.tables.length > 0 ? tableOfPath(app, settings, f.path) : null;
+    if (!wantTable(input.tables, table)) continue;
+    corpus.set(f.path, { file: f, table });
+  }
+  let read3 = corpus.values();
+  if (terms.every(indexableWord)) {
+    const named = /* @__PURE__ */ new Set();
+    let all = false;
+    for (const t of terms) {
+      const c = searchCandidates(app, [t]);
+      if (c === null) {
+        all = true;
+        break;
+      }
+      for (const list4 of [c.hits, c.unsure]) for (const p of list4) named.add(p);
+    }
+    if (!all) read3 = [...named].map((p) => corpus.get(p)).filter((c) => c !== void 0);
+  }
+  const notes = [];
+  for (const c of read3) notes.push({ path: c.file.path, fields: await noteFields(app, c.file, settings.tableKey) });
+  forgetGone(app, new Set(files.map((f) => f.path)));
+  const byWords = rankByWords(notes, corpus.size, q, terms);
+  const termSet = new Set(terms);
+  const tableOf = (path23) => corpus.get(path23)?.table ?? tableOfPath(app, settings, path23);
+  const words = (r, score, matchedBy) => {
+    const table = tableOf(r.path);
+    return { path: r.path, ...table ? { table } : {}, score, ...excerptOf(r.fields, termSet), matched_by: matchedBy };
+  };
+  if (!semantic || !settings.semanticEnabled) {
+    return { query: input.query, results: byWords.slice(0, limit).map((r) => words(r, Math.round(r.score * 100) / 100, ["words"])), meaning: "off" };
+  }
+  let meaningHits;
+  try {
+    const r = await semantic.search({
+      query: q.text,
+      limit: MEANING_DEPTH,
+      ...input.tables && input.tables.length > 0 ? { tables: input.tables } : {},
+      ...folder ? { folder } : {},
+      ...input.minScore !== void 0 ? { minScore: input.minScore } : {}
+    });
+    meaningHits = r.results;
+  } catch (e) {
+    if (e instanceof ReadDeniedError || e instanceof OperationInputError) throw e;
+    return { query: input.query, results: byWords.slice(0, limit).map((r) => words(r, Math.round(r.score * 100) / 100, ["words"])), meaning: "failed", meaning_error: messageOf(e) };
+  }
+  const meaning = [];
+  for (const h of meaningHits) {
+    const c = corpus.get(h.path);
+    if (!c) continue;
+    const fields = await noteFields(app, c.file, settings.tableKey);
+    if (!allows2(fields, q)) continue;
+    meaning.push({ path: h.path, heading: h.heading, snippet: h.snippet, fields });
+    if (meaning.length === FUSION_DEPTH2) break;
+  }
+  const fused = /* @__PURE__ */ new Map();
+  byWords.slice(0, FUSION_DEPTH2).forEach((r, i) => fused.set(r.path, { score: 1 / (RRF_K2 + i + 1), wordsRank: i + 1, ranked: r }));
+  meaning.forEach((m, i) => {
+    const f = fused.get(m.path) ?? { score: 0, wordsRank: Infinity };
+    f.score += 1 / (RRF_K2 + i + 1);
+    f.meaning = m;
+    fused.set(m.path, f);
+  });
+  const results = [...fused.entries()].sort(([pa, a], [pb, b]) => b.score - a.score || a.wordsRank - b.wordsRank || pa.localeCompare(pb)).slice(0, limit).map(([path23, f]) => {
+    const score = Math.round(f.score * 1e4) / 1e4;
+    if (f.ranked) return words(f.ranked, score, f.meaning ? ["words", "meaning"] : ["words"]);
+    const table = tableOf(path23);
+    return { path: path23, ...table ? { table } : {}, score, heading: f.meaning.heading, snippet: f.meaning.snippet, matched_by: ["meaning"] };
+  });
+  return { query: input.query, results, meaning: "on" };
+}
+
+// src/server/rest.ts
 init_write_check();
 init_query();
 init_journal();
@@ -66890,6 +68092,7 @@ async function rowMovesSince(app, rows) {
 // src/core/change-feed.ts
 init_table_loader();
 init_types_table();
+init_read_scope();
 init_store();
 init_vault_index();
 init_telemetry();
@@ -67046,6 +68249,24 @@ function matches(ev, q) {
   if (q.excludeActor && ev.actor?.harness === q.excludeActor) return false;
   return true;
 }
+function eventTable(app, settings, table) {
+  if (table === null) return null;
+  const model = cachedMetastore(app, settings);
+  return (model ? rowTableFull(model, table) : null) ?? table;
+}
+function eventForScope(ev, scope, app, settings) {
+  if (scope === null) return ev;
+  if (ev.op === "tool_call") return ev.actor?.auth === scope.token ? ev : null;
+  const table = eventTable(app, settings, ev.table);
+  if (table === null || !tableReadable(table, scope)) return null;
+  const shown = (path23) => path23 === ev.path || path23 === ev.oldPath || pathReadable(app, settings, path23, scope);
+  const violations = ev.violations?.filter((v) => shown(v.path));
+  const cause = ev.cause?.filter((c) => pathReadable(app, settings, c.path, scope));
+  const cut2 = violations !== void 0 && violations.length < ev.violations.length;
+  if (!cut2 && cause?.length === ev.cause?.length) return ev;
+  const { violationsTotal, ...rest } = ev;
+  return { ...rest, ...violations !== void 0 ? { violations } : {}, ...!cut2 && violationsTotal !== void 0 ? { violationsTotal } : {}, ...cause !== void 0 ? { cause } : {} };
+}
 var STATE_SLICE = 2e3;
 var ChangeFeed = class {
   constructor(app, getSettings, retentionDays = 30) {
@@ -67715,9 +68936,14 @@ var ChangeFeed = class {
       latest: broken.slice(0, limit).map((e) => ({ path: e.path, table: e.table, at: e.at, seq: e.seq, violations: count2(e), message: e.violations[0].message }))
     };
   }
-  /** Events after `since` that match the query. */
-  async read(q = {}) {
+  /**
+   * Events after `since` that match the query, as the read scope sees them ({@link eventForScope}:
+   * by default the scope of the request that reads; delivery that runs on its own passes its own).
+   */
+  async read(q = {}, scope = currentReadScope()) {
     const since = q.since ?? 0;
+    const s = this.getSettings();
+    const visible = (ev) => eventForScope(ev, scope, this.app, s);
     const limit = Math.min(Math.max(q.limit ?? 500, 1), 5e3);
     let source;
     if (this.buffer.length > 0 && since >= this.buffer[0].seq - 1) source = this.buffer.slice(firstAfter(this.buffer, since));
@@ -67735,7 +68961,7 @@ var ChangeFeed = class {
           if (ev.seq > max) max = ev.seq;
           if (ev.seq <= since) continue;
           source.push(ev);
-          if (plain && matches(ev, q)) matched++;
+          if (plain && matches(ev, q) && (scope === null || visible(ev) !== null)) matched++;
         }
         if (events2.length > 0) this.fileMaxSeq.set(f, max);
         if (plain && matched >= limit) break;
@@ -67751,7 +68977,10 @@ var ChangeFeed = class {
     for (let i = 0; i < source.length; i++) {
       const ev = source[i];
       last = ev.seq;
-      if (kept2[i] && rowMatches(ev)) events.push(ev);
+      if (kept2[i] && rowMatches(ev)) {
+        const shown = visible(ev);
+        if (shown) events.push(shown);
+      }
       if (events.length >= limit) break;
     }
     if (events.length < limit) last = Math.max(last, Math.min(this.seq, source.length ? source[source.length - 1].seq : since));
@@ -67795,10 +69024,10 @@ var ChangeFeed = class {
     for (const w of [...this.waiters]) w();
   }
   /** Like `read`, but waits up to `waitMs` for a matching event when there is none yet (long poll). */
-  async wait(q, waitMs) {
+  async wait(q, waitMs, scope = currentReadScope()) {
     const started = Date.now();
     const deadline = started + Math.min(Math.max(waitMs, 0), 6e4);
-    let page2 = await this.read(q);
+    let page2 = await this.read(q, scope);
     let since = page2.last;
     while (page2.events.length === 0 && Date.now() < deadline && this.waitsEnded < started) {
       await new Promise((resolve) => {
@@ -67811,7 +69040,7 @@ var ChangeFeed = class {
         }
         this.waiters.add(done);
       });
-      page2 = await this.read({ ...q, since });
+      page2 = await this.read({ ...q, since }, scope);
       since = page2.last;
     }
     return page2;
@@ -67842,246 +69071,18 @@ function changedTables2(prev, next) {
   return catalogTables(after).filter(({ ref: ref2, entry }) => was.get(ref2.full) !== JSON.stringify(entry)).map(({ ref: ref2 }) => ref2.full).sort();
 }
 
-// src/core/vault-read.ts
-init_file_cache();
-init_database();
-init_datetime();
-init_hints();
-var VaultPathNotFoundError = class extends GuidedError {
-  constructor() {
-    super(...arguments);
-    this.name = "VaultPathNotFoundError";
-  }
-};
-var VaultPathError = class extends GuidedError {
-  constructor() {
-    super(...arguments);
-    this.name = "VaultPathError";
-  }
-};
-var FIND_NOTE = guide("Give the vault path of the note, with .md: list_folder lists a folder, search_notes finds notes by their words.", "readNote");
-function clean(path23) {
-  return path23.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-}
-async function readNote(app, settings, path23) {
-  const rel = clean(path23);
-  if (rel === "" || /\/$/.test(path23.trim())) {
-    throw new VaultPathError("path must name a file, not a folder", guide('Pass the vault path of a note, e.g. "Films/Metropolis.md"; list_folder lists a folder.', "readNote"));
-  }
-  const f = app.vault.getAbstractFileByPath(rel);
-  if (!f || !("extension" in f)) {
-    if (f) throw new VaultPathError(`${rel} is a folder: list_folder lists it`, FIND_NOTE);
-    throw new VaultPathNotFoundError(`no file ${rel} in the vault`, FIND_NOTE);
-  }
-  const file = f;
-  const { content } = await readHashed(app, file);
-  const cache = app.metadataCache.getFileCache(file);
-  const { position: _position, ...frontMatter } = cache?.frontmatter ?? {};
-  const fmTags = frontMatter.tags;
-  const tags = [
-    ...(cache?.tags ?? []).map((t) => t.tag.replace(/^#/, "")),
-    ...Array.isArray(fmTags) ? fmTags.map(String) : typeof fmTags === "string" ? [fmTags] : []
-  ];
-  const stat = file.stat;
-  const tz = (await readDatabaseConfig(app, settings)).timezone;
-  const at = (ms) => typeof ms === "number" && ms > 0 ? isoAt(ms, tz) : null;
-  return {
-    path: file.path,
-    content,
-    front_matter: frontMatter,
-    tags: [...new Set(tags)],
-    modified_at: at(stat?.mtime),
-    created_at: at(stat?.ctime),
-    size: typeof stat?.size === "number" ? stat.size : null
-  };
-}
-function listFolder(app, folder) {
-  const rel = clean(folder);
-  const node2 = rel === "" ? app.vault.getRoot?.() ?? app.vault.getAbstractFileByPath("/") : app.vault.getAbstractFileByPath(rel);
-  if (!node2 || !("children" in node2)) {
-    if (node2) throw new VaultPathError(`${rel} is a file: read_note reads it`, guide('Pass a folder of the vault ("" is the vault root); read_note reads a file.', "readNote"));
-    throw new VaultPathNotFoundError(`no folder ${rel} in the vault`, guide('list_folder with folder "" lists the vault root; pass one of its folders.', "readNote"));
-  }
-  const folders = [];
-  const files = [];
-  for (const child of node2.children) {
-    const name = child.name ?? child.path.split("/").pop();
-    if (name.startsWith(".")) continue;
-    const path23 = rel === "" ? name : `${rel}/${name}`;
-    ("children" in child ? folders : files).push(path23);
-  }
-  return { folder: rel, folders: folders.sort(), files: files.sort() };
-}
-function fold5(s) {
-  return s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
-}
-var searchFold = fold5;
-var ONE_TO_ONE = /^[\u0000-˿]*$/;
-var BMP_FOLDED = new Uint8Array(65536).fill(255);
-function foldedLength(cp, ch) {
-  if (cp > 65535) return fold5(ch).length;
-  let n = BMP_FOLDED[cp];
-  if (n === 255) BMP_FOLDED[cp] = n = fold5(ch).length;
-  return n;
-}
-function foldedOffsets(content) {
-  if (ONE_TO_ONE.test(content)) return null;
-  const starts = [];
-  const ends = [];
-  let aligned = true;
-  for (let o = 0; o < content.length; ) {
-    const cp = content.codePointAt(o);
-    const width = cp > 65535 ? 2 : 1;
-    const n = cp < 768 ? 1 : foldedLength(cp, content.slice(o, o + width));
-    if (n !== width) aligned = false;
-    if (n === 0 && ends.length > 0) {
-      for (let k = ends.length - 1; k >= 0 && ends[k] === o; k--) ends[k] = o + width;
-    }
-    for (let k = 0; k < n; k++) {
-      starts.push(o);
-      ends.push(o + width);
-    }
-    o += width;
-  }
-  if (aligned) return null;
-  return {
-    // a match covers at least one folded character: its start and its last character are in the text
-    start: (i) => starts[i],
-    end: (i) => ends[i - 1]
-  };
-}
-var SEARCH_CACHE = { maxChars: 64 * 1024 * 1024 };
-var FOLDED = /* @__PURE__ */ new WeakMap();
-function foldedCache(app) {
-  let cache = FOLDED.get(app);
-  if (!cache) FOLDED.set(app, cache = { notes: /* @__PURE__ */ new Map(), chars: 0 });
-  return cache;
-}
-function keptFolded(app, path23, hash) {
-  const kept2 = foldedCache(app).notes.get(path23);
-  return kept2 && kept2.hash === hash ? kept2 : void 0;
-}
-function foldedNote(app, path23, hash, content, keep) {
-  const note = { hash, text: fold5(content), name: fold5(path23) };
-  if (!keep) return note;
-  const cache = foldedCache(app);
-  const kept2 = cache.notes.get(path23);
-  const size = note.text.length + note.name.length;
-  if (kept2) {
-    cache.chars += size - kept2.text.length - kept2.name.length;
-    cache.notes.set(path23, note);
-  } else if (cache.chars + size <= SEARCH_CACHE.maxChars) {
-    cache.chars += size;
-    cache.notes.set(path23, note);
-  }
-  return note;
-}
-function forgetFolded(app, present2) {
-  const cache = foldedCache(app);
-  for (const [path23, note] of cache.notes) {
-    if (present2.has(path23)) continue;
-    cache.notes.delete(path23);
-    cache.chars -= note.text.length + note.name.length;
-  }
-}
-var SEARCH_SOURCES = /* @__PURE__ */ new WeakMap();
-function setSearchSource(app, source) {
-  if (source) SEARCH_SOURCES.set(app, source);
-  else SEARCH_SOURCES.delete(app);
-}
-var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
-function indexableWord(w) {
-  if (w.indexOf("\0") >= 0 || LONE_SURROGATE.test(w)) return false;
-  let n = 0;
-  for (const _ of w) if (++n >= 3) return true;
-  return false;
-}
-var HIDDEN = /(^|\/)\./;
-var MAX_RESULTS = 200;
-function scoreOf2(n, words) {
-  let hits = 0;
-  for (const w of words) {
-    for (let i = n.text.indexOf(w); i >= 0 && hits < 20; i = n.text.indexOf(w, i + w.length)) hits++;
-    if (hits >= 20) break;
-  }
-  return hits + words.filter((w) => n.name.includes(w)).length * 5;
-}
-function matchesOf(text5, content, words, ctx) {
-  const spans = [];
-  for (const w of words) {
-    for (let i = text5.indexOf(w); i >= 0; i = text5.indexOf(w, i + w.length)) spans.push({ start: i, end: i + w.length });
-  }
-  spans.sort((x, y) => x.start - y.start || y.end - x.end);
-  const merged = [];
-  for (const sp of spans) {
-    const last = merged[merged.length - 1];
-    if (last && (sp.start <= last.end || !/[\p{L}\p{N}]/u.test(text5.slice(last.end, sp.start)))) last.end = Math.max(last.end, sp.end);
-    else merged.push({ ...sp });
-  }
-  const at = merged.length > 0 ? foldedOffsets(content) : null;
-  return merged.slice(0, 20).map((m) => {
-    const start = at ? at.start(m.start) : m.start;
-    const end = at ? at.end(m.end) : m.end;
-    return { start, end, context: content.slice(Math.max(0, start - ctx), end + ctx) };
-  });
-}
-function candidateFiles(app, c) {
-  const out2 = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const list4 of [c.hits, c.unsure]) {
-    for (const p of list4) {
-      if (seen.has(p)) continue;
-      seen.add(p);
-      const f = app.vault.getAbstractFileByPath(p);
-      if (f && "extension" in f && f.extension === "md") out2.push(f);
-    }
-  }
-  return out2;
-}
-async function searchNotes(app, query, contextLength = 100) {
-  const words = [...new Set(fold5(query).split(/\s+/).filter(Boolean))];
-  if (words.length === 0) return { query, results: [], total: 0 };
-  const ctx = Number.isFinite(contextLength) && contextLength >= 0 ? Math.min(Math.floor(contextLength), 1e3) : 100;
-  const indexable = words.filter(indexableWord);
-  const narrowed = indexable.length > 0 ? SEARCH_SOURCES.get(app)?.candidates(indexable) ?? null : null;
-  const files = narrowed ? candidateFiles(app, narrowed) : app.vault.getMarkdownFiles();
-  const keep = narrowed === null;
-  const present2 = keep ? /* @__PURE__ */ new Set() : null;
-  const has2 = (n) => words.every((w) => n.text.includes(w) || n.name.includes(w));
-  const found = [];
-  for (const f of files) {
-    if (HIDDEN.test(f.path)) continue;
-    present2?.add(f.path);
-    let content;
-    let folded = keptFolded(app, f.path, await readHash(app, f));
-    if (!folded) {
-      const r = await readHashed(app, f);
-      content = r.content;
-      folded = foldedNote(app, f.path, r.hash, content, keep);
-    }
-    if (!has2(folded)) continue;
-    if (content === void 0) {
-      const r = await readHashed(app, f);
-      content = r.content;
-      if (r.hash !== folded.hash && !has2(folded = foldedNote(app, f.path, r.hash, content, keep))) continue;
-    }
-    found.push({ path: f.path, score: scoreOf2(folded, words), folded, content });
-  }
-  if (present2) forgetFolded(app, present2);
-  found.sort((x, y) => y.score - x.score || x.path.localeCompare(y.path));
-  const results = found.slice(0, MAX_RESULTS).map((r) => ({ path: r.path, score: r.score, matches: matchesOf(r.folded.text, r.content, words, ctx) }));
-  return { query, results, total: found.length };
-}
-
 // src/server/rest.ts
 init_message();
 init_hints();
 init_guidance();
 init_requests();
 init_actor();
+init_read_scope();
+init_changeset_checks();
 
 // src/server/token-routes.ts
 init_catalog();
+init_hints();
 var READ_OPERATIONS = new Set(OPERATIONS.filter((o) => o.annotations.readOnlyHint === true).map((o) => o.name));
 var SCHEMA_OPERATIONS = new Set(Object.keys(OPERATION_KIND).filter((op2) => OPERATION_KIND[op2] === "schema"));
 var ROW_WRITES = {
@@ -68095,14 +69096,25 @@ var ROW_WRITES = {
   recompute_columns: ["table"],
   align_relations: ["table"]
 };
+var READ_TABLE_ARGS = {
+  select_rows: ["table"],
+  describe_table: ["table"],
+  check_table: ["table"],
+  infer_table: ["table"],
+  list_link_targets: ["table"],
+  table_changes: ["table"],
+  describe_history: ["table"]
+};
 var OWNER_OPERATIONS = /* @__PURE__ */ new Set(["create_webhook", "delete_webhook"]);
 var READ_ROUTES = /* @__PURE__ */ new Set(["/manual/search/", "/tokens/me/", "/tokens/update/", "/extensions/", "/openapi/", "/openapi.json/", "/sessions/identify/", "/tool-calls/record/"]);
 var OWNER_ADMIN_ROUTES = /* @__PURE__ */ new Set(["/tokens/", "/tokens/create/", "/tokens/update/", "/tokens/delete/", "/tokens/rotate/", "/extensions/record/", "/extensions/delete/", "/status/", "/stop/"]);
+var READ_SCOPE_UNSUPPORTED = "read permissions need Node's AsyncLocalStorage";
+var READ_SCOPE_UNSUPPORTED_HINT = guide(`This token has "read" patterns, which this runtime cannot enforce: run the engine on Node (datanotes serve), or have the owner pass "read": null to tokens/update/ for this token.`, "tokenRead");
 
 // src/server/scheduler.ts
 init_telemetry();
 var FREE_WRITES = /* @__PURE__ */ new Set(["sync_semantic_index"]);
-var FREE_READS = /* @__PURE__ */ new Set(["semantic_search"]);
+var FREE_READS = /* @__PURE__ */ new Set(["semantic_search", "search"]);
 var MAX_WRITES_AHEAD = 8;
 var WRITE_SLOT = { maxMs: 6e4 };
 function operationClass(op2, body = {}) {
@@ -68222,7 +69234,7 @@ var Forbidden = class extends GuidedError {
   }
 };
 var FORBIDDEN_HINT = guide(
-  'Named tokens read everything; writes need a matching "write" pattern, schema changes "ddl": true, maintenance "maintain": true. Ask the owner to update the token (tokens/update/), or use a token that has the permission.',
+  'Named tokens read the tables their "read" patterns name (every table without "read"); writes need a matching "write" pattern, schema changes "ddl": true, maintenance "maintain": true. Ask the owner to update the token (tokens/update/), or use a token that has the permission.',
   "tokens"
 );
 function operationOf(route) {
@@ -68232,7 +69244,7 @@ function operationOf(route) {
 function argumentsGuidance(op2, route) {
   if (op2) return { hint: `Check the arguments of ${op2}: ${argumentsOf(op2)}.`, docs: toolDocs(op2) };
   if (route?.startsWith("/tokens/")) {
-    return guide(`The token routes take {"name"} and, to create or update one, "description" (text), "write" (table patterns), "ddl" and "maintain" (true or false), "autolink" (true or false: the default of its writes for automatic links).`, "manageTokens");
+    return guide(`The token routes take {"name"} and, to create or update one, "description" (text), "read" (table patterns it may read; on update, null for every table), "write" (table patterns it may write, each one readable), "ddl" and "maintain" (true or false), "autolink" (true or false: the default of its writes for automatic links).`, "manageTokens");
   }
   return guide("Check the request's fields against the route in GET /datanotes/openapi.json.", "routes");
 }
@@ -68286,9 +69298,54 @@ function runOpts(body) {
 function kindsArg(body) {
   return strings(body, "kinds")?.map(opOfKind);
 }
-function opResponse(r) {
-  if (r.ok) return { status: 200, json: r };
-  return { status: writeStatus(r.failed.length > 0, r.rolled_back), json: { ...r, ...refusalGuidance(r) } };
+function writeResponse(r, app, settings) {
+  const answer = redactWriteAnswer(r, app, settings);
+  if (r.ok) return { status: 200, json: answer };
+  return { status: writeStatus(r.failed.length > 0, r.rolled_back), json: { ...answer, ...refusalGuidance(answer) } };
+}
+function redactWriteAnswer(r, app, settings) {
+  const scope = currentReadScope();
+  if (!scope) return r;
+  const hidden2 = (path23) => pathHidden(app, settings, path23, scope);
+  const blocked = /* @__PURE__ */ new Set();
+  const keep = (list4, pathOf) => list4.filter((x) => {
+    const p = pathOf(x);
+    if (!hidden2(p)) return true;
+    blocked.add(p);
+    return false;
+  });
+  const conflicts = keep(r.conflicts, (c) => c.path).map((c) => ({ path: c.path, message: c.message }));
+  const violations = keep(r.violations, (v) => v.path).map((v) => ({ path: v.path, violations: v.violations }));
+  const failed2 = keep(r.failed, (f) => f.path).map((f) => ({ path: f.path, error: f.error }));
+  if (blocked.size > 0) {
+    const n = blocked.size;
+    conflicts.push({ path: "", message: `${n} ${n === 1 ? "row" : "rows"} this token may not read ${n === 1 ? "blocks" : "block"} this write` });
+  }
+  const links = r.links_added?.filter((l) => !hidden2(l.path) && !hidden2(l.target)).map((l) => ({ path: l.path, text: l.text, target: l.target, link: l.link }));
+  const mentions = r.ambiguous_mentions?.filter((m) => !hidden2(m.path)).map((m) => ({ path: m.path, text: m.text, reason: m.reason, candidates: m.candidates.filter((c) => !hidden2(c)), context: m.context, hint: m.hint })).filter((m) => m.candidates.length > 0);
+  return {
+    ok: r.ok,
+    op: r.op,
+    dry_run: r.dry_run,
+    ...r.migration_id !== void 0 ? { migration_id: r.migration_id } : {},
+    notes_changed: r.notes_changed,
+    files_created: r.files_created,
+    files_moved: r.files_moved,
+    files_deleted: r.files_deleted,
+    references_updated: r.references_updated,
+    conflicts,
+    violations,
+    failed: failed2,
+    ...r.rolled_back !== void 0 ? { rolled_back: r.rolled_back } : {},
+    planned_edits: r.planned_edits.filter((e) => !hidden2(e.path)).map((e) => ({ path: e.path, set: e.set, remove: e.remove, ...e.body !== void 0 ? { body: e.body } : {} })),
+    planned_creates: r.planned_creates.filter((p) => !hidden2(p)),
+    planned_moves: r.planned_moves.filter((m) => !hidden2(m.from) && !hidden2(m.to)).map((m) => ({ from: m.from, to: m.to })),
+    planned_deletes: r.planned_deletes.filter((p) => !hidden2(p)),
+    planned_texts: [...r.planned_texts],
+    ...r.commits ? { commits: r.commits.filter((c) => tableReadable(c.table, scope)).map((c) => ({ table: c.table, version: c.version, operation: c.operation })) } : {},
+    ...links && links.length > 0 ? { links_added: links } : {},
+    ...mentions && mentions.length > 0 ? { ambiguous_mentions: mentions } : {}
+  };
 }
 function writeStatus(failed2, rolledBack) {
   return !failed2 ? 422 : rolledBack === true ? 503 : 500;
@@ -68300,6 +69357,7 @@ function errorResponse(e, op2, route) {
   if (e instanceof TableNotFoundError) return { status: 404, json: body(guide("list_tables lists the tables and views, with their descriptions and aliases.", "findTable")) };
   if (e instanceof MigrationNotFoundError) return { status: 404, json: body(guide("list_migrations lists the journal ids (migration_id) of the writes, newest first.", "undo")) };
   if (e instanceof VaultPathNotFoundError) return { status: 404, json: body(guide("list_folder lists a folder, search_notes finds notes by their words.", "readNote")) };
+  if (e instanceof ReadDeniedError) return { status: 403, json: body(READ_DENIED_GUIDANCE) };
   if (e instanceof Forbidden) return { status: 403, json: body(FORBIDDEN_HINT) };
   if (e instanceof AmbiguousCatalogRefError) {
     return { status: 409, json: { ...body(guide(`Name the table in full (catalog.schema.table): ${e.candidates.join(" or ")}.`, "catalogs")), tables: e.candidates } };
@@ -68312,6 +69370,26 @@ function errorResponse(e, op2, route) {
 function stepFailure(json3) {
   return Object.assign(new Error(json3.error), guidanceOf(json3));
 }
+function redactBatchRollback(r, app, settings) {
+  const scope = currentReadScope();
+  if (!scope || !r.rollback) return r;
+  const shown = (path23) => !pathHidden(app, settings, path23, scope);
+  return {
+    ok: r.ok,
+    op: r.op,
+    dry_run: r.dry_run,
+    ...r.migration_id !== void 0 ? { migration_id: r.migration_id } : {},
+    steps: r.steps,
+    ...r.failed_at !== void 0 ? { failed_at: r.failed_at } : {},
+    ...r.rolled_back !== void 0 ? { rolled_back: r.rolled_back } : {},
+    rollback: r.rollback.map((u) => ({
+      migration_id: u.migration_id,
+      ok: u.ok,
+      conflicts: u.conflicts.filter((c) => shown(c.path)).map((c) => ({ path: c.path, message: c.message })),
+      failed: u.failed.filter((f) => shown(f.path)).map((f) => ({ path: f.path, error: f.error }))
+    }))
+  };
+}
 function batchGuidance(r) {
   if (r.dry_run) return guide("Fix the operations marked refused, then send the batch again (dry_run checks each one against the vault as it is now).", "batch");
   if (r.rolled_back === false) return guide('Some operations could not be undone: "rollback" lists them; undo them with undo_migration, or repair the rows, before you retry.', "batch");
@@ -68356,6 +69434,7 @@ function checkArgs(op2, args) {
 function createHandlers(app, getSettings, saveSettings = async () => {
 }, semantic, api, options = {}) {
   const s = getSettings;
+  const opResponse = (r) => writeResponse(r, app, s());
   const pub = api ?? createPublicApi(app, getSettings, saveSettings, semantic);
   const needSemantic = () => {
     if (!semantic) throw new BadRequest("semantic search is not available", SEMANTIC_OFF);
@@ -68713,7 +69792,8 @@ function createHandlers(app, getSettings, saveSettings = async () => {
       });
       const failedStep = r.failed_at !== void 0 && (r.steps[r.failed_at]?.result?.failed.length ?? 0) > 0;
       const status = r.ok ? 200 : r.rolled_back === false ? 500 : writeStatus(failedStep, true);
-      return { status, json: r.ok ? r : { ...r, ...batchGuidance(r) } };
+      const answer = redactBatchRollback(r, app, s());
+      return { status, json: answer.ok ? answer : { ...answer, ...batchGuidance(answer) } };
     },
     // --- queries ---
     select_rows: async (b) => {
@@ -68758,10 +69838,10 @@ function createHandlers(app, getSettings, saveSettings = async () => {
       };
     },
     read_note: async (b) => ({ status: 200, json: await readNote(app, s(), text3(b, "path")) }),
-    list_folder: async (b) => ({ status: 200, json: listFolder(app, text3(b, "folder") ?? "") }),
+    list_folder: async (b) => ({ status: 200, json: listFolder(app, text3(b, "folder") ?? "", s()) }),
     search_notes: async (b) => {
       const ctx = optInt(b, "context_length");
-      return { status: 200, json: await searchNotes(app, str(b, "query"), ctx ?? 100) };
+      return { status: 200, json: await searchNotes(app, str(b, "query"), ctx ?? 100, s()) };
     },
     semantic_search: async (b) => {
       const sem = needSemantic();
@@ -68778,6 +69858,20 @@ function createHandlers(app, getSettings, saveSettings = async () => {
         })
       };
     },
+    search: async (b) => {
+      const limit = optInt(b, "limit");
+      const minScore = b.min_score;
+      return {
+        status: 200,
+        json: await searchVault(app, s(), {
+          query: str(b, "query"),
+          ...limit !== void 0 ? { limit } : {},
+          ...strings(b, "tables") ? { tables: strings(b, "tables") } : {},
+          ...str(b, "folder") !== void 0 ? { folder: str(b, "folder") } : {},
+          ...typeof minScore === "number" ? { minScore } : {}
+        }, semantic)
+      };
+    },
     graph_neighbors: async (b) => ({
       status: 200,
       json: await graphNeighbors(app, s(), {
@@ -69161,10 +70255,12 @@ var STATUS_TEXT = {
   404: "Unknown table, view, migration, note or folder.",
   409: "Ambiguous table name: it matches several tables (`paths` or `tables` lists them)."
 };
+var READ_DENIED_TEXT = "A named token whose `read` patterns do not cover the table, view or note the request names (such as `token cook may not read personal.health.weight`). Sets it did not name (listings, bases, search, the graph, the change feed) are filtered instead.";
 var ERRORS = {
   400: { description: STATUS_TEXT[400], content: json(ref("Error")) },
   401: { $ref: "#/components/responses/Unauthorized" },
   403: { description: STATUS_TEXT[403], content: json(ref("Error")) },
+  readDenied: { description: READ_DENIED_TEXT, content: json(ref("Error")) },
   404: { description: STATUS_TEXT[404], content: json(ref("Error")) },
   409: { description: STATUS_TEXT[409], content: json(ref("AmbiguousName")) },
   500: { $ref: "#/components/responses/ServerError" }
@@ -69174,6 +70270,7 @@ function postRoute(d) {
   const op2 = operationOf(d.route);
   const read3 = op2 !== void 0 ? READ_OPERATIONS.has(op2) : READ_ROUTES.has(d.route) && d.route !== "/tokens/update/";
   if (!read3) responses["403"] = ERRORS[403];
+  else if (op2 !== void 0) responses["403"] = ERRORS.readDenied;
   if (d.namesTable) responses["404"] = ERRORS[404];
   const refused2 = op2 !== void 0 ? refusedStatus(op2) : void 0;
   if (refused2 === 409) {
@@ -69213,6 +70310,7 @@ var TOKEN_ROUTES = {
       properties: {
         name: { type: "string", pattern: "^[a-z0-9][a-z0-9-]*$", description: "Kebab-case; the journal records it as `auth`. `owner` is reserved." },
         description: { type: "string" },
+        read: { type: "array", items: { type: "string" }, description: "Tables the token may read, as patterns like `write`'s. Absent (or with `*`): every table. It must cover every `write` pattern, and stay absent with `ddl` or `maintain` (400 otherwise)." },
         write: { type: "array", items: { type: "string" }, description: "Tables the token may write: catalog.schema.table, catalog.schema.*, catalog.* or *." },
         ddl: { type: "boolean", description: "May the token change the schema?" },
         maintain: { type: "boolean", description: "May the token also undo, restore, vacuum, configure and rebuild the semantic index? (For an agent's own token.)" },
@@ -69223,12 +70321,13 @@ var TOKEN_ROUTES = {
     writes: true
   },
   "/tokens/update/": {
-    summary: "Change a named token. A token may change its own description and autolink default; permissions are the owner's.",
+    summary: "Change a named token. A token may change its own description and autolink default; permissions (`read`, `write`, `ddl`, `maintain`) are the owner's.",
     body: {
       type: "object",
       properties: {
         name: { type: "string", description: "Owner only (a named token updates itself)." },
         description: { type: "string", description: "An empty string removes it." },
+        read: { type: ["array", "null"], items: { type: "string" }, description: "The tables the token may read; null reads every table again. Checked against `write`, `ddl` and `maintain` as on create." },
         write: { type: "array", items: { type: "string" } },
         ddl: { type: "boolean" },
         maintain: { type: "boolean" },
@@ -69402,11 +70501,12 @@ var SCHEMAS = {
   Token: {
     type: "object",
     description: "A named token as the registry shows it (never its value).",
-    required: ["name", "write", "ddl", "created_at", "updated_at"],
+    required: ["name", "write", "read", "ddl", "created_at", "updated_at"],
     properties: {
       name: { type: "string" },
       description: { type: "string" },
       write: { type: "array", items: { type: "string" } },
+      read: { type: "array", items: { type: "string" }, description: 'The tables it may read (patterns like `write`\'s); `["*"]` when it reads every table.' },
       ddl: { type: "boolean" },
       maintain: { type: "boolean" },
       autolink: { type: "boolean", description: "The default of its writes for automatic links (absent: the database's setting)." },
@@ -69657,7 +70757,7 @@ function openApiDocument(version2) {
     info: {
       title: "Datanotes",
       version: version2,
-      description: "Database of Markdown notes: tables of notes, rows, queries, history, a change feed and the vault's notes.\n\n**Operations**: every operation is `POST /datanotes/operations/<name>/`, its body the operation's arguments (the same names as the MCP tool of the same name). An unknown argument is refused (400) with the closest real one.\n\n**Authentication**: every route but `GET /`, this document and `/datanotes/docs` needs `Authorization: Bearer <token>`: the owner's token (`httpServerToken` in the settings: everything) or a named token (`/datanotes/tokens/create/`: reads everything; writes the tables in its `write` patterns, changes the schema with `ddl`; the engine's administration stays the owner's: 403 otherwise).\n\n**Actor**: send `X-Datanotes-Actor: {\"harness\": \u2026, \"model\": \u2026, \"session\": \u2026}` (JSON) to record on whose behalf a write is made; the journal adds the credential (`auth`: `owner`, or the named token's name), which the client cannot claim.\n\n**Errors**: `{error}` with 400 (bad input), 401 (missing or wrong token), 403 (a named token beyond its permissions), 404 (unknown table, view, migration or note), 409 (ambiguous table name), 500. A refused write answers 422 (409 for undo) with the operation's result, `ok: false`: nothing was written."
+      description: "Database of Markdown notes: tables of notes, rows, queries, history, a change feed and the vault's notes.\n\n**Operations**: every operation is `POST /datanotes/operations/<name>/`, its body the operation's arguments (the same names as the MCP tool of the same name). An unknown argument is refused (400) with the closest real one.\n\n**Authentication**: every route but `GET /`, this document and `/datanotes/docs` needs `Authorization: Bearer <token>`: the owner's token (`httpServerToken` in the settings: everything) or a named token (`/datanotes/tokens/create/`: reads the tables in its `read` patterns, every table without them; writes the tables in its `write` patterns, changes the schema with `ddl`; the engine's administration stays the owner's: 403 otherwise).\n\n**Actor**: send `X-Datanotes-Actor: {\"harness\": \u2026, \"model\": \u2026, \"session\": \u2026}` (JSON) to record on whose behalf a write is made; the journal adds the credential (`auth`: `owner`, or the named token's name), which the client cannot claim.\n\n**Errors**: `{error}` with 400 (bad input), 401 (missing or wrong token), 403 (a named token beyond its permissions, or a read of a table outside its `read` patterns), 404 (unknown table, view, migration or note), 409 (ambiguous table name), 500. A refused write answers 422 (409 for undo) with the operation's result, `ok: false`: nothing was written."
     },
     servers: [{ url: "/" }],
     tags: [
@@ -69691,6 +70791,7 @@ function openApiDocument(version2) {
 init_message();
 init_hints();
 init_docs();
+init_read_scope();
 var ListenError = class extends GuidedError {
   constructor(message, code, g) {
     super(message, g);
@@ -70000,7 +71101,7 @@ var HttpApiServer = class {
       "gen_ai.tool.name": actor.tool
     });
     if (method === "GET" && (path23 === `${ROUTE_PREFIX2}/changes/stream` || path23 === `${ROUTE_PREFIX2}/changes/stream/`)) {
-      await this.stream(req, res, url);
+      await this.stream(req, res, url, named ? this.opts.readScopeOf?.(named.name) ?? null : null);
       return;
     }
     if (method === "GET" && (path23 === MANUAL_PATH || path23.startsWith(`${MANUAL_PATH}/`))) {
@@ -70061,7 +71162,11 @@ var HttpApiServer = class {
    * `where`: JSON).
    * A comment line every 25 s keeps proxies from closing the connection.
    */
-  async stream(req, res, url) {
+  async stream(req, res, url, scope) {
+    if (scope && !(this.opts.readScopeSupported ?? READ_SCOPE_SUPPORTED)) {
+      send2(res, 503, { error: READ_SCOPE_UNSUPPORTED, ...READ_SCOPE_UNSUPPORTED_HINT });
+      return;
+    }
     const feed = this.opts.changeFeed?.();
     if (!feed || !res.write) {
       send2(res, 503, { error: "the change feed is not available", ...guide("The change feed runs while the engine follows the vault (datanotes serve); list_changes reads it.", "changeFeed") });
@@ -70099,7 +71204,7 @@ var HttpApiServer = class {
 `);
     try {
       while (open2 && this.server && !this.draining) {
-        const page2 = await feed.wait({ ...q, since: cursor, limit: 500 }, 2e4);
+        const page2 = await feed.wait({ ...q, since: cursor, limit: 500 }, 2e4, scope);
         if (!open2) break;
         if (page2.gap) res.write(`event: gap
 data: {"since":${cursor}}
@@ -70265,6 +71370,8 @@ init_actor();
 init_redact();
 
 // src/server/webhooks.ts
+init_metastore();
+init_read_scope();
 init_store();
 init_telemetry();
 init_message();
@@ -70360,8 +71467,16 @@ var WebhookDispatcher = class {
     if (this.saveTimer) await this.save();
     await this.saving;
   }
+  /**
+   * The webhooks, as the read scope of the request sees them: a restricted token (one with `read`
+   * patterns) sees only the webhooks on tables it may all read, never one on every table.
+   */
   list() {
-    return this.hooks.map(publicView);
+    const scope = currentReadScope();
+    if (!scope) return this.hooks.map(publicView);
+    const model = cachedMetastore(this.app, this.getSettings());
+    const full = (t) => (model ? rowTableFull(model, t) : null) ?? t;
+    return this.hooks.filter((h) => (h.tables ?? []).length > 0 && h.tables.every((t) => tableReadable(full(t), scope))).map(publicView);
   }
   async create(input) {
     if (!/^https?:\/\//i.test(input.url)) throw new Error(`"url" must be an http(s) URL`);
@@ -70451,7 +71566,7 @@ var WebhookDispatcher = class {
         continue;
       }
       const q = { since: h.cursor, limit: BATCH, ...h.tables ? { tables: h.tables } : {}, ...h.ops ? { ops: h.ops } : {}, ...h.columns ? { columns: h.columns } : {}, ...h.excludeActor ? { excludeActor: h.excludeActor } : {}, ...h.where ? { where: h.where } : {} };
-      const page2 = await feed.wait(q, WAIT_MS);
+      const page2 = await feed.wait(q, WAIT_MS, null);
       if (!this.alive(h)) return;
       if (page2.events.length === 0 && !page2.gap) {
         if (page2.last !== h.cursor) {
@@ -70621,7 +71736,7 @@ async function engineStatus(i) {
         cursor: w.cursor
       }))
     },
-    tokens: i.tokens.map((t) => ({ name: t.name, write: t.write, ddl: t.ddl, maintain: t.maintain === true, last_seen: t.last_seen ?? null })),
+    tokens: i.tokens.map((t) => ({ name: t.name, ...t.read.includes("*") ? {} : { read: t.read }, write: t.write, ddl: t.ddl, maintain: t.maintain === true, last_seen: t.last_seen ?? null })),
     hand_edits: handEdits,
     logs: {
       folder: s.fileLogEnabled ? i.host?.store ? `${i.host.store}${i.host.store.includes("\\") ? "\\" : "/"}logs` : storePath("logs") : null,
@@ -70633,13 +71748,14 @@ async function engineStatus(i) {
 
 // src/server/tokens.ts
 init_actor();
+init_read_scope();
 init_metastore();
 init_store();
 init_telemetry();
 init_message();
 init_hints();
 var FILE = "tokens.json";
-var NAME = /^[a-z0-9][a-z0-9-]{0,62}$/;
+var NAME2 = /^[a-z0-9][a-z0-9-]{0,62}$/;
 var RESERVED_NAMES = /* @__PURE__ */ new Set(["owner"]);
 var SEEN_SAVE_MS = 6e4;
 async function sha256Hex(text5) {
@@ -70647,11 +71763,13 @@ async function sha256Hex(text5) {
   return [...d].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function tableAllowed(full, patterns) {
-  return patterns.some((p) => {
-    if (p === "*") return true;
-    if (p.endsWith(".*")) return full.startsWith(p.slice(0, -1));
-    return p === full;
-  });
+  return matchesTablePattern(full, patterns);
+}
+function scopeOf(t) {
+  return t.read === void 0 || t.read.includes("*") ? null : { token: t.name, patterns: t.read };
+}
+function readCovers(r, w) {
+  return r === "*" || r === w || r.endsWith(".*") && w.startsWith(r.slice(0, -1));
 }
 function tokenNameOf(actor) {
   const auth = actor?.auth;
@@ -70711,6 +71829,7 @@ var TokenRegistry = class {
     return {
       name: t.name,
       ...t.description !== void 0 ? { description: t.description } : {},
+      read: t.read ?? ["*"],
       write: t.write,
       ddl: t.ddl,
       ...t.maintain !== void 0 ? { maintain: t.maintain } : {},
@@ -70741,7 +71860,7 @@ var TokenRegistry = class {
   }
   async create(input) {
     await this.load();
-    if (!NAME.test(input.name)) throw new BadRequest(`"name" must be kebab-case (a-z, 0-9, -)`);
+    if (!NAME2.test(input.name)) throw new BadRequest(`"name" must be kebab-case (a-z, 0-9, -)`);
     if (RESERVED_NAMES.has(input.name)) throw new BadRequest(`"${input.name}" is reserved (the owner's token)`);
     if (this.get(input.name)) throw new BadRequest(`token ${input.name} already exists (update it, or delete it first)`);
     const token = newToken();
@@ -70750,13 +71869,15 @@ var TokenRegistry = class {
       name: input.name,
       ...input.description ? { description: input.description } : {},
       tokenHash: await sha256Hex(token),
-      write: checkPatterns(input.write ?? []),
+      ...input.read !== void 0 ? { read: readPatterns(input.read) } : {},
+      write: checkPatterns(input.write ?? [], "write"),
       ddl: input.ddl === true,
       ...input.maintain === true ? { maintain: true } : {},
       ...input.autolink !== void 0 ? { autolink: input.autolink } : {},
       createdAt: now,
       updatedAt: now
     };
+    checkReadCoversPermissions(t);
     this.tokens.push(t);
     this.reindex();
     await this.save();
@@ -70765,24 +71886,31 @@ var TokenRegistry = class {
   }
   /**
    * Change a token. `self` (a token updating its own entry) may change its description and its
-   * `autolink` default; permissions are the owner's. `autolink: null` follows the database again.
+   * `autolink` default; permissions are the owner's. `autolink: null` follows the database again,
+   * `read: null` reads every table again. Nothing changes when the token as changed would be refused.
    */
   async update(name, patch, self) {
     await this.load();
     const t = this.get(name);
     if (!t) throw new BadRequest(`no token ${name}`);
-    if (self && (patch.write !== void 0 || patch.ddl !== void 0 || patch.maintain !== void 0)) throw new Forbidden("a token cannot change its own permissions");
+    if (self && (patch.read !== void 0 || patch.write !== void 0 || patch.ddl !== void 0 || patch.maintain !== void 0)) throw new Forbidden("a token cannot change its own permissions");
+    const next = { ...t };
     if (patch.description !== void 0) {
-      if (patch.description === "") delete t.description;
-      else t.description = patch.description;
-    }
-    if (patch.write !== void 0) t.write = checkPatterns(patch.write);
-    if (patch.ddl !== void 0) t.ddl = patch.ddl;
-    if (patch.maintain === true) t.maintain = true;
-    else if (patch.maintain === false) delete t.maintain;
-    if (patch.autolink === null) delete t.autolink;
-    else if (patch.autolink !== void 0) t.autolink = patch.autolink;
-    t.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (patch.description === "") delete next.description;
+      else next.description = patch.description;
+    }
+    if (patch.read === null) delete next.read;
+    else if (patch.read !== void 0) next.read = readPatterns(patch.read);
+    if (patch.write !== void 0) next.write = checkPatterns(patch.write, "write");
+    if (patch.ddl !== void 0) next.ddl = patch.ddl;
+    if (patch.maintain === true) next.maintain = true;
+    else if (patch.maintain === false) delete next.maintain;
+    if (patch.autolink === null) delete next.autolink;
+    else if (patch.autolink !== void 0) next.autolink = patch.autolink;
+    checkReadCoversPermissions(next);
+    next.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const k of Object.keys(t)) if (!(k in next)) delete t[k];
+    Object.assign(t, next);
     await this.save();
     return this.publicView(t);
   }
@@ -70807,7 +71935,10 @@ var TokenRegistry = class {
     return token;
   }
   // --- permissions ---------------------------------------------------------------------------
-  /** Why this token may not run this route with this body, or null when it may. */
+  /**
+   * Why this token may not run this route with this body, or null when it may: the reason of a
+   * refused write or route, or the refusal of a read (the same error the engine's read sites throw).
+   */
   async check(name, route, body) {
     const t = this.get(name);
     if (!t) return "unknown token";
@@ -70818,8 +71949,8 @@ var TokenRegistry = class {
   }
   /** Why this token may not run this operation with these arguments, or null when it may. */
   async checkOperation(t, op2, body) {
-    if (READ_OPERATIONS.has(op2)) return null;
     const b = body && typeof body === "object" ? body : {};
+    if (READ_OPERATIONS.has(op2)) return this.checkRead(t, op2, b);
     if (op2 === "batch") {
       const steps = Array.isArray(b.operations) ? b.operations : [];
       for (const [i, raw] of steps.entries()) {
@@ -70842,20 +71973,44 @@ var TokenRegistry = class {
     }
     return null;
   }
-  /** Wrap a dispatcher: calls made with a named token are checked first. */
+  /**
+   * The refusal of a read whose arguments name a table the token may not read, or null. Only names
+   * that resolve to a table are checked here (a view, `base:x`, the system catalog or an unknown
+   * name pass): the engine's read sites decide the rest while the request runs in the token's scope.
+   */
+  async checkRead(t, op2, b) {
+    const scope = scopeOf(t);
+    if (!scope) return null;
+    const names2 = (Object.prototype.hasOwnProperty.call(READ_TABLE_ARGS, op2) ? READ_TABLE_ARGS[op2] : []).map((k) => b[k]);
+    if ((op2 === "semantic_search" || op2 === "search") && Array.isArray(b.tables)) names2.push(...b.tables.filter((x) => typeof x === "string" && !x.includes("*")));
+    if (!names2.some((n) => typeof n === "string")) return null;
+    const model = (await loadMetastore(this.deps.app, this.deps.getSettings()).catch(() => null))?.model ?? null;
+    if (!model) return null;
+    for (const ref2 of names2) {
+      const full = rowTableFull(model, ref2);
+      if (full !== null && !matchesTablePattern(full, scope.patterns)) return tableReadDenied(t.name, full);
+    }
+    return null;
+  }
+  /** Wrap a dispatcher: calls made with a named token are checked first, and run in its read scope. */
   guard(dispatch2) {
     return async (route, handler, body) => {
       const name = tokenNameOf(currentActor());
-      if (name) {
-        const why = await this.check(name, route, body);
-        if (why) {
-          telemetry().log("WARN", "datanotes token refused", { token_name: name, "http.route": route, reason: why });
-          return { status: 403, json: { error: why, ...FORBIDDEN_HINT } };
-        }
-        const autolink = this.get(name)?.autolink;
-        if (autolink !== void 0) body = withAutolinkDefault(route, body, autolink);
-      }
-      return dispatch2(route, handler, body);
+      if (!name) return dispatch2(route, handler, body);
+      const why = await this.check(name, route, body);
+      if (why) {
+        const reason = typeof why === "string" ? why : why.message;
+        telemetry().log("WARN", "datanotes token refused", { token_name: name, "http.route": route, reason });
+        return typeof why === "string" ? { status: 403, json: { error: why, ...FORBIDDEN_HINT } } : errorResponse(why);
+      }
+      const token = this.get(name);
+      if (token.autolink !== void 0) body = withAutolinkDefault(route, body, token.autolink);
+      const scope = scopeOf(token);
+      if (scope && !(this.deps.readScopeSupported ?? READ_SCOPE_SUPPORTED)) {
+        telemetry().log("WARN", "datanotes token refused", { token_name: name, "http.route": route, reason: READ_SCOPE_UNSUPPORTED });
+        return { status: 503, json: { error: READ_SCOPE_UNSUPPORTED, ...READ_SCOPE_UNSUPPORTED_HINT } };
+      }
+      return runWithReadScope(scope, () => dispatch2(route, handler, body));
     };
   }
   // --- routes --------------------------------------------------------------------------------
@@ -70871,6 +72026,7 @@ var TokenRegistry = class {
       if (!Array.isArray(v) || v.some((x) => typeof x !== "string")) throw new BadRequest(`"${k}" must be a list of strings`);
       return v;
     };
+    const strListOrNull = (b, k) => b[k] === null ? null : strList(b, k);
     const optStr = (b, k) => {
       const v = b[k];
       if (v === void 0 || v === null) return void 0;
@@ -70900,10 +72056,12 @@ var TokenRegistry = class {
         ownerOnly();
         const autolink = optAutolink(b, false);
         const description = optStr(b, "description");
+        const read3 = strList(b, "read");
         const write = strList(b, "write");
         const r = await this.create({
           name: optStr(b, "name") ?? "",
           ...description !== void 0 ? { description } : {},
+          ...read3 ? { read: read3 } : {},
           ...write ? { write } : {},
           ...b.ddl === true ? { ddl: true } : {},
           ...b.maintain === true ? { maintain: true } : {},
@@ -70915,10 +72073,12 @@ var TokenRegistry = class {
         const self = !!caller();
         for (const k of ["ddl", "maintain"]) if (b[k] !== void 0 && typeof b[k] !== "boolean") throw new BadRequest(`"${k}" must be true or false`);
         const description = optStr(b, "description");
+        const read3 = strListOrNull(b, "read");
         const write = strList(b, "write");
         const autolink = optAutolink(b, true);
         const patch = {
           ...description !== void 0 ? { description } : {},
+          ...read3 !== void 0 ? { read: read3 } : {},
           ...write !== void 0 ? { write } : {},
           ...typeof b.ddl === "boolean" ? { ddl: b.ddl } : {},
           ...typeof b.maintain === "boolean" ? { maintain: b.maintain } : {},
@@ -70966,12 +72126,28 @@ function optAutolink(b, nullable2) {
     )
   );
 }
-function checkPatterns(patterns) {
+function checkPatterns(patterns, field3) {
   for (const p of patterns) {
-    if (!/^(\*|[\w-]+(\.[\w-]+){0,2}(\.\*)?)$/.test(p)) throw new BadRequest(`write pattern "${p}" must be a table name, catalog.schema.*, catalog.* or *`);
+    if (!/^(\*|[\w-]+(\.[\w-]+){0,2}(\.\*)?)$/.test(p)) {
+      throw new BadRequest(`${field3} pattern "${p}" must be a table name, catalog.schema.*, catalog.* or *`, field3 === "read" ? guide(`Write each read pattern as catalog.schema.table, catalog.schema.*, catalog.* or *; list_tables gives the full names.`, "tokenRead") : void 0);
+    }
   }
   return [...new Set(patterns)];
 }
+function readPatterns(patterns) {
+  const read3 = checkPatterns(patterns, "read");
+  return read3.includes("*") ? ["*"] : read3;
+}
+function checkReadCoversPermissions(t) {
+  const read3 = t.read;
+  if (read3 === void 0 || read3.includes("*")) return;
+  if (t.ddl || t.maintain === true) {
+    throw new BadRequest(`token ${t.name}: "ddl" and "maintain" need read on every table`, guide(`Leave "read" out (or pass ["*"]) for a token with ddl or maintain, or turn them off.`, "tokenRead"));
+  }
+  for (const w of t.write) {
+    if (!read3.some((r) => readCovers(r, w))) throw new BadRequest(`token ${t.name} writes ${w} but may not read it`, guide(`Add "${w}" (or a wider pattern) to "read": a write answers with the rows it touches.`, "tokenRead"));
+  }
+}
 
 // src/server/extensions.ts
 init_actor();
@@ -71076,6 +72252,7 @@ var ExtensionRegistry = class {
 
 // src/server/read-cache.ts
 init_metastore();
+init_query_tables();
 init_file_cache();
 init_vault_index();
 var CACHED_READS = /* @__PURE__ */ new Set([
@@ -71094,7 +72271,6 @@ var CACHED_READS = /* @__PURE__ */ new Set([
 ]);
 var GRAPH_READS = /* @__PURE__ */ new Set(["graph_neighbors", "graph_traverse", "graph_path"]);
 var SECRET_SETTINGS = /* @__PURE__ */ new Set(["httpServerToken", "telemetryHeaders", "storeBackupRemote"]);
-var PLAIN_SELECT_KEYS = /* @__PURE__ */ new Set(["table", "columns", "where", "order_by", "limit", "offset", "group_by", "aggregates", "include_body", "join", "union"]);
 var TODAY_BUCKET_MS = 15 * 6e4;
 function pathKey(path23) {
   return path23.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").normalize("NFC").toLowerCase();
@@ -71376,8 +72552,8 @@ function readDeps(op2, body, model) {
     return { tables: "vault", today: today || r.today || views.today };
   }
   if (op2 === "describe_table" && model && typeof body.table === "string") {
-    const ref2 = refOf3(model, body.table, "table");
-    if (ref2 && !refOf3(model, body.table, "view")) return { tables: [ref2], today };
+    const ref2 = refOf2(model, body.table, "table");
+    if (ref2 && !refOf2(model, body.table, "view")) return { tables: [ref2], today };
   }
   if (op2 === "list_tables") return { tables: [], today };
   if (op2 === "describe_database" && model) return { tables: catalogTables(model).map(({ ref: ref2 }) => ref2.full), today, loose: true };
@@ -71386,111 +72562,6 @@ function readDeps(op2, body, model) {
   if (GRAPH_READS.has(op2) && model) return { tables: catalogTables(model).map(({ ref: ref2 }) => ref2.full).sort(), today, links: true };
   return { tables: "vault", today };
 }
-function refOf3(model, name, kind) {
-  try {
-    return resolveCatalogRef(model, name, kind)?.full ?? null;
-  } catch {
-    return null;
-  }
-}
-function isSystemTable(name) {
-  const t = name.trim();
-  if (t.startsWith(`${SYSTEM_CATALOG}.`)) return true;
-  const parts = t.split(".");
-  return parts.length === 2 && parts[0] === "information_schema";
-}
-var DOTTED_KEY = /"[^"]*\.[^"]*"\s*:/;
-function queryTables(q, model, out2, depth) {
-  const text5 = JSON.stringify(q);
-  const r = { vault: false, today: text5.includes("{today"), now: text5.includes("{now") };
-  if (depth > 8) return { ...r, vault: true };
-  if (text5.includes("within") || text5.includes("{this")) r.vault = true;
-  if (DOTTED_KEY.test(text5) && !linkedTables(q, model, out2)) r.vault = true;
-  if (text5.includes("file_backlink_count")) r.links = true;
-  if (Object.keys(q).some((k) => !PLAIN_SELECT_KEYS.has(k))) r.vault = true;
-  const sources = [q.table];
-  if (q.join && typeof q.join === "object") sources.push(q.join.table);
-  if (Array.isArray(q.union)) for (const b of q.union) sources.push(b && typeof b === "object" ? b.table : void 0);
-  for (const name of sources) {
-    if (typeof name === "string" && isSystemTable(name)) {
-      r.store = true;
-      continue;
-    }
-    if (typeof name !== "string" || name.startsWith("base:")) {
-      r.vault = true;
-      continue;
-    }
-    const table = refOf3(model, name, "table");
-    const view = refOf3(model, name, "view");
-    if (!table && !view) r.vault = true;
-    if (table) out2.add(table);
-    const v = view ? viewQuery(model, view) : null;
-    if (view && !v) r.vault = true;
-    if (v) {
-      const sub = queryTables(v, model, out2, depth + 1);
-      r.vault ||= sub.vault;
-      r.links ||= sub.links;
-      r.store ||= sub.store;
-      r.today ||= sub.today;
-      r.now ||= sub.now;
-    }
-  }
-  return r;
-}
-var isRecord2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
-function plainTable(model, name) {
-  return typeof name === "string" && !refOf3(model, name, "view") ? refOf3(model, name, "table") : null;
-}
-function linkedTables(q, model, out2) {
-  const join = isRecord2(q.join) ? q.join : null;
-  const branches = Array.isArray(q.union) ? q.union : null;
-  const rest = {
-    ...q,
-    where: void 0,
-    join: join ? { ...join, where: void 0 } : q.join,
-    union: branches ? branches.map((b) => isRecord2(b) ? { ...b, where: void 0 } : b) : q.union
-  };
-  if (DOTTED_KEY.test(JSON.stringify(rest))) return false;
-  const roots = branches ? branches.map((b) => isRecord2(b) ? plainTable(model, b.table) : null) : [plainTable(model, q.table)];
-  if (roots.length === 0) return false;
-  for (const table of roots) if (!followKeys(q.where, table, model, out2)) return false;
-  if (join && !followKeys(join.where, plainTable(model, join.table), model, out2)) return false;
-  for (const b of branches ?? []) if (isRecord2(b) && !followKeys(b.where, plainTable(model, b.table), model, out2)) return false;
-  return true;
-}
-function followKeys(where, table, model, out2) {
-  if (where === null || typeof where !== "object") return true;
-  if (Array.isArray(where)) return where.every((w) => followKeys(w, table, model, out2));
-  for (const [key2, cond] of Object.entries(where)) {
-    if (key2 === "and" || key2 === "or" || key2 === "not") {
-      if (!followKeys(cond, table, model, out2)) return false;
-    } else if (key2.indexOf(".") > 0 && (table === null || !followPath(key2, table, model, out2))) return false;
-  }
-  return true;
-}
-function followPath(key2, table, model, out2) {
-  let current2 = table;
-  for (const column of key2.split(".").slice(0, -1)) {
-    const next = linkTarget(model, current2, column);
-    if (!next) return false;
-    out2.add(next);
-    current2 = next;
-  }
-  return true;
-}
-function linkTarget(model, full, column) {
-  const t = catalogTables(model).find((x) => x.ref.full === full);
-  if (!t) return null;
-  let columns;
-  try {
-    columns = effectiveColumns(model, t.ref, t.entry);
-  } catch {
-    return null;
-  }
-  const c = columns.find((x) => x.name === column);
-  const link = c !== void 0 && (c.type === "link" || c.type === "list" && c.items === "link");
-  return link && typeof c.ref === "string" ? refOf3(model, c.ref, "table") : null;
-}
 var VIEW_TIMES = /* @__PURE__ */ new WeakMap();
 function viewTimes(model) {
   let t = VIEW_TIMES.get(model);
@@ -71500,11 +72571,6 @@ function viewTimes(model) {
   }
   return t;
 }
-function viewQuery(model, full) {
-  const [catalog, schema, name] = full.split(".");
-  const q = model.catalogs[catalog]?.schemas[schema]?.views[name]?.query;
-  return q && typeof q === "object" ? q : null;
-}
 
 // src/server/runtime.ts
 init_message();
@@ -71848,6 +72914,11 @@ var EngineRuntime = class {
       ...this.o.httpHost ? { host: this.o.httpHost } : {},
       changeFeed: () => this.feed,
       tokens: this.tokens,
+      // the change stream's events, as the token may read them (a token gone since: nothing)
+      readScopeOf: (name) => {
+        const t = this.tokens.get(name);
+        return t ? scopeOf(t) : { token: name, patterns: [] };
+      },
       dispatch: guarded,
       ...this.o.docs ? { docs: this.o.docs } : {},
       compression: () => this.o.getSettings().httpCompression
@@ -71899,7 +72970,7 @@ var EngineRuntime = class {
     const name = tokenNameOf(currentActor());
     if (!name) return "owner";
     const t = this.tokens.get(name);
-    return JSON.stringify([name, t?.write ?? null, t?.ddl ?? null, t?.maintain ?? null, t?.autolink ?? null]);
+    return JSON.stringify([name, t?.write ?? null, t?.ddl ?? null, t?.maintain ?? null, t?.autolink ?? null, t?.read ?? null]);
   }
   /** Follow the vault (call once the vault is indexed: Obsidian's layout-ready, or after opening). */
   async start(opts = {}) {
@@ -72987,7 +74058,7 @@ function relativePath(fromDir2, to) {
   while (i < a.length && i < b.length - 1 && a[i] === b[i]) i++;
   return [...a.slice(i).map(() => ".."), ...b.slice(i)].join("/");
 }
-function linkText(resolver, path23, sourcePath, format, omitMd = true) {
+function linkText2(resolver, path23, sourcePath, format, omitMd = true) {
   const target = omitMd && /\.md$/i.test(path23) ? stripMd(path23) : path23;
   if (format === "absolute") return target;
   if (format === "relative") return relativePath(dirname2(sourcePath), target);
@@ -75149,7 +76220,7 @@ var NodeMetadataCache = class {
     return f && "extension" in f ? f : null;
   }
   fileToLinktext(file, sourcePath, omitMdExtension = true) {
-    return linkText(this.resolver, file.path, sourcePath, this.vault.config.newLinkFormat, omitMdExtension);
+    return linkText2(this.resolver, file.path, sourcePath, this.vault.config.newLinkFormat, omitMdExtension);
   }
   on(name, cb) {
     this.events.on(name, cb);
@@ -75251,7 +76322,7 @@ var NodeFileManager = class {
       src,
       resolveOld,
       moved,
-      (dest, s) => linkText(newResolver, dest, s, format, true),
+      (dest, s) => linkText2(newResolver, dest, s, format, true),
       oldSrc,
       (lp, s) => newResolver.resolve(lp, s)
     ).text;
@@ -76145,7 +77216,7 @@ function setUp(o, vault, home, explicit, self) {
 // src/node/service.ts
 init_local();
 init_hints();
-var VERSION = true ? "3.3.1" : "dev";
+var VERSION = true ? "3.4.0" : "dev";
 function parsePort(raw, from = "--port") {
   const n = /^\s*\d+\s*$/.test(raw) ? Number(raw) : NaN;
   if (n === 0 || Number.isInteger(n) && n >= 1024 && n <= 65535) return n;
@@ -76660,7 +77731,8 @@ ${"error".padEnd(11)}${r.error}`;
   line("changes", f.running ? `feed running, last seq ${f.head}` : `feed NOT RUNNING: ${f.reason}`);
   line("webhooks", `${r.webhooks.count}${r.webhooks.failing.length ? ` (${r.webhooks.failing.length} failing)` : ""}`);
   for (const w of r.webhooks.failing) out2.push(`  ! ${w.id} ${w.url_host}: ${plural(w.failures, "failed attempt")}, retried with backoff${w.last_error ? `; last error: ${w.last_error}` : ""}`);
-  const perms = (t) => [t.write.length ? `write ${t.write.join(", ")}` : "read only", ...t.ddl ? ["ddl"] : [], ...t.maintain ? ["maintain"] : []].join(", ");
+  const reads = (t) => t.read ? [`read ${t.read.length ? t.read.join(", ") : "nothing"}`] : [];
+  const perms = (t) => [...reads(t), t.write.length ? `write ${t.write.join(", ")}` : t.read ? "no write" : "read only", ...t.ddl ? ["ddl"] : [], ...t.maintain ? ["maintain"] : []].join(", ");
   line("tokens", r.tokens.length ? r.tokens.map((t) => `${t.name} (${perms(t)})`).join("; ") : "owner only");
   const h = r.hand_edits;
   line(
@@ -77209,7 +78281,7 @@ Docs: https://datanotes.dev`;
 
 // src/node/cli.ts
 init_message();
-var VERSION2 = true ? "3.3.1" : "dev";
+var VERSION2 = true ? "3.4.0" : "dev";
 var consoleError = console.error;
 async function main5(argv = process.argv.slice(2)) {
   const [command, ...rest] = argv;