Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript

Access docs now say restricted pages are still sent to your embedding provider (#9585)

Garry Tan95f082d72bbb
diff --git a/changelog.d/say-restricted-pages-still-embed.md b/changelog.d/say-restricted-pages-still-embed.md
new file mode 100644
index 0000000000..4a0e0b02ad
--- /dev/null
+++ b/changelog.d/say-restricted-pages-still-embed.md
@@ -0,0 +1,4 @@
+**The access docs now say plainly that restricted pages are still embedded by the brain's configured embedding provider.**
+
+### Documentation
+- `readable_by`, folder rules and `visibility: private` control who reads a page, not which configured providers process it. The memory-boundaries guide ("Where text goes"), the access-designations guide and the company-brain tutorial now say that every page is embedded with the configured provider, that gbrain cannot tell a local endpoint from a remote one, and that a self-hosted provider keeps restricted text on your own hardware. Access designations do not exclude a page from embedding.
diff --git a/docs/guides/access-designations.md b/docs/guides/access-designations.md
index e453776915..f36706deba 100644
--- a/docs/guides/access-designations.md
+++ b/docs/guides/access-designations.md
@@ -40,7 +40,9 @@ Five kinds of caller read a brain:
| fact `visibility: private` | reads | reads | hidden | hidden | hidden |
"Hidden" means the same `not_found` a missing page gets, on every read path (get_page, search, query, recall, lists,
-links, timelines, versions). The owner reads through `get_page`, `search`, `query`, `recall` and the other page
+links, timelines, versions). Designations govern readers, not processing: restricted pages are embedded
+with the brain's configured embedding provider like any other page. See
+[where text goes](memory-boundaries.md#where-text-goes). The owner reads through `get_page`, `search`, `query`, `recall` and the other page
reads in every source its grant reads; the owner's source grant still bounds which sources those are. It also gets
private facts from `recall`, the `query` facts arm, `think` trajectories, hot memory, `delta` and `context_pack` hot
facts, except a fact taken from a page it cannot read. Facts on `entity` and `context_pack` cards stay world-only for
diff --git a/docs/guides/memory-boundaries.md b/docs/guides/memory-boundaries.md
index 58bb266825..1900be8ba2 100644
--- a/docs/guides/memory-boundaries.md
+++ b/docs/guides/memory-boundaries.md
@@ -397,6 +397,26 @@ candidate passages; expansion receives the query; synthesis and LLM extraction
receive the relevant retrieved content or source text. Self-hosted providers have
their own deployment boundary. The connected agent's own model also receives
whatever memory its harness includes in context, even on a keyless GBrain setup.
+
+Access designations decide who reads a page, not which configured providers
+process it, and they do not exclude a page from processing that is turned on.
+A page with `readable_by`, a folder rule or `visibility: private` is embedded
+like every other page, so the configured embedding provider receives its text.
+Private facts and takes are embedded on their own, so the provider receives
+their text too. When contextual retrieval runs at the synopsis tier, the chat
+model also receives the page's title and text (with private fact rows and takes
+removed). GBrain cannot tell a local endpoint from a remote one, because a
+recipe's base URL can point anywhere. A self-hosted embedding provider (and
+synopsis model) on hardware you control keeps restricted text in house for
+embedding and contextual retrieval only. Every other enabled provider, such as
+a reranker or a chat model, can still receive restricted text, so self-host or
+turn off each one that must not. The decision provider is stricter by default:
+while `decide.egress.private` is `deny` (the default), System One calls to
+TypeSafe withhold restricted pages, private facts and conversation text, except
+for the reranking slot and the fact and conversation items of a slot turned on
+by the key-aware default. An `llm:` decision provider, or setting
+`decide.egress.private allow`, removes that guard.
+
Reporting back through Wakeshift (off by default, owner opt-in) sends a watched
job's, write request's or cron's id, status and times (and a removed member's
hashed id to forget), never page text, titles or slugs; see
diff --git a/docs/tutorials/company-brain.md b/docs/tutorials/company-brain.md
index e88ad6ec01..041f8c5e6a 100644
--- a/docs/tutorials/company-brain.md
+++ b/docs/tutorials/company-brain.md
@@ -132,7 +132,7 @@ gbrain access who-can-read notes/renewal-notes # the members and groups a pag
A credential bound with `--member` whose write source is `default` (a token with no `--sources` or `--sources default`, or an OAuth client left at its registration default) or a federated source (`gbrain sources federate <id>`) writes where every credential without a source grant reads, so a page it creates is written with `readable_by: [member:<id>]` and only that member reads it; it keeps those readers when the member rewrites it without the field, and the member shares it by naming readers (`readable_by: [alice-example, group:team-a]`). An edit to an existing page that names no readers leaves it shared, `remember` facts go on the member's own page as before, and `POST /ingest` refuses such a credential. Pages derived from such a page (extracted atoms, chronicle events, `derived_from` pages, and a synthesized concept that uses it) follow the rule for pages with readers and are readable by no remote caller, the writer included. A page that teammates should read, such as a shared `people/` or `companies/` entity page or a page in a folder a rule already scopes to a group, names its readers when it is created; otherwise the first member to create a slug keeps it, and every other remote credential writing that slug (another member, an unbound token, a shared agent) gets `page_not_found`. The operator widens such a page from the brain host by adding `readable_by` to it. A member-bound `put_page` over a page deleted within the last 72 hours is a create, so it is kept to the member too. A credential whose write source is a source that is not federated (`--sources private-alice-example,default`, first id the write source) keeps writing exactly what it sends. Earlier releases wrote these pages with no readers, so other members and unbound tokens read them; run `gbrain access who-can-read <slug>` on pages your members wrote and add `readable_by` on the host where needed.
-A remote caller whose credential is bound to a listed member (directly or through a group) reads the page on every read path; every other remote caller, including an unbound token, an unbound stdio server, a bot with `--private-pages granted-sources` and an operator escape hatch (`GBRAIN_REMOTE_PRIVATE_PAGES=1`, `search.remote_private_pages=visible`), gets the same `not_found` as for a page that does not exist. `readable_by` only narrows: a `visibility: private` page stays private to a listed member unless the member's credential also has `--private-pages granted-sources`. What every designation means for each kind of caller is in [access designations](../guides/access-designations.md). A malformed `readable_by` reads as nobody. A page derived from a restricted page (an extracted atom, a synthesized concept, a chronicle event) is readable by no remote caller. The local CLI is unchanged; `--as <member>` previews one member's view. Pages that already carried `readable_by` before you upgraded read as nobody until `gbrain repair access` (preview, then `--apply`) derives their readers. This works the same on a repo-less brain: members, groups and bindings live in the database.
+A remote caller whose credential is bound to a listed member (directly or through a group) reads the page on every read path; every other remote caller, including an unbound token, an unbound stdio server, a bot with `--private-pages granted-sources` and an operator escape hatch (`GBRAIN_REMOTE_PRIVATE_PAGES=1`, `search.remote_private_pages=visible`), gets the same `not_found` as for a page that does not exist. `readable_by` only narrows: a `visibility: private` page stays private to a listed member unless the member's credential also has `--private-pages granted-sources`. What every designation means for each kind of caller is in [access designations](../guides/access-designations.md). A malformed `readable_by` reads as nobody. A page derived from a restricted page (an extracted atom, a synthesized concept, a chronicle event) is readable by no remote caller. The local CLI is unchanged; `--as <member>` previews one member's view. Pages that already carried `readable_by` before you upgraded read as nobody until `gbrain repair access` (preview, then `--apply`) derives their readers. This works the same on a repo-less brain: members, groups and bindings live in the database. `readable_by` limits who reads a page, not which providers process it: the brain's embedding provider still embeds restricted pages, so pick a provider whose data handling fits your most sensitive page ([where text goes](../guides/memory-boundaries.md#where-text-goes)).
On a brain with two or more enabled members, Model C is required, not optional: a remote read from a token or OAuth client bound to no member is refused with [`requester_scope_required`](../guides/write-refusals.md#requester_scope_required) (connections that already existed get 14 days of notices first), and `gbrain auth create` refuses an unbound token. Bind each teammate's credential with `--member`; a bot serving a channel names its audience per call (`--may-act-for`); `--reads-unscoped --yes` opts one credential out on purpose.