@recursiv/sdk 0.7.82 → 0.7.89

package/dist/resources/sealed.js

@@ -10,8 +10,10 @@ export class SealedTransportError extends Error {
 /** Set on a refusal the gateway wrote itself; a relayed router answer never carries it. */
 export const SEALED_REFUSAL_HEADER = 'x-sealed-gateway-refusal';
 /**
- * Requests left in the member's allowance today. The gateway sets it on every answer it relayed from the router and on
- * no other, and the router cannot set it, so an error without it is one the API (or an edge in front of it) wrote.
+ * Messages left in the member's allowance today, on a check as on a message. The gateway sets it on every answer it
+ * relayed from the router and on no other, and the router cannot set it, so an error without it is one the API (or an
+ * edge in front of it) wrote. A relayed answer to a check also carries `X-Sealed-Checks-Remaining` while the gateway
+ * has a check allowance, and one to a marked search `X-Sealed-Searches-Remaining`.
  */
 export const SEALED_ALLOWANCE_REMAINING_HEADER = 'x-sealed-allowance-remaining';
 const HEX_32_BYTES = /^[0-9a-fA-F]{64}$/;
@@ -95,10 +97,23 @@ export class SealedResource {
      *   has no nonce, never to be shown as the model's words.
      *
      * Throws a RecursivError for every error the API wrote rather than relayed, whether or not it is marked
-     * X-Sealed-Gateway-Refusal: RateLimitError for an allowance used up (`code` `sealed_allowance_used` or
-     * `sealed_too_many_requests`) or the API's own per-IP limit (`rate_limited`), AuthenticationError for a revoked or
-     * expired key, NotFoundError while Sealed is off or not on for this app. Throws SealedTransportError when the router
-     * is not listed, the key is malformed, or a 2xx answer came back unsealed.
+     * X-Sealed-Gateway-Refusal: RateLimitError for an allowance used up (`code` `sealed_allowance_used`,
+     * `sealed_search_allowance_used` or `sealed_too_many_requests`, with SealedQuotaDetails in `details`) or the API's own
+     * per-IP limit (`rate_limited`), a RecursivError with status 503 and `code` `sealed_paused_budget` while the app's
+     * monthly Sealed budget is used up (until the next UTC month), AuthenticationError for a revoked or expired key,
+     * NotFoundError while Sealed is off or not on for this app, AuthorizationError (`sealed_search_off`) for a marked
+     * search while search is off. Throws SealedTransportError when the router is not listed, the key, purpose or marks
+     * are malformed, or a 2xx answer came back unsealed.
+     *
+     * With `purpose: 'check'` the request counts against the check allowance while the gateway has one (`code`
+     * `sealed_check_allowance_used` when it is used up), and as a message otherwise. With `search: true` it counts
+     * against the day's searches (`sealed_search_allowance_used`) and spends no message. While the gateway's day lock is
+     * on, a member is refused until midnight UTC (`sealed_paused_today`) after a request of theirs that searched the web
+     * unmarked (or marked a check), that the router answered with a model `config()` does not offer for it (a check's must
+     * be in `checks`; any other's in `models`, or in `checks` while the gateway lets checks sent unmarked through), or
+     * that passed the day's count of answers left before their usage line (searches included). The lists can change on
+     * the server: read `config()` again from time to time, not once for the app's whole run, or a member whose app still
+     * sends to a model taken out of them is paused.
      */
     async send(input) {
         // Malformed input is refused here, before the config is read, so it never turns into a network error.
@@ -109,6 +124,15 @@ export class SealedResource {
         if (!HEX_32_BYTES.test(input.encapsulatedKey)) {
             throw new SealedTransportError('bad_encapsulated_key', 'The encapsulated key must be 32 bytes of hex. Nothing was sent.');
         }
+        if (input.purpose !== undefined && input.purpose !== 'check') {
+            throw new SealedTransportError('bad_purpose', 'The purpose must be "check" or left out. Nothing was sent.');
+        }
+        if (input.search !== undefined && typeof input.search !== 'boolean') {
+            throw new SealedTransportError('bad_marks', 'search must be true, false or left out. Nothing was sent.');
+        }
+        if (input.search === true && input.purpose === 'check') {
+            throw new SealedTransportError('bad_marks', 'A check never searches: search cannot go with purpose "check". Nothing was sent.');
+        }
         const targets = input.targets ?? (await this.config()).targets;
         if (!targets.some((target) => target.origin === origin && target.kind === 'router')) {
             throw new SealedTransportError('enclave_not_allowed', 'That router is not one the gateway forwards to. Nothing was sent.');
@@ -137,6 +161,9 @@ export class SealedResource {
                     // receives a request marked Sealed is meant to refuse it. No server path reads this header yet, so nothing
                     // enforces that today; the Sealed gateway strips it before the router.
                     'X-Recursiv-Privacy-Tier': 'sealed',
+                    // Read by the gateway to pick the allowance, and never forwarded to the router.
+                    ...(input.purpose === 'check' ? { 'X-Sealed-Purpose': 'check' } : {}),
+                    ...(input.search === true ? { 'X-Sealed-Search': '1' } : {}),
                 },
                 body: input.body,
                 signal: controller.signal,

package/dist/resources/settings.d.ts

@@ -22,7 +22,9 @@ export declare class SettingsResource {
     updateAppearance(input: UpdateAppearanceInput): Promise<SuccessResponse>;
     /**
      * Update per-user content preferences for the app bound to this API key.
-     * Requires a project-bound key with `settings:write`.
+     * Requires a project-bound key with `settings:write`. `sealed_adult: true`
+     * is refused (403 `AuthorizationError`, code `sealed_adult_needs_adult`, and
+     * nothing in the request is saved) unless the member answered 18 or older.
      */
     updateContent(input: UpdateContentPreferencesInput): Promise<SuccessResponse>;
     /** List active sessions */

package/dist/resources/settings.js

@@ -45,7 +45,9 @@ export class SettingsResource {
     }
     /**
      * Update per-user content preferences for the app bound to this API key.
-     * Requires a project-bound key with `settings:write`.
+     * Requires a project-bound key with `settings:write`. `sealed_adult: true`
+     * is refused (403 `AuthorizationError`, code `sealed_adult_needs_adult`, and
+     * nothing in the request is saved) unless the member answered 18 or older.
      */
     updateContent(input) {
         return this.client.put('/settings/preferences/content', input);

package/dist/resources/users.d.ts

@@ -1,10 +1,19 @@
 import type { HttpClient } from '../client.js';
 import type { PaginatedResponse, SingleResponse, User, FollowUser, PaginationParams } from '../types.js';
+import type { AssistantSettings } from '../assistant-surfaces.js';
+/** The signed-in user as `users.me()` returns it. */
+export interface CurrentUser extends User {
+    /**
+     * The assistant surface switches for the app this key is bound to (absent on servers from before George plan G7a).
+     * Read them with `assistantSurfaceOn(me, id)`, which is off for anything but an explicit true.
+     */
+    assistant?: AssistantSettings;
+}
 export declare class UsersResource {
     private client;
     constructor(client: HttpClient);
-    /** Get the authenticated user's profile */
-    me(): Promise<SingleResponse<User>>;
+    /** Get the authenticated user's profile, with the app's assistant surface switches */
+    me(): Promise<SingleResponse<CurrentUser>>;
     /** Get a user by ID */
     get(id: string): Promise<SingleResponse<User>>;
     /** List a user's followers */

package/dist/resources/users.js

@@ -3,7 +3,7 @@ export class UsersResource {
     constructor(client) {
         this.client = client;
     }
-    /** Get the authenticated user's profile */
+    /** Get the authenticated user's profile, with the app's assistant surface switches */
     me() {
         return this.client.get('/users/me');
     }

package/dist/social-protocol-ids.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Every open network id the API may name a post, an account or a source by (`protocol` on a SocialPost, a SocialProfile,
+ * a SocialSourceRef, a radar member's `kind`, a feed top's `network_post` and lane). The server's twin is
+ * packages/server/src/lib/socialProtocolIds.ts, and its socialProtocolIds test holds the two equal.
+ *
+ * Readers first (0.7.87): `farcaster` is listed one release before any server reader emits it, so an app on this SDK
+ * shows a Farcaster post, radar member or top item the day the API starts serving them, with no app update. Listing an
+ * id serves nothing: which networks an app can read is still `publicNetworks()` / `sharedNetworks(projectId)`, and a
+ * network the catalog does not list never appears. An id a later SDK adds is skipped by this one, never an error.
+ *
+ * Farcaster ids, as the server checks them: an account is its FID in decimal ("3"); a cast is its CastId,
+ * `<fid>:0x<40 lowercase hex>` (its author's FID and its message hash).
+ */
+export declare const SOCIAL_PROTOCOL_IDS: readonly ["bluesky", "activitypub", "nostr", "farcaster"];
+export type SocialProtocolId = (typeof SOCIAL_PROTOCOL_IDS)[number];
+/** Whether `value` is an open network id this SDK knows. */
+export declare function isSocialProtocolId(value: unknown): value is SocialProtocolId;
+/**
+ * The networks a member's native write may act on (0.7.87): the source a reply, follow, like or repost names
+ * (`NativeReplyPrepareInput.parent`, `NativeFollowSourceInput`, `NativeLikeSourceInput`, `NativeRepostSourceInput`), and
+ * the account lists and results those writes answer. Narrower than SOCIAL_PROTOCOL_IDS on purpose: a network is read
+ * before it is written, so a Farcaster post can be shown, muted, hidden or reported (`SocialSourceRef`) while the API
+ * still refuses a Farcaster write (400 `invalid_input`). Check `isNativeWriteProtocol(post.protocol)` before offering one.
+ */
+export declare const NATIVE_WRITE_PROTOCOLS: readonly ["bluesky", "activitypub", "nostr"];
+export type NativeWriteProtocol = (typeof NATIVE_WRITE_PROTOCOLS)[number];
+/** Whether a member's native write may act on a source of network `value` (NATIVE_WRITE_PROTOCOLS). */
+export declare function isNativeWriteProtocol(value: unknown): value is NativeWriteProtocol;

package/dist/social-protocol-ids.js

@@ -0,0 +1,30 @@
+/**
+ * Every open network id the API may name a post, an account or a source by (`protocol` on a SocialPost, a SocialProfile,
+ * a SocialSourceRef, a radar member's `kind`, a feed top's `network_post` and lane). The server's twin is
+ * packages/server/src/lib/socialProtocolIds.ts, and its socialProtocolIds test holds the two equal.
+ *
+ * Readers first (0.7.87): `farcaster` is listed one release before any server reader emits it, so an app on this SDK
+ * shows a Farcaster post, radar member or top item the day the API starts serving them, with no app update. Listing an
+ * id serves nothing: which networks an app can read is still `publicNetworks()` / `sharedNetworks(projectId)`, and a
+ * network the catalog does not list never appears. An id a later SDK adds is skipped by this one, never an error.
+ *
+ * Farcaster ids, as the server checks them: an account is its FID in decimal ("3"); a cast is its CastId,
+ * `<fid>:0x<40 lowercase hex>` (its author's FID and its message hash).
+ */
+export const SOCIAL_PROTOCOL_IDS = Object.freeze(['bluesky', 'activitypub', 'nostr', 'farcaster']);
+/** Whether `value` is an open network id this SDK knows. */
+export function isSocialProtocolId(value) {
+    return typeof value === 'string' && SOCIAL_PROTOCOL_IDS.includes(value);
+}
+/**
+ * The networks a member's native write may act on (0.7.87): the source a reply, follow, like or repost names
+ * (`NativeReplyPrepareInput.parent`, `NativeFollowSourceInput`, `NativeLikeSourceInput`, `NativeRepostSourceInput`), and
+ * the account lists and results those writes answer. Narrower than SOCIAL_PROTOCOL_IDS on purpose: a network is read
+ * before it is written, so a Farcaster post can be shown, muted, hidden or reported (`SocialSourceRef`) while the API
+ * still refuses a Farcaster write (400 `invalid_input`). Check `isNativeWriteProtocol(post.protocol)` before offering one.
+ */
+export const NATIVE_WRITE_PROTOCOLS = Object.freeze(['bluesky', 'activitypub', 'nostr']);
+/** Whether a member's native write may act on a source of network `value` (NATIVE_WRITE_PROTOCOLS). */
+export function isNativeWriteProtocol(value) {
+    return typeof value === 'string' && NATIVE_WRITE_PROTOCOLS.includes(value);
+}

package/dist/types.d.ts

@@ -1316,7 +1316,35 @@ export interface AgentChatInput {
     message: string;
     conversation_id?: string;
     new_conversation?: boolean;
+    /** Per-turn options. `{ safe: true }` makes this a safe turn (see {@link AgentChatTurn}). */
+    turn?: AgentChatTurn;
 }
+/**
+ * Per-turn options for an agent chat message.
+ *
+ * `safe: true` (George plan G6a) asks about something on the network, typically someone else's post, on the caller's
+ * own personal agent, in their one Asks thread with it (found or made by the server; leave out `new_conversation`, and
+ * send `conversation_id` only for that thread). The turn has no tools whatever the agent's tool mode, reads and saves
+ * no memory, sends OpenRouter `data_collection: 'deny'` whatever the member chose, writes no audit copy of the prompt
+ * or reply (`ai_usage_detail`), sends pictures as alt text and stored descriptions only, and counts against a small
+ * daily allowance. Every later turn in the Asks thread is a safe turn too, however it is sent. The reply
+ * carries `metadata.safe_turn: true`. Refusals answer with a fixed {@link SafeTurnRefusalCode}; none names a plan or
+ * a price, and the server never creates an agent for an ask.
+ */
+export interface AgentChatTurn {
+    safe?: boolean;
+}
+/**
+ * Why the server refused a safe turn (the `code` of the error):
+ * - `safe_turn_limit` (429): today's asks are used up (an app shows its own "limit" words). Marked
+ *   `X-RateLimit-Scope: action`, so the SDK throws it at once as a `RateLimitError` with `scope: 'action'` and
+ *   `resetAt` (the next midnight UTC), and does not resend it.
+ * - `safe_turn_needs_personal_agent` (409): the agent is not the caller's own personal agent.
+ * - `safe_turn_needs_app` (403): the key is bound to no app (a personal key, say); an ask goes with the app's own key.
+ * - `safe_turn_ai_off` / `safe_turn_standard_off` (403): the member's AI choices refuse it.
+ * - `safe_turn_conversation` (400): `new_conversation` was sent, or `conversation_id` is not the Asks thread.
+ */
+export type SafeTurnRefusalCode = 'safe_turn_limit' | 'safe_turn_needs_personal_agent' | 'safe_turn_needs_app' | 'safe_turn_ai_off' | 'safe_turn_standard_off' | 'safe_turn_conversation';
 /** Answer an existing message of yours again, without sending it a second time. */
 export interface AgentChatRetryInput {
     conversation_id: string;
@@ -1583,6 +1611,20 @@ export interface UserPreferences {
         profile_visibility: 'public' | 'network' | 'private';
         show_email: boolean;
         show_location: boolean;
+        /**
+         * "Who can message me": with 'following', new conversations, message requests and group invites reach the member
+         * only from accounts they follow. A 13-17 account always reads 'following'. Absent on servers that predate it.
+         */
+        who_can_message?: WhoCanMessage;
+        /** True when the member cannot change `who_can_message` themselves (a 13-17 account). */
+        who_can_message_locked?: boolean;
+        /** Whether the member has answered the age question. The answer itself is never returned. */
+        age_declared?: boolean;
+        /**
+         * True when the member is a known adult: they answered the age question 18 or older. False for a 13-17 answer and
+         * for no answer. Only the member's own preferences carry it. Absent on servers that predate it.
+         */
+        age_is_adult?: boolean;
     };
     appearance: {
         theme: 'light' | 'dark' | 'system';
@@ -1597,6 +1639,18 @@ export interface ContentPreferences {
     autoplay_video: boolean;
     ai_enabled: boolean;
     default_feed: 'foryou' | 'following';
+    /**
+     * True when the member picked `default_feed` themselves (any `updateContent({ default_feed })` sets it).
+     * When false, `default_feed` is only the default and the app may choose for them. Absent from APIs older than
+     * this field: treat absent as unknown, not as false.
+     */
+    default_feed_chosen?: boolean;
+    /**
+     * The Sealed adult-content setting. True only while it is on AND the member is a known adult
+     * (`privacy.age_is_adult`): if the account stops being one, it reads false whatever was saved. Absent on servers
+     * that predate it: treat absent as off.
+     */
+    sealed_adult?: boolean;
 }
 export interface UpdateNotificationChannelsInput {
     /** Master switch: sets in-app on every kind. */
@@ -1612,10 +1666,21 @@ export interface UpdateNotificationChannelsInput {
      */
     channels?: Partial<Record<NotificationChannelKind, Partial<NotificationChannelToggles>>> & Record<string, Partial<NotificationChannelToggles>>;
 }
+/** "Who can message me" (`UserPreferences.privacy.who_can_message`). */
+export type WhoCanMessage = 'everyone' | 'following';
+/** An answer to the age question (`UpdatePrivacyInput.age_band`). Only a band is ever stored, never a date of birth. */
+export type AgeAnswer = '18_plus' | '13_17' | 'under_13';
 export interface UpdatePrivacyInput {
     profile_visibility?: 'public' | 'network' | 'private';
     show_email?: boolean;
     show_location?: boolean;
+    /** "Who can message me". A 13-17 account stays held to 'following' whatever it saves. */
+    who_can_message?: WhoCanMessage;
+    /**
+     * The age question, answered once. 'under_13' is refused (403 `age_not_eligible`) and writes nothing in the request;
+     * a different second answer is refused (409 `age_already_set`); the same answer again succeeds and changes nothing.
+     */
+    age_band?: AgeAnswer;
 }
 export interface UpdateAppearanceInput {
     theme?: 'light' | 'dark' | 'system';
@@ -1627,6 +1692,12 @@ export interface UpdateContentPreferencesInput {
     autoplay_video?: boolean;
     ai_enabled?: boolean;
     default_feed?: 'foryou' | 'following';
+    /**
+     * The Sealed adult-content setting. `true` is accepted only from a known adult (an 18+ answer): anyone else gets 403
+     * `AuthorizationError` with code `sealed_adult_needs_adult`, and nothing in the request is saved. `false` is always
+     * accepted.
+     */
+    sealed_adult?: boolean;
 }
 export interface Session {
     id: string;

package/llm.md

@@ -214,6 +214,29 @@ Methods: `tasks`, `stats`, `decisions`, `milestones`, `agents`, `teamActivity`,
 
 ---
 
+## Assistant subjects — `@recursiv/sdk/assistant` (unreleased)
+
+Pure, no network: the same input on a server, a phone or the web. Build the bundle from data you already hold, then render it; never paste post text into a prompt by hand.
+
+```typescript
+import { buildSubjectBundle, renderBundleForModel } from '@recursiv/sdk/assistant'
+const { bundle, refused, excluded } = buildSubjectBundle({ mode: 'standard', asker: { id, blocked_ids, muted_ids }, post, parent, quoted, replies }) // server: also blocked_by_ids
+if (bundle) {
+  const { system, user, references } = renderBundleForModel(bundle, 'summarise', { boundary }) // boundary: fresh random, 16+ chars, per call
+}
+```
+
+- `bundle` is null when the post itself may not be read: author asks off (`ai_ask_allowed` `'off'`, or `'sealed_only'` in Standard), the asker blocked or muted the author or the author blocked the asker, known-minor author (unless asker is author), child-safety hold, moderator suppression, `assist_readable: 'none'`. Make no model call.
+- `refused` and `excluded` (`{ role, reason, count }[]`, never ids) are safe to show the asker: blocks, minors, holds and suppression all read `'unavailable'`. `audit` has the detail: server log only, never to a client.
+- `known_minor`, `child_safety_hold`, `assistant_suppressed`, media `held: true`, `blocked_by_ids`: server-side inputs, never sent to another member's client (held media is left out of that payload, and so is the post's `ai_caption` whenever any of its media is held: a client cannot see media it was never sent); a client passes the server's per-viewer `assist_readable` instead. Exception: a picture's `held: false`, the payload's "not held" mark beside `checked_at`. Flags fail closed (anything but false/null/absent is set); an unreadable id list throws.
+- Replies, parent and quote are left out by the same rules. Media go as alt text and stored caption only; picture and media addresses never reach `references`. Hidden text is stripped; top 20 replies; per-field and total caps (lower them with `limits`, never raise).
+- Intents: `explain`, `fact_context` (post, parent, quote), `summarise` (plus replies), `translate` (needs `language`, a BCP 47 tag), `describe`. Output filters allow only `references` ids, handles and URLs, as plain links (never render an image the model wrote). Render only bundles you built from your own reads.
+- Post pictures: pass media `id`, the payload's `checked_at` and its `held: false` mark to the builder (`checked_at` is kept only with `held` exactly `false`). `max` = `Math.max(0, 3 - phonePictures)`. `listed = bundlePictures(bundle, intent, { now: Date.now(), max })`, run your checks, then `renderBundleForModel(bundle, intent, { boundary, pictures: { now: Date.now(), max, allowed: passed.map((x) => x.picture), cached: (p) => passed.find((x) => same(x.picture, p))?.prepared_jpeg ?? null } })` (a fresh clock: it can only take pictures away). Your checks load each listed picture from the image cache, prepare it first (longest side ≤ 1536 px, re-encoded as JPEG, metadata stripped; spec 2.2), check the prepared bytes and return `passed` as `{ picture, prepared_jpeg }`; `cached` returns that `prepared_jpeg` (`same` matches `item_id`, `media_id` and `number`): never a second read of the cache, which could return a picture nobody checked and still carries its metadata. The SDK only checks the bytes look like a JPEG. Only pictures on the post, parent or quote (never replies), marked `held: false`, checked under 24 h ago by `now` (5 min ahead allowed), with a plain id, on `allowed` and with a cached base64 JPEG go, as `image_url` data parts inside the content block in `user_parts`; at most `max` (≤ 3), none for `translate`; a picture stale since listing is not replaced; everything else stays alt text, and output is unchanged when none qualifies. With pictures, send `system` + `user_parts` (not `user`/`text`). Never fetch in `cached`; `references` never holds a picture address.
+- `sealedTurnCaps({ mode: 'sealed' | 'both', others_content, phone_pictures, temporary, searched_earlier, phone_pictures_earlier, search, earlier_messages, memory, memory_in_chat, memory_tick, about_you, page_opens_limited })` → `{ search, history, memory, about_you, phone_pictures, suggest_memory, reasons }`. `others_content` (`[]` for own words), `phone_pictures` (`0` for none), `temporary`, `searched_earlier`, `phone_pictures_earlier` and `earlier_messages` are required (absent/null throws; `false` is none). `mode: 'both'` with `'encrypted_chat'` throws (G21: Sealed only; Both's Standard half would send it to Minds and the AI company). Searching messages carry no memory/About you/phone pictures (search turns off: `search.off_mix`) and no history (`search.question_only`); someone else's public post blocks search until `page_opens_limited` (Tinfoil ask 3, default false; `search.off_subject`); members-only posts and chat messages never search (`search.off_members`), encrypted-chat messages never (`search.e2ee`) and carry no phone pictures; Both never searches or carries phone pictures (`both.no_search`, `both.no_photo`); temporary chats and encrypted-chat asks get no memory. With others' content only `memory_tick` sends memory/About you (the chip `memory_in_chat` counts only in the member's own chat). No `suggest_memory` with phone pictures in the message (a screenshot can carry someone else's words), or after a search or a phone picture earlier in the chat. Only `true` turns a sending choice on; unknown `mode`/content kinds and picture counts that are not 0 to 3 throw.
+- Fixed cards, before any model call: `matchFixedCard(memberWords, { country, locale })` → `{ kind: 'crisis' | 'election', card } | null`. Crisis (self-harm, suicide risk, immediate danger) always shows the card first, then the turn may answer; election logistics only (never candidates, results, fraud claims, votes on a post or poll), and `fixedCardAnswer('election', Date.now())` is `'card_only'` until 2026-11-04T12:00Z. English and Spanish; every number and URL is sourced data (`CRISIS_LINES`, `ELECTION_SITES`), never generated. Pass the member's words, not the post they ask about.
+
+---
+
 ## Evidence — Measure agents (evals, accuracy, cost)
 
 ### r.evidence — Author evals, run simulations, read graded results
@@ -564,6 +587,14 @@ const { data: reset } = await r.e2ee.resetAccount({ email_code, device_name, rea
 // → { reset, resetAt, retiredRoot, revokedDeviceIds, device (the new main device), signedOut: { sessions, keys, connectedApps } }; a retry after a lost answer gets the same result
 ```
 
+A contact's reset (D2 R2, 0.7.83; where `accountReset` is on). Each member of an encrypted conversation the account shares (a direct chat, or a group both accepted) gets `e2ee:peer` `{ userId, reason: 'root_changed', conversationId }`, once per shared conversation, and each direct-chat contact one push (at most one a day per person who reset; it does not name them): "A contact reset encrypted chat. Open Minds to keep chatting." `peerChanges({ since })` lists the accounts whose main device a reset replaced since then (default and floor 7 days, oldest first, at most 200; a relay without it answers 404: treat it as none). An engine that can accept a contact's new main device sends `trust_change: true` with its messages; in a direct chat with someone who reset, such a message gets 409 `peer_not_joined` (`details.userId`) until a device of this account added their new device, and 409 `stale_epoch` under a key generation before the chat's last key update. Messages without it are accepted as before.
+
+```ts
+r.realtime.onE2eePeer(({ userId, conversationId }) => {});              // look at userId's devices again
+const { data: changes } = await r.e2ee.peerChanges({ since });          // [{ userId, at }] after time in the background
+await r.e2ee.appendEvent(conversationId, { device_id, envelope, trust_change: true }); // ConflictError 'peer_not_joined' | 'stale_epoch'
+```
+
 ### r.realtime — WebSocket Chat Client
 
 Provides persistent real-time streaming and chat presence, useful for building frontends (e.g. React Native, Web).
@@ -597,7 +628,7 @@ unsub()
 const off = r.realtime.on('notification', (n) => refreshBadge(n))
 ```
 
-Events: `onMessage`, `onMessageEdit`, `onMessageDelete`, `onTyping`, `onAgentThinking`, `onE2eeEvent`, `onE2eeLink`, `onE2eeDevices`, `on(event, fn)`
+Events: `onMessage`, `onMessageEdit`, `onMessageDelete`, `onTyping`, `onAgentThinking`, `onE2eeEvent`, `onE2eeLink`, `onE2eeDevices`, `onE2eePeer`, `on(event, fn)`
 
 Reconnects on its own (transport drops, token expiry, refused handshakes) with jittered backoff and a fresh single-use token per attempt; listeners and joined rooms carry over, so no app-side reconnect shim is needed. It stops only on `disconnect()` or a 401/403 from the token source. `connect()` is safe to call repeatedly.
 
@@ -794,13 +825,21 @@ Methods: `list`, `get`, `create`, `delete`
 
 ## Platform Resources
 
-- `r.settings` — User preferences, sessions, password changes, account deletion. `revokeOtherSessions({ keep_session_token? })` signs out every other device and keeps this key (and the proven session); `revokeAllSessions()` also revokes this key. Accounts with no password confirm `requestEmailChange({ new_email, email_code })` with a code from `requestConfirmationCode('email_change')`. With a project-bound key, `getPreferences()` includes app-scoped `content`; persist changes with `updateContent({ show_nsfw?, autoplay_video?, ai_enabled?, default_feed? })`. Notifications (0.7.72): `getPreferences()` returns `notifications.channels`, each kind (`post_mention`, `post_reply`, `post_repost`, `post_reaction`, `follow`, `message`, and the operator kinds) with `{ inApp, push, email }`; `updateNotifications({ channels: { post_reaction: { push: false } } })` changes that kind only, while `in_app`/`push`/`email` stay master switches over every kind. `disableAccount({ password })` (0.7.71) deactivates the account (hidden, nothing deleted; signing back in restores it), asked once; an API that does not serve deactivation answers 404 `NotFoundError`, so keep the control hidden until yours does.
+- `r.settings` — User preferences, sessions, password changes, account deletion. `revokeOtherSessions({ keep_session_token? })` signs out every other device and keeps this key (and the proven session); `revokeAllSessions()` also revokes this key. Accounts with no password confirm `requestEmailChange({ new_email, email_code })` with a code from `requestConfirmationCode('email_change')`. With a project-bound key, `getPreferences()` includes app-scoped `content`; persist changes with `updateContent({ show_nsfw?, autoplay_video?, ai_enabled?, default_feed?, sealed_adult? })`; `content.default_feed_chosen` is true once the member set `default_feed` themselves (absent on older APIs). `privacy.age_is_adult` is true only when the member answered the age question 18 or older (false for 13-17 and for no answer; only their own preferences carry it). `content.sealed_adult` is the Sealed adult-content setting: it reads true only while it is on and the member is a known adult, and `updateContent({ sealed_adult: true })` from anyone else throws `AuthorizationError` with code `sealed_adult_needs_adult` and saves nothing in that request; `sealed_adult: false` is always accepted. Both are absent on older APIs (treat as false). Notifications (0.7.72): `getPreferences()` returns `notifications.channels`, each kind (`post_mention`, `post_reply`, `post_repost`, `post_reaction`, `follow`, `message`, and the operator kinds) with `{ inApp, push, email }`; `updateNotifications({ channels: { post_reaction: { push: false } } })` changes that kind only, while `in_app`/`push`/`email` stay master switches over every kind. `disableAccount({ password })` (0.7.71) deactivates the account (hidden, nothing deleted; signing back in restores it), asked once; an API that does not serve deactivation answers 404 `NotFoundError`, so keep the control hidden until yours does.
 - `r.signals` (0.7.71) — The member's engagement signals for their own ranking (For You), under their app-bound key (`agents:write`): `batch(events, { keepalive?, retry? })` sends up to `SIGNAL_BATCH_MAX` (100) `{ event_type, post_id?, dwell_ms?, metadata? }` to POST /signals/batch; `record(event)` sends one to POST /signals/post (for an API before the batch route, which answers that one 404). `event_type`: `view`, `click`, `dwell`, `react_up`, `react_down`, `save`, `hide`, `share`, `mute_source`, `open_chat`, `ask_agent`, `more_like`, `unhide`. Best-effort: a signal the server cannot store answers 200 with `recorded` 0 (or false) and a `reason` (`no_project_scope`, `project_db_unavailable`). `keepalive: true` is for a flush as the page is hidden or unloads: the request is on the wire before the call returns and is asked once.
 
 ```typescript
 await r.signals.batch([{ event_type: 'view', post_id: post.id }, { event_type: 'dwell', post_id: post.id, dwell_ms: 4200 }])
 addEventListener('pagehide', () => { void r.signals.batch(pending.splice(0, SIGNAL_BATCH_MAX), { keepalive: true }).catch(() => {}) })
 ```
+- `r.privacy` (unreleased) — `capabilities()` reads GET /privacy/capabilities: `{ api_commit, facts }`, the platform privacy facts the deployed API's build marks enforced (any API key). `@recursiv/sdk/privacy` exports `PRIVACY_FACTS` (each `{ id, status, enforcement, capability, step, says }`, generated from the platform's claims registry), `privacyFact(id)`, `isFactEnforced(id)`, `isFactLive(id, capabilities, { deviceFacts? })` and `liveFacts(capabilities, { deviceFacts? })`. Show a privacy sentence only when every fact it rests on is live: enforced in this SDK and listed by the API, and, for a fact held on the phone (`enforcement: 'device'`), also named in `deviceFacts` by the app for the native module it ships. A device fact says what the module does, not what the app does with it (for `sealed.attest_before_send` the app chooses how long a checked router is reused).
+
+```typescript
+import { isFactLive } from '@recursiv/sdk/privacy'
+const { data: capabilities } = await r.privacy.capabilities()
+const showNoPushLine = isFactLive('sealed.no_push', capabilities)
+const showCheckedLine = isFactLive('sealed.attest_before_send', capabilities, { deviceFacts: ['sealed.attest_before_send'] })
+```
 - `r.billing` — Usage tracking, checkout sessions, portal sessions, metered billing
 - `r.appSubscriptions` — Project-scoped consumer plans: `checkout` (409 `subscription_exists` when the member already pays), `status`, `createPortalSession({ return_url, flow?: 'cancel' })` (`flow: 'cancel'` opens Stripe's cancel confirmation; 409 `no_subscription` when there is no plan to cancel), `previewTierChange({ tier })`, `changeTier({ tier, proration_date? })` (in-place, prorated, never a second subscription)
 - `r.boosts` — Promoted posts (micro-USD): `create`, `mine`, `balance`, `pause`, `resume`, `cancel`, `recordEvent`; buy credit with `topup({ amount_cents, return_url })` then `confirmTopup(sessionId)` (credits once); admin `listPendingReview`, `review`, `grant`
@@ -833,11 +872,12 @@ await r.appSubscriptions.changeTier({ tier: 'pro', proration_date: quote.prorati
 - Native follows: `nativeFollowState({ accountId, protocol, nativeId })`, `prepareNativeFollow({ clientMutationId, accountId, protocol, nativeId, action: "follow" | "unfollow" })`, `submitNativeFollow(id, { approve: true, event? })`, `nativeFollowStatus(id)`. Show the acting identity and native following/requested/unfollowed state separately from the Minds feed subscription. Nostr must sign the complete review event without dropping other contacts; stale lists require a fresh review. Keep mutation IDs and reconcile ambiguous outcomes without replay. Requires current follow scopes and API `NATIVE_SOCIAL_FOLLOW_PROJECTS` plus source controls.
 - Native reposts: `nativeRepostState({ accountId, protocol, nativeId })`, `prepareNativeRepost({ clientMutationId, accountId, protocol, nativeId, action: "repost" | "unrepost" })`, `submitNativeRepost(id, { approve: true, event? })`, `nativeRepostStatus(id)`. Requires `NATIVE_SOCIAL_REPOST_PROJECTS`, account capability and explicit approval; Nostr signs the exact review (kind 6 or own kind 5). Unknown attempts only reconcile. Bluesky connections need the new repost scope; ActivityPub uses write:statuses. Native likes: `nativeLikeState({ accountId, protocol, nativeId })`, `prepareNativeLike({ clientMutationId, accountId, protocol, nativeId, action: "like" | "unlike" })`, `submitNativeLike(id, { approve: true, event? })`, and `nativeLikeStatus(id)`. Display the selected account, source and action before approval. Only Nostr supplies `event`: sign the exact public `signing.event` in the review; never transmit a private key. Preserve mutation IDs on ambiguous responses and refresh unknown results instead of resending. Read capabilities before offering actions; old reply-only connections need reconnecting for likes. Nostr results describe the connected relay, not every public relay. The app-specific `NATIVE_SOCIAL_LIKE_PROJECTS` switch and source controls must be enabled on the API.
 - Delegated social accounts: `r.protocols.nativeSocialAccounts()`, `startNativeSocialConnection({ protocol, identifier })`, `finishNativeSocialConnection({ protocol, state, code?, iss?, error? })`, `disconnectNativeSocialAccount(id)`. Example: `const { data } = await r.protocols.startNativeSocialConnection({ protocol: "bluesky", identifier: "alice.bsky.social" })`; open `data.authorizationUrl`, then complete with the same signed-in app user. Never log callback codes, send passwords, or auto-retry OAuth callbacks. Shared replies (off until schema/API deployment and live verification): `prepareNativeReply({ clientMutationId, text, parent: { protocol, nativeId, readRef? }, accountIds, media?, linkedPostAccountIds?, recoverFrom?: { batchId, deliveryIds } })`, `submitNativeReply(id, { approve: true, deliveryIds })`, `nativeReplyStatus(id)`, `nativeReplyHistory({ limit?, cursor? })`, `prepareNativeReplyRemoval(id, { deliveryIds })`, `removeNativeReply(id, { approve: true, removals })`. Review account, destination, `kind`, source, exact `wireText` and every reviewed `media` item with its alt text; connection is not publication approval. `media` takes the same `NativeMediaInput[]` as `prepareNativePost` and needs the account's `publish_media` capability. `linkedPostAccountIds` explicitly selects different-network standalone posts with a source link, never matching threaded replies or a same-network denial fallback. Preserve mutation IDs, show per-destination results and reconcile uncertain attempts without reposting. To review selected unsent or definitively rejected deliveries again, use recoverFrom with a new mutation ID, the same source/accounts and freshly reviewed text; preserve that ID on uncertain preparation. Only saved recoverable destinations qualify, current gates still apply, and replacedBy disables old sends atomically. Never restart unknown, accepted or published deliveries. The new preview still needs explicit approval. Saved delegated drafts/results: `const { data: history } = await r.protocols.nativeReplyHistory({ limit: 20 })`; use its opaque cursor for the next page and `nativeReplyStatus(item.id)` for details. This is a private read, not a write or provider refresh, and includes Nostr results marked type=nostr. Use nativeNostrReplyResult(item.id) to check that recorded event on its relay without signing or resending. Discard page state on owner/app changes. See README for examples and the callback, revocation and removal contracts.
-- `r.protocols` — Private app safety: `sourceControls` returns current `enabled` plus paged saved choices; `setSourceControl`, `onSourceControlChange` and `reportSource` share app scope. Example: `const choices = new Map(); const stop = r.protocols.onSourceControlChange(change => choices.set(JSON.stringify([change.source, change.control]), change.enabled));` then `await r.protocols.setSourceControl({ source: { protocol: "bluesky", kind: "actor", nativeId: "did:plc:aaaaaaaaaaaaaaaaaaaaaaaa" }, control: "mute", enabled: true, scope: "minds" });` and call `stop(); choices.clear()` on account change/unmount. Notifications follow an exact server confirmation, never an uncertain response. These preferences and reports apply in Minds, not on the remote network. Keyless post links: `const visitor = new Recursiv({ anonymous: true, inheritEnvironmentApiKey: false }); const { data: thread } = await visitor.protocols.getSharedConversation(projectId, { protocol: 'nostr', post: publicEventId })`; `sharedNetworks(projectId)` lists public conversation capabilities. Only configured apps; app moderation and rate limits apply, no member state or write authority. Member public reading: `publicNetworks`, `searchPublicProfiles`, `getPublicProfile`, `getPublicAuthorFeed`, `getFollowingFeed`, `getPublicConversation`, `getPublicTrends`, `getPublicTrendFeed`; private app subscriptions: `listSubscriptions`, `subscribeToProfile`, `unsubscribeFromProfile`, `onSubscriptionChange`. Example after selecting a returned source post: `const { data: thread } = await r.protocols.getPublicConversation({ protocol: post.protocol, post: post.nativeId, readRef: post.readRef })`. Render `focus`, oldest-first `ancestors` and direct `replies`; `public_provider_window` never promises every reply, and `limited` marks known omissions. The author's own thread (0.7.81): `thread` holds the focus author's continuation below the post, oldest first (a "1/" post's 2/, 3/, 4/ ..., at most 20 parts, each held to the same moderation and member controls as a reply); its first part is not repeated in `replies`, so render `focus`, `thread`, then `replies` (`thread ?? []`: older APIs omit it, and a `replies: 'none'` read answers none). A card (a post shared into a chat, a link preview) asks for the post alone, 0.7.78: `getPublicConversation({ protocol, post, replies: 'none' })` (also `getSharedConversation` and `getConnectedSocialConversation`) answers `focus` with no `ancestors` or `replies` and `repliesStatus: 'not_requested'`; a Nostr note answers from one relay read instead of a whole thread's. An older API answers 400 `invalid_input`: read without it. Requires both `users:read` and `posts:read` on the current human app key. Protocol discovery/settings: `const { data: adapters } = await r.protocols.list()` returns bounded `{ id, name, icon, color, maturity, capabilities, limitations }` metadata; `supported` means implemented, not configured, healthy, authorized, or enabled. Methods: `list`, `status`, `listCandidates`, `getCandidate`, `search`, `getSettings`, `refresh`, `updateSettings`.
+- `r.protocols` — Private app safety: `sourceControls` returns current `enabled` plus paged saved choices; `setSourceControl`, `onSourceControlChange` and `reportSource` share app scope. Example: `const choices = new Map(); const stop = r.protocols.onSourceControlChange(change => choices.set(JSON.stringify([change.source, change.control]), change.enabled));` then `await r.protocols.setSourceControl({ source: { protocol: "bluesky", kind: "actor", nativeId: "did:plc:aaaaaaaaaaaaaaaaaaaaaaaa" }, control: "mute", enabled: true, scope: "minds" });` and call `stop(); choices.clear()` on account change/unmount. Notifications follow an exact server confirmation, never an uncertain response. These preferences and reports apply in Minds, not on the remote network. Open network ids (0.7.87, readers first): `import { SOCIAL_PROTOCOL_IDS, isSocialProtocolId } from '@recursiv/sdk'` lists every network a post, account or `SocialSourceRef` may name: bluesky, activitypub, nostr and farcaster (a Farcaster account by its FID, "3"; a cast by `<fid>:0x<40 lowercase hex>`). Listing an id serves nothing: read only what `publicNetworks()` lists, and skip an id this SDK does not know. Writes stay narrower: a native reply, follow, like or repost takes only `NATIVE_WRITE_PROTOCOLS` (bluesky, activitypub, nostr; `isNativeWriteProtocol(post.protocol)` before offering one), and a feed top's `networks` always names those three while a Farcaster lane may be absent (`networks.farcaster ?? []`). Keyless post links: `const visitor = new Recursiv({ anonymous: true, inheritEnvironmentApiKey: false }); const { data: thread } = await visitor.protocols.getSharedConversation(projectId, { protocol: 'nostr', post: publicEventId })`; `sharedNetworks(projectId)` lists public conversation capabilities. Only configured apps; app moderation and rate limits apply, no member state or write authority. Member public reading: `publicNetworks`, `searchPublicProfiles`, `getPublicProfile`, `getPublicAuthorFeed`, `getFollowingFeed`, `getPublicConversation`, `getPublicTrends`, `getPublicTrendFeed`; private app subscriptions: `listSubscriptions`, `subscribeToProfile`, `unsubscribeFromProfile`, `onSubscriptionChange`. `getFollowingFeed` sources: a slow account is `late` (status `late`, or `ok` with `late: true` while its held first page is shown; older APIs say `unavailable` with `late: true`), never a failure: read the next page for its posts (`lateNetworks` names its network). Example after selecting a returned source post: `const { data: thread } = await r.protocols.getPublicConversation({ protocol: post.protocol, post: post.nativeId, readRef: post.readRef })`. Render `focus`, oldest-first `ancestors` and direct `replies`; `public_provider_window` never promises every reply, and `limited` marks known omissions. The author's own thread (0.7.81): `thread` holds the focus author's continuation below the post, oldest first (a "1/" post's 2/, 3/, 4/ ..., at most 20 parts, each held to the same moderation and member controls as a reply); its first part is not repeated in `replies`, so render `focus`, `thread`, then `replies` (`thread ?? []`: older APIs omit it, and a `replies: 'none'` read answers none). A card (a post shared into a chat, a link preview) asks for the post alone, 0.7.78: `getPublicConversation({ protocol, post, replies: 'none' })` (also `getSharedConversation` and `getConnectedSocialConversation`) answers `focus` with no `ancestors` or `replies` and `repliesStatus: 'not_requested'`; a Nostr note answers from one relay read instead of a whole thread's. An older API answers 400 `invalid_input`: read without it. Requires both `users:read` and `posts:read` on the current human app key. Protocol discovery/settings: `const { data: adapters } = await r.protocols.list()` returns bounded `{ id, name, icon, color, maturity, capabilities, limitations }` metadata; `supported` means implemented, not configured, healthy, authorized, or enabled. Methods: `list`, `status`, `listCandidates`, `getCandidate`, `search`, `getSettings`, `refresh`, `updateSettings`.
   - Native Nostr: `const { data: preview } = await r.protocols.prepareNativeNostr(identityId, { action: "publish", content: draft })`; review and sign the exact public event, then `submitNativeNostr(identityId, { intent: preview.intent, event, approve: true })`. Preparation/submission never auto-retry. After uncertainty, use `getNativeNostrPost(identityId, preview.postId ?? preview.eventId)` before a user-selected retry of the identical intent/event: deletion checks the original note's `postId`, publication checks `eventId`. Check `nativeNostrAccount()` enablement first; keys stay with the signer. For replies, after `nativeNostrAccount()` advertises `reply_text_note`, use `prepareNativeNostr(identityId, { action: "reply", content: draft, parentId: post.nativeId })`. Review returned parent/root/participants/relay and exact event, sign with the connected client signer, then `submitNativeNostr(identityId, { intent, event, approve: true })`. Requires users:read, posts:read and posts:write. Kind1 public notes only; reply enablement and shared UI/live proof remain pending. Do not inherit arbitrary notification tags or relay hints. Signing mutations never auto-retry; check `getNativeNostrPost(identityId, eventId)` after uncertainty before a user-selected identical-event retry.
+  - Native networks (0.7.89): every eligible member is on ActivityPub, AT Protocol and Nostr by rule. `const { data } = await r.protocols.networks()` lists `{ network, state, reason, mode, handle, engageDefault }` (read-only; `ready` = set up on their first post or interaction, show "Will be set up when you first post or interact"). `activateNetwork(network)` = "Set up now" (`pending` + `retryAt` over budget; 409 `network_off` after the member's off switch). `setNetwork(network, { enabled: false, removePast: true })` turns it off and removes what was shared; `{ enabled: true }` turns it back on (403 `network_locked`, 409 `not_rolled_out`/`age_band_required`). Needs users:read (+ users:write to change). A linked outside account is a Settings choice, never a step in a main flow.
   - Hosted Bluesky account on the app's own PDS: `const { data } = await r.protocols.createHostedIdentity({ protocol: 'atproto', handle: 'alice', email })`. Only the label is sent; `data.handle` carries the domain and `data.password` is returned this once, never stored. Never auto-retried. Either the account is finished or it is removed again. 409 `handle_unavailable` = choose another label; 503 `handle_dns_unavailable`/`handle_unresolvable`/`handle_unverified` = operator setup, retry later unchanged.
   - Anonymous discovery: `const visitor = new Recursiv({ anonymous: true, inheritEnvironmentApiKey: false }); const { data } = await visitor.protocols.getSharedTrends(projectId, { protocol: 'nostr', limit: 20, discovery: true })`. Use `sharedNetworks(projectId)` capabilities; open a returned topic with `getSharedTrendFeed(projectId, { protocol: 'bluesky', topic: trend.nativeId, cursor })`. Configured apps only; no account authority or writes. App moderation and per-IP/app rate limits apply. Categories and Jev layouts reuse cached judgments without initiating paid inference; handle partial categories and finite provider windows. Category depth: `r.posts.list({ category: 'science', sort: 'hot', discovery: true })` pages the hot window by offset and then by keyset (`meta.next` is `{ offset }`, `{ cursor }` or `null`; pass a cursor back as `cursor`); when a stage ends, `meta.fallover` lists the next feeds in order (`category_older`, `category_network`, `category` with `via`, `for_you`, `all`; `feed` with `ref` is declared in 0.7.60 but not sent yet, so skip kinds you cannot open). One call for a category's modules: `const { data } = await r.discovery.category({ category: 'science' })` returns `stories`, `network`, `clips`, `people`, `groups`, each `{ items, ms, reason? }`. Watch's Minds videos: `const { data, meta } = await r.discovery.videos({ limit: 12 })` returns public video posts in hot order from a list shared per app (rebuilt about once a minute), each re-checked per call for the viewer; page on `meta.next_cursor`. With no category about one row in four is an open-network clip (0.7.78): `isWatchNetworkClip(row)` tells `{ kind: 'social', id, post: SocialPost }` from a `Post`; open and react to it as the network's post (its `id` is never a Minds id).
-  - Progressive Discover feed (0.7.71): `const feed = r.discovery.createProgressiveFeed({ networks, category, recommend, top: { ref: 'builtin:all' }, seen, seenClusters }); const round = await feed.next(part => draw(part))` opens one `createFeed` session per source (Minds with the radar and suggestions, one per network with `public_trends`) and hands each source's page on as a `DiscoveryPart` (`{ source, round, modules, composed?, mixed? }`) the moment it lands, instead of a page that waits for its slowest network (up to 15 s); a round waits `DISCOVERY_STRAGGLER_MS` past its first answer and rejects only when every source failed. The first load is held until Minds and one other network answered (or `FIRST_SCREEN_MS`, 2.5 s, after the first answer; `firstScreenMs: VISITOR_FIRST_SCREEN_MS` for a visitor) and arrives as one `composed: true` part from `composeFirstScreen`: the top's first post when it is a playable video, else a picture lead from the best 8 by engagement (never a story, rail, video strip, column, `isSensitivePost` post or `linksAdultSite` porn link; 0.7.80: never a post with no picture or clip and no engagement while the screen holds one with either, which then leads: media and engagement, else media, else engagement, as `mergeDiscoveryArrival` leads a feed's top and the feed after a line), then every network's posts by engagement (`DiscoveryEngagementMerge`) with row 2 from another network than the lead's when one is left (`FIRST_SCREEN_NETWORK_ROWS`), a story as row 3 and a rail as row 5, nothing dropped. Merge later `mixed` parts with `mergeDiscoveryArrival(rows, arriving, reachedIds)`. `top`/`seen`/`seenClusters`/`bucket` reach every session; the top is read once per open. Also `retryFailed()`, `onStatus(listener)`, `setNetworks(catalog)`; settings `perSource`, `firstScreen`, `onLanded`. For you: `createProgressiveFeed({ createFeed: o => r.discovery.createPersonalFeed(o) }, options, { perSource: false })`. A session's `seen` now also leaves seen network posts out of trend pages, previews and topic pages; in a category a topic page with nothing new ends its topic and after `DISCOVERY_EMPTY_TOPIC_PAGES` (3) in a row the network's other topics are skipped.
+  - Progressive Discover feed (0.7.71): `const feed = r.discovery.createProgressiveFeed({ networks, category, recommend, top: { ref: 'builtin:all' }, seen, seenClusters }); const round = await feed.next(part => draw(part))` opens one `createFeed` session per source (Minds with the radar and suggestions, one per network with `public_trends`) and hands each source's page on as a `DiscoveryPart` (`{ source, round, modules, composed?, mixed? }`) the moment it lands, instead of a page that waits for its slowest network (up to 15 s); a round waits `DISCOVERY_STRAGGLER_MS` past its first answer and rejects only when every source failed. The first load is held until Minds and one other network answered (or `FIRST_SCREEN_MS`, 2.5 s, after the first answer; `firstScreenMs: VISITOR_FIRST_SCREEN_MS` for a visitor) and arrives as one `composed: true` part from `composeFirstScreen`: the top's first post when it is a playable video, else a picture lead from the best 8 by engagement (never a story, rail, video strip, column, `isSensitivePost` post or `linksAdultSite` porn link; 0.7.80: never a post with no picture or clip and no engagement while the screen holds one with either, which then leads: media and engagement, else media, else engagement, as `mergeDiscoveryArrival` leads a feed's top and the feed after a line), then every network's posts by engagement (`DiscoveryEngagementMerge`) with row 2 from another network than the lead's when one is left (`FIRST_SCREEN_NETWORK_ROWS`), a story as row 3 and a rail as row 5, nothing dropped. Merge later `mixed` parts with `mergeDiscoveryArrival(rows, arriving, reachedIds)`. `top`/`seen`/`seenClusters`/`bucket` reach every session; the top is read once per open. Also `retryFailed()`, `onStatus(listener)`, `setNetworks(catalog)`; settings `perSource`, `firstScreen`, `onLanded`. For you: `createProgressiveFeed({ createFeed: o => r.discovery.createPersonalFeed(o) }, options, { perSource: false })`. A session's `seen` now also leaves seen network posts out of trend pages, previews and topic pages; in a category a topic page with nothing new ends its topic and after `DISCOVERY_EMPTY_TOPIC_PAGES` (3) in a row the network's other topics are skipped. 0.7.84: a featured module carries `theme` only when its lead window was themed so and most of its own posts were judged into that category (a category feed's posts, by the read's category filter); a feed with no category titles every module by its kind alone ("Videos", not "Videos in Technology" over an unjudged Nostr clip). A post is shown once by every identity (`discoveryItemIdentities(item)`: its key, an open-network post's network id, and each media file by address and by content hash, so a second note carrying the same clip is the same post) across a session's pages, a progressive feed's sources (`withoutSeenItems` takes identities or keys), `mergeDiscoveryArrival` and gallery pooling; `withoutRepeatedDiscoveryItems(rows, shown)` does the same for an app's own rows.
   - Viral read (0.7.59; off until the server enables it for the app): `const { data } = await r.protocols.getPublicViral({ media: 'video', category: 'science', limit: 20 })` (member key, users:read + posts:read, never cached) or keyless `visitor.protocols.getSharedViral(projectId, { media: 'video', compass: 'hide' })` (visitors send compass `all` or `hide` only). Params, all optional: `network` (all, minds, bluesky, activitypub, nostr), `category`, `media: 'video'`, `limit` 5/10/20/40, `cursor` (the last page's; a cursor whose 30-minute build expired ends the list), `compass`. Each item: `key` (stable; drop ones already shown), `protocol`, `post` (checking `protocol` narrows it: `ViralMindsCard` for minds, open at /post/:id; otherwise a `SocialPost`), `label` viral/rising/hot, `score`, `rank`, `category`, `velocity` (show counts with `countsReportedBy` as reported, never verified), `spread`. A visitor's read serves media only where the server cleared it, so even with `media: 'video'` some items arrive with the video withheld (empty `media`): `import { viralItemHasVideo } from '@recursiv/sdk'` and keep `data.items.filter(viralItemHasVideo)` before a vertical video player. `status` ok/building/screening/off: off resolves with no items, and `getSharedViral` also resolves an older API's 401 `missing_api_key` as off; `getPublicViral` throws every 401/403 (never off), so catch it and skip that step.
   - Public trends: require `public_trends` from `publicNetworks()`, then `getPublicTrends({ protocol, limit?, cursor?, compass?, media? })` (`compass: 'hide'` leaves out politics, 0.7.62; `media: 'video'`, 0.7.73, Bluesky: the network's own window of video posts, a `kind: posts` page paged by its cursor, no category or layout, 404 `unsupported_protocol` for a network without one, 400 on an API that predates it; keyless `getSharedTrends(projectId, { ..., media: 'video' })` holds only clips a visitor may see and counts the rest in `mediaFilter.withheld`); render `kind: topics` as source topics and `kind: posts` as source posts. With `trend_feed`, open only a returned current topic using `getPublicTrendFeed({ protocol, topic: trend.nativeId, limit?, cursor? })`. Show provider, observedAt and provider_ranked_window coverage; null rankingWindow is unknown, not a daily/global ranking. Preserve source order, canonical IDs and readRef, and opaque cursors. Topic catalogs do not paginate; Mastodon trends stop at 200 source positions. Both methods require users:read plus posts:read on the current human app key; Nostr trends are unsupported. Propagate errors; trend_unavailable means refresh the topic list. No ingestion or native writes.
   - One outlet count per story (0.7.71): a radar story (list, story read, archive), a World Today story (`outlets`, with `outlet_count` its total and `lane_mix` its lanes), a category strip story, a `feeds.top`/`feeds.stories` story and a search story carry `outlets: { total, mainstream, independent, other }`, the distinct outlets of the articles the story lists (an allow-listed outlet once, an unlisted host in `other`; the buckets sum to `total`). Show `outlets.total`; `sources.outlet` counts articles. `DiscoveryCluster.outletCount` reads it. An older server omits it.
@@ -855,6 +895,7 @@ await r.appSubscriptions.changeTier({ tier: 'pro', proration_date: quote.prorati
 - `r.dispatcher` — Task queue: `tasks()`, `create()`, `claimNext()`, `complete()`, `release()`, `stats()`, `signals()`, `outcomes()`, `staleItems()`, `stuckItems()`, `discoveries()`
 - `r.dispatcher` (webhooks): `createWebhook()`, `listWebhooks()`, `updateWebhook()`, `deleteWebhook()`, `testWebhook()`, `webhookDeliveries()`, `cleanupWebhookLogs()`
 - `r.goals` — Org goals that dispatcher tasks roll up into: `list()`, `get()`, `create()`, `update()`, `archive()`. Tasks link via `goal_id` on `r.dispatcher.create()/update()`; `tasks({ goal_id })` filters (use `'none'` for goal-less tasks).
+- `r.linkPreview` — Open Graph card for a public link: `get(url)` answers `{ data: LinkPreview | null }` (null: no preview, show the plain link); keyless clients may call it. For a link in a chat message pass where it came from, `get(url, { messageId })` (or `{ conversationId }` before the message has an id), on a signed-in key with `chat:read`: the link is fetched only when it is in the named message and a person wrote that message, or when the caller wrote the same address in that conversation (a message, or the card link of a Minds post they shared there), else `{ data: null, refused: 'ai_link' }` with nothing fetched; 401 without a key, 404 for a message or conversation the caller cannot read. A `source` with no id rejects with `ValidationError` and sends nothing. Never pass `source` in an encrypted conversation: the server cannot read it, so every link would be refused; the app's own rule decides there.
 
 ```typescript
 // Create a goal and group tasks under it (personal keys: pass organization_id)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recursiv/sdk",
-  "version": "0.7.82",
+  "version": "0.7.89",
   "description": "TypeScript SDK for the Recursiv API",
   "license": "FSL-1.1-ALv2",
   "type": "module",
@@ -13,6 +13,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./assistant": {
+      "types": "./dist/assistant/index.d.ts",
+      "import": "./dist/assistant/index.js",
+      "default": "./dist/assistant/index.js"
+    },
     "./react": {
       "types": "./dist/react/index.d.ts",
       "import": "./dist/react/index.js",
@@ -22,6 +27,11 @@
       "types": "./dist/next/index.d.ts",
       "import": "./dist/next/index.js",
       "default": "./dist/next/index.js"
+    },
+    "./privacy": {
+      "types": "./dist/privacy/index.d.ts",
+      "import": "./dist/privacy/index.js",
+      "default": "./dist/privacy/index.js"
     }
   },
   "files": [