@recursiv/sdk 0.7.26 → 0.7.27

package/README.md

@@ -110,7 +110,7 @@ for await (const chunk of r.agents.chatStream(agent.id, { message: 'Hello!' }))
 | `r.admin` | User management, stats, content reports (`listReports`, `resolveReport`, `dismissReport`) |
 | `r.dispatcher` | Task queue, claims, signals, outcomes, webhooks |
 | `r.goals` | Org goals with task rollups (group dispatcher tasks) |
-| `r.protocols` | Public reading: `publicNetworks`, `searchPublicProfiles`, `getPublicProfile`, `getPublicAuthorFeed`, `getFollowingFeed`, `getPublicConversation`, `getPublicTrends`, `getPublicTrendFeed`; private app subscriptions: `listSubscriptions`, `subscribeToProfile`, `unsubscribeFromProfile`, `onSubscriptionChange`. `list` returns bounded adapter `maturity`, `limitations`, and exhaustive `supported`/`planned`/`unsupported` implementation capabilities (not provider health or enablement); settings, candidate refresh/status, search, and read-only quarantined candidate review via `listCandidates` / `getCandidate` |
+| `r.protocols` | Private Minds safety: `sourceControls` (current enablement and saved choices), `setSourceControl`, `onSourceControlChange`, `reportSource`. Delegated accounts: `nativeSocialAccounts`, `startNativeSocialConnection`, `finishNativeSocialConnection`, `disconnectNativeSocialAccount`. Reviewed replies and optional linked posts: `prepareNativeReply`, `submitNativeReply`, `nativeReplyStatus`, `nativeReplyHistory`, `prepareNativeReplyRemoval`, `removeNativeReply` (require deployed API support and app enablement). Public reading: `publicNetworks`, `searchPublicProfiles`, `getPublicProfile`, `getPublicAuthorFeed`, `getFollowingFeed`, `getPublicConversation`, `getPublicTrends`, `getPublicTrendFeed`; private app subscriptions: `listSubscriptions`, `subscribeToProfile`, `unsubscribeFromProfile`, `onSubscriptionChange`. `list` returns bounded adapter `maturity`, `limitations`, and exhaustive `supported`/`planned`/`unsupported` implementation capabilities (not provider health or enablement); settings, candidate refresh/status, search, and read-only quarantined candidate review via `listCandidates` / `getCandidate` |
 
 Full reference: see [llm.md](./llm.md) (ships with this package) or the type definitions in `dist/`.
 
@@ -459,3 +459,114 @@ configured. After an uncertain submission, check
 `getNativeNostrPost(identityId, preview.postId ?? preview.eventId)`: deletion uses
 the original note's `postId`, while publication uses the new `eventId`. Any
 user-selected retry must keep the same intent and signed event.
+
+When the deployed API advertises `reply_text_note`, the same method can prepare
+`{ action: 'reply', content: draftText, parentId: selectedPost.nativeId }`. Review
+the returned parent, root, participants, relay and exact event before asking the
+signer to sign. The API constructs verified NIP-10 references; callers cannot
+inject tags, participant lists, relay URLs or signing keys. Reply prepare/submit
+also require `posts:read`. This capability remains off until the shared reply UI
+and live delivery are verified. Only public kind-1 notes are supported; additional
+participant selection is unfinished. `textTruncated` labels an abbreviated source
+preview. Preparation and submission never automatically retry; check the event ID
+after an uncertain result before choosing a retry of the identical signed event.
+
+### Delegated Bluesky and ActivityPub accounts
+
+These methods require the same signed-in human app key throughout. The API must
+enable the app and deploy the authorization schema before use.
+
+```ts
+const { data: connection } = await r.protocols.startNativeSocialConnection({
+  protocol: 'bluesky', identifier: 'alice.bsky.social',
+})
+// Navigate to connection.authorizationUrl. On the configured app callback:
+const { data: account } = await r.protocols.finishNativeSocialConnection({
+  protocol: 'bluesky', state, code, iss,
+})
+const { data: accounts } = await r.protocols.nativeSocialAccounts()
+await r.protocols.disconnectNativeSocialAccount(account.id)
+```
+
+ActivityPub uses an operator-approved HTTPS server origin as `identifier` and
+requires Mastodon-compatible OAuth metadata with S256 PKCE. The server configures
+the exact callback path `/social/connect/callback/:protocol`; the app must remove
+its query from browser history immediately and never log codes. No password or
+native token is sent through these SDK methods. Start and callback are single-use
+requests and are never automatically retried. If a callback result is uncertain,
+refresh the account list before starting again.
+
+Connection does not approve publication. The account's `capabilities` lists only
+implemented actions, currently empty for these adapters. Local disconnect takes
+effect even when `providerRevocation` is `unconfirmed`; the user can also revoke
+Minds from their network's authorized-app settings.
+
+### One reviewed reply across selected accounts
+
+The shared reply API is off by default. Deploy its required schema/API and finish
+live authorization and delivery verification before enabling it. This example
+prepares a preview; it does not publish anything:
+
+```ts
+const { data: preview } = await r.protocols.prepareNativeReply({
+  clientMutationId: crypto.randomUUID(), text: draftText,
+  parent: { protocol: 'bluesky', nativeId: selectedPost.nativeId },
+  accountIds: [blueskyAccount.id, activityPubAccount.id],
+  linkedPostAccountIds: [activityPubAccount.id],
+})
+// Review each delivery's account, protocol, kind, parent and exact wireText.
+// After the user approves selected delivery IDs:
+await r.protocols.submitNativeReply(preview.id, { approve: true, deliveryIds: approvedDeliveryIds })
+```
+
+Use `linkedPostAccountIds` only after the user selects a standalone post with the
+source link on that different network. It is not a matching threaded reply, and
+a denied same-network reply never falls back automatically. Verified cross-network
+thread mappings are not implemented here. Nostr uses the connected client signer
+described above. Preserve the mutation
+ID while recovering an uncertain preparation; read `nativeReplyStatus(preview.id)` to
+show each destination's result. Repeated submit reconciles an attempted delivery
+without publishing it again. Removal uses a fresh `prepareNativeReplyRemoval`
+preview and explicit `removeNativeReply` approval for the selected own posts.
+
+For a selected unsent or definitively rejected destination, the same prepare
+method accepts `recoverFrom: { batchId: preview.id, deliveryIds: selectedIds }`
+with a **new** mutation ID, the same source/accounts and freshly reviewed text.
+Preserve that new ID if preparation is uncertain. The server creates the fresh
+review and disables only those old destinations atomically; `replacedBy` points
+to the new batch. `recoverable` describes saved eligibility, while current account,
+source and safety checks still apply. Sending, unknown, accepted or published
+destinations cannot be resent this way. The fresh preview still needs explicit
+approval; completed destinations retain their outcomes.
+
+`nativeReplyHistory` pages through one private history containing Bluesky/ActivityPub
+drafts and delivery results, plus Nostr replies and linked posts once submitted. It also includes unsent or expired preparations. The
+summary contains a bounded preview of the user's own text and source references,
+not old remote parent text or approval material. Opening a result with
+`nativeReplyStatus(id)` does not send anything. Reading remains available when
+new replies are disabled; it does not refresh credentials or contact a network.
+Nostr items have `type: "nostr"`. `nativeNostrReplyResult(id)` checks the saved event
+on its recorded relay without signing or resending. It requires the same connected
+identity and preserves historical publication/deletion evidence separately from
+`lastReadBack`. A relay absence is not proof of global deletion. Signatures and
+intents are never retained in history.
+
+```ts
+const { data: history } = await r.protocols.nativeReplyHistory({ limit: 20 })
+// Read a saved result without submitting it.
+const firstResult = history.items[0]
+if (firstResult) {
+  if ('type' in firstResult && firstResult.type === 'nostr') {
+    await r.protocols.nativeNostrReplyResult(firstResult.id)
+  } else await r.protocols.nativeReplyStatus(firstResult.id)
+}
+if (history.cursor) {
+  const { data: next } = await r.protocols.nativeReplyHistory({ limit: 20, cursor: history.cursor })
+  console.log(next.items.length)
+}
+```
+
+Keep the cursor opaque and discard it when the app or signed-in user changes.
+History order is fixed by creation time, so later delivery updates do not move
+older entries across page boundaries. Reopen each result for its current saved
+state and obtain a fresh review before a new write.

package/dist/index.d.ts

@@ -160,7 +160,7 @@ export { EnvVarsResource } from './resources/env-vars.js';
 export type { QueryDatabaseInput, QueryResult } from './resources/databases.js';
 export { GitHubResource } from './resources/github.js';
 export { DeploymentsResource } from './resources/deployments.js';
-export type { PrepareProtocolServersInput, PreparedProtocolServers, ProtocolServerPreparation } from './resources/deployments.js';
+export type { PrepareProtocolServersInput, PreparedProtocolServers, ProtocolServerPreparation, ProtocolServerUpgradePreview, ProtocolServerUpgradeInput, ProtocolServerUpgradeStatus } from './resources/deployments.js';
 export { IntegrationsResource } from './resources/integrations.js';
 export type { ExecuteToolInput, ExecuteToolResult } from './resources/integrations.js';
 export { ProjectBrainResource } from './resources/project-brain.js';
@@ -189,7 +189,7 @@ export type { UploadMediaInput, UploadUrlInput, UploadUrlResult } from './resour
 export { WalletResource } from './resources/wallet.js';
 export { ProtocolsResource } from './resources/protocols.js';
 export { PROTOCOL_ADAPTER_MATURITIES, PROTOCOL_CAPABILITY_OPERATIONS, PROTOCOL_CAPABILITY_STATUSES, } from './resources/protocols.js';
-export type { SocialProfile, SocialSubscription, SocialSubscriptionChange, SocialProfilePage, SocialNetwork, SocialPost, SocialConversation, SocialTrend, SocialTrendProvenance, SocialTrends, SocialTrendFeed, SocialAuthorFeed, SocialFollowingFeed, SocialFollowingSource, SearchPublicProfilesParams, HostedProtocolConnections, HostedProtocol, HostedProtocolIdentity, HostedNostrChallenge, HostedNostrIdentityProof, NativeNostrPrepareInput, NativeNostrPrepared, NativeNostrAccount, NativeNostrPostState, NativeNostrReceipt, HostedPostPreview, ConnectHostedIdentityInput, PreviewHostedPostInput, PublishHostedPostInput, ListProtocolCandidatesParams, ProtocolAdapterMaturity, ProtocolAdapterMetadata, ProtocolCandidateListResponse, ProtocolCandidatePageMeta, ProtocolCapabilityOperation, ProtocolCapabilityStatus, ProtocolCollectionStatus, ProtocolQuarantinedCandidate, ProtocolRefreshResult, ProtocolSettings, ProtocolSettingsUpdateResult, UpdateSettingsInput as UpdateProtocolSettingsInput, } from './resources/protocols.js';
+export type { SocialProfile, SocialSubscription, SocialSubscriptionChange, SocialProfilePage, SocialNetwork, SocialPost, SocialConversation, SocialTrend, SocialTrendProvenance, SocialTrends, SocialTrendFeed, SocialAuthorFeed, SocialFollowingFeed, SocialFollowingSource, SearchPublicProfilesParams, HostedProtocolConnections, HostedProtocol, HostedProtocolIdentity, HostedNostrChallenge, HostedNostrIdentityProof, NativeNostrPrepareInput, NativeNostrPrepared, NativeNostrAccount, NativeNostrPostState, NativeNostrReceipt, NativeSocialProtocol, FederationIdentity, FederationIdentityView, NativeSocialAccount, NativeSocialCallbackInput, NativeReplyPrepareInput, NativeReplyReceipt, NativeReplyBatch, NativeReplyHistory, NativeDelegatedReplyHistoryItem, NativeNostrReplyResult, NativeNostrReplyHistoryItem, NativeReplyRemovalReceipt, NativeReplyRemovalPreview, SocialSourceRef, SocialSourceControl, SocialSourceControlChange, HostedPostPreview, ConnectHostedIdentityInput, PreviewHostedPostInput, PublishHostedPostInput, ListProtocolCandidatesParams, ProtocolAdapterMaturity, ProtocolAdapterMetadata, ProtocolCandidateListResponse, ProtocolCandidatePageMeta, ProtocolCapabilityOperation, ProtocolCapabilityStatus, ProtocolCollectionStatus, ProtocolQuarantinedCandidate, ProtocolRefreshResult, ProtocolSettings, ProtocolSettingsUpdateResult, UpdateSettingsInput as UpdateProtocolSettingsInput, } from './resources/protocols.js';
 export { InboxResource } from './resources/inbox.js';
 export { NetworkResource } from './resources/network.js';
 export { SimulatorResource } from './resources/simulator.js';

package/dist/resources/deployments.d.ts

@@ -62,6 +62,12 @@ export interface PreparedProtocolServers {
     runtime_status: 'unverified';
 }
 export interface ProtocolServerPreparation {
+    /** Non-secret locator for recovering inspection after an operator/client restart. */
+    upgrade?: {
+        revision: string;
+        image: string;
+        phase: ProtocolServerUpgradeStatus['phase'];
+    };
     /** Provider process observation only; protocol interoperability remains unverified. */
     provider_status: 'running' | 'stopped' | 'transitioning' | 'unhealthy' | 'unknown';
     id: string;
@@ -87,6 +93,32 @@ export interface HostedServiceScope {
 export interface HostedServiceOperation extends HostedServiceScope {
     request_hash: string;
 }
+export interface ProtocolServerUpgradePreview {
+    id: string;
+    provider_service_uuid: string;
+    revision: string;
+    from_image: string;
+    to_image: string;
+    restart_services: ['pds', 'activitypub', 'nostr'];
+    provider_status: 'running' | 'stopped';
+    operation: 'preview';
+    runtime_status: 'unverified';
+    storage_identity_verification_required: true;
+}
+export interface ProtocolServerUpgradeInput extends HostedServiceOperation {
+    image: string;
+    revision: string;
+}
+export interface ProtocolServerUpgradeStatus {
+    revision: string;
+    phase: 'applying' | 'configuration_saved' | 'restarting' | 'restart_requested';
+    runtime_status: 'unverified';
+    automatic_retry_allowed: false;
+    configuration_matches?: boolean;
+    provider_status?: ProtocolServerPreparation['provider_status'];
+    restart_services?: ['pds', 'activitypub', 'nostr'];
+    identity_verification_required?: true;
+}
 export interface HostedServiceReservation {
     id: string;
     provider_service_uuid: string | null;
@@ -115,6 +147,16 @@ export declare class DeploymentsResource {
         project_id: string;
         network_id: string;
     }): Promise<SingleResponse<ProtocolServerPreparation>>;
+    /** Read-only staging image proposal; does not update or restart servers.
+     * Requires an unbound owner key and the server-configured approved image digest. */
+    previewProtocolServerUpgrade(input: HostedServiceOperation & {
+        image: string;
+    }): Promise<SingleResponse<ProtocolServerUpgradePreview>>;
+    /** Apply a reviewed staging upgrade once. Never automatically retry a lost response.
+     * Acceptance does not establish live identity, storage contents or interoperability. */
+    upgradeProtocolServers(input: ProtocolServerUpgradeInput): Promise<SingleResponse<ProtocolServerUpgradeStatus>>;
+    /** Read the saved upgrade and provider configuration; never replays a write. */
+    getProtocolServerUpgrade(input: ProtocolServerUpgradeInput): Promise<SingleResponse<ProtocolServerUpgradeStatus>>;
     /** Queue a single activation after verifying the saved provider configuration and secrets.
      * A 202 response is not evidence of live runtime health. */
     startProtocolServers(input: {

package/dist/resources/deployments.js

@@ -26,6 +26,20 @@ export class DeploymentsResource {
     getProtocolServerPreparation(scope) {
         return this.client.get('/deployments/protocol-servers', { project_id: scope.project_id, network_id: scope.network_id });
     }
+    /** Read-only staging image proposal; does not update or restart servers.
+     * Requires an unbound owner key and the server-configured approved image digest. */
+    previewProtocolServerUpgrade(input) {
+        return this.client.post('/deployments/protocol-servers/upgrade-preview', input);
+    }
+    /** Apply a reviewed staging upgrade once. Never automatically retry a lost response.
+     * Acceptance does not establish live identity, storage contents or interoperability. */
+    upgradeProtocolServers(input) {
+        return this.client.post('/deployments/protocol-servers/upgrade', input, { retry: false });
+    }
+    /** Read the saved upgrade and provider configuration; never replays a write. */
+    getProtocolServerUpgrade(input) {
+        return this.client.post('/deployments/protocol-servers/upgrade-status', input);
+    }
     /** Queue a single activation after verifying the saved provider configuration and secrets.
      * A 202 response is not evidence of live runtime health. */
     startProtocolServers(input) {

package/dist/resources/moderation.d.ts

@@ -1,6 +1,6 @@
 import type { HttpClient } from '../client.js';
 import type { SingleResponse } from '../types.js';
-export type ModerationTargetType = 'post' | 'user' | 'message' | 'community' | 'agent';
+export type ModerationTargetType = 'post' | 'user' | 'message' | 'community' | 'agent' | 'source_actor' | 'source_post';
 export type ModerationActionType = 'down_rank' | 'label' | 'remove' | 'suspend' | 'ban';
 export type ModerationAppealStatus = 'none' | 'pending' | 'upheld' | 'overturned';
 export interface ModerationPrinciple {
@@ -53,7 +53,8 @@ export interface OwnModerationLog {
     actions: OwnModerationAction[];
 }
 export interface ApplyModerationActionInput {
-    target_type: ModerationTargetType;
+    /** Source actions are resolved through the scoped report queue. */
+    target_type: Exclude<ModerationTargetType, 'source_actor' | 'source_post'>;
     target_id: string;
     action: ModerationActionType;
     label?: string;

package/dist/resources/protocols.d.ts

@@ -162,10 +162,199 @@ export interface HostedNostrIdentityProof {
 export type NativeNostrPrepareInput = {
     action: 'publish';
     content: string;
+} | {
+    action: 'reply';
+    content: string;
+    parentId: string;
+} | {
+    action: 'linked_post';
+    content: string;
+    source: {
+        protocol: NativeSocialProtocol;
+        nativeId: string;
+        readRef?: string;
+    };
 } | {
     action: 'delete';
     postId: string;
 };
+export type NativeSocialProtocol = 'bluesky' | 'activitypub';
+export interface NativeSocialAccount {
+    id: string;
+    protocol: NativeSocialProtocol;
+    nativeId: string;
+    serverUrl: string;
+    handle: string;
+    connectedAt: string;
+    capabilities: string[];
+}
+/** A Minds-hosted ActivityPub identity for this app user. Keys never leave the platform. */
+export interface FederationIdentity {
+    identifier: string;
+    actorUri: string;
+    handle: string;
+    enabled: boolean;
+    origin: string;
+}
+export interface FederationIdentityView {
+    enabled: boolean;
+    origin: string | null;
+    identity: FederationIdentity | null;
+}
+export interface SocialSourceRef {
+    protocol: 'bluesky' | 'activitypub' | 'nostr';
+    kind: 'actor' | 'post';
+    nativeId: string;
+}
+export interface SocialSourceControl {
+    id: string;
+    source: SocialSourceRef;
+    control: 'block' | 'mute' | 'hide';
+    scope: 'minds';
+    createdAt: string;
+}
+export type SocialSourceControlChange = Omit<SocialSourceControl, 'id' | 'createdAt'> & {
+    enabled: boolean;
+};
+export interface NativeReplyPrepareInput {
+    clientMutationId: string;
+    text: string;
+    parent: {
+        protocol: SocialSourceRef['protocol'];
+        nativeId: string;
+        readRef?: string;
+    };
+    accountIds: string[];
+    /** Selected different-network accounts to review as standalone posts with a source link. */
+    linkedPostAccountIds?: string[];
+    /** Fresh review of selected unsent or definitively rejected deliveries. The original selected reviews are atomically fenced; preserve this mutation ID on retry. */
+    recoverFrom?: {
+        batchId: string;
+        deliveryIds: string[];
+    };
+}
+export interface NativeReplyReceipt {
+    state: 'published' | 'accepted' | 'unknown' | 'rejected';
+    nativeId: string | null;
+    sourceUrl: string | null;
+    providerId: string | null;
+    acknowledged: boolean;
+    readBack: 'matched' | 'absent' | 'unavailable';
+}
+export interface NativeReplyRemovalReceipt {
+    /** Absence is observed on the owning server; this is not global erasure. */
+    state: 'absent' | 'accepted' | 'unknown' | 'rejected';
+    acknowledged: boolean;
+    readBack: 'absent' | 'present' | 'unavailable';
+}
+export interface NativeReplyRemovalPreview {
+    id: string;
+    previews: Array<{
+        deliveryId: string;
+        removalId: string;
+        expiresAt: string;
+        protocol: NativeSocialProtocol;
+        nativeId: string;
+        providerId: string;
+        sourceUrl: string;
+        revision: string | null;
+        text: string | null;
+        additionalContent: boolean;
+        account: {
+            nativeId: string;
+            handle: string;
+            serverUrl: string;
+        } | null;
+    }>;
+    errors: Record<string, {
+        code: string;
+        message: string;
+    }>;
+}
+export interface NativeReplyBatch {
+    id: string;
+    clientMutationId: string;
+    expiresAt: string;
+    deliveries: Array<{
+        id: string;
+        grantId: string;
+        protocol: NativeSocialProtocol;
+        kind: 'reply' | 'linked_post';
+        state: 'prepared' | 'sending' | NativeReplyReceipt['state'];
+        attemptedAt: string | null;
+        /** Saved attempt eligibility only; source, account authority and app/provider gates are checked again during preparation. */
+        recoverable?: boolean;
+        /** Newer batch that replaced this destination's approval. This old destination cannot publish. */
+        replacedBy?: string;
+        account: {
+            nativeId: string;
+            handle: string;
+            serverUrl: string;
+        } | null;
+        parent: {
+            protocol: SocialSourceRef['protocol'];
+            nativeId: string;
+            sourceUrl: string;
+            authorId: string;
+            authorHandle: string;
+            text: string;
+            textTruncated?: boolean;
+        };
+        text: string;
+        wireText: string;
+        receipt: NativeReplyReceipt | null;
+        removal: {
+            id: string;
+            expiresAt: string;
+            attemptedAt: string | null;
+            receipt: NativeReplyRemovalReceipt | null;
+        } | null;
+    }>;
+}
+export interface NativeSocialCallbackInput {
+    protocol: NativeSocialProtocol;
+    state: string;
+    code?: string;
+    iss?: string;
+    error?: string;
+}
+export interface NativeDelegatedReplyHistoryItem {
+    id: string;
+    createdAt: string;
+    text: string;
+    textTruncated: boolean;
+    source: Pick<NativeReplyBatch['deliveries'][number]['parent'], 'protocol' | 'nativeId' | 'sourceUrl'>;
+    deliveries: Array<Pick<NativeReplyBatch['deliveries'][number], 'id' | 'protocol' | 'kind' | 'state' | 'attemptedAt' | 'account' | 'recoverable' | 'replacedBy'> & {
+        removalReceipt: NativeReplyRemovalReceipt | null;
+    }>;
+}
+export interface NativeNostrReplyResult {
+    id: string;
+    createdAt: string;
+    text: string;
+    source: {
+        protocol: SocialSourceRef['protocol'];
+        nativeId: string;
+        sourceUrl: string;
+    };
+    identityId: string;
+    pubkey: string;
+    relay: string;
+    eventId: string;
+    action: 'reply' | 'linked_post';
+    receipt: NativeNostrReceipt;
+    checkedAt: string | null;
+    lastReadBack: NativeNostrReceipt['readBack'];
+}
+export interface NativeNostrReplyHistoryItem extends NativeNostrReplyResult {
+    type: 'nostr';
+    textTruncated: boolean;
+}
+export interface NativeReplyHistory {
+    /** One private history, including client-signed Nostr replies once submitted. */
+    items: Array<NativeDelegatedReplyHistoryItem | NativeNostrReplyHistoryItem>;
+    cursor: string | null;
+}
 export interface NativeNostrPrepared {
     intent: string;
     event: {
@@ -175,17 +364,42 @@ export interface NativeNostrPrepared {
         tags: string[][];
     };
     eventId: string;
-    action: 'publish' | 'delete';
+    action: 'publish' | 'reply' | 'linked_post' | 'delete';
     identityId: string;
     pubkey: string;
     relay: string;
     expiresAt: string;
     postId?: string;
+    parent?: {
+        protocol: 'nostr';
+        nativeId: string;
+        authorId: string;
+        authorHandle: string;
+        sourceUrl: string;
+        text: string;
+        textTruncated: boolean;
+        root: {
+            nativeId: string;
+            authorId: string;
+            sourceUrl: string;
+        };
+        participants: string[];
+        tags: string[][];
+    };
+    source?: {
+        protocol: NativeSocialProtocol;
+        nativeId: string;
+        authorId: string;
+        authorHandle: string;
+        sourceUrl: string;
+        text: string;
+        textTruncated?: boolean;
+    };
 }
 export interface NativeNostrAccount {
     enabled: boolean;
     identity: HostedProtocolIdentity | null;
-    capabilities: Array<'publish_original_text' | 'request_own_post_deletion'>;
+    capabilities: Array<'publish_original_text' | 'request_own_post_deletion' | 'reply_text_note' | 'publish_linked_text'>;
     signing?: 'client';
 }
 export interface NativeNostrPostState {
@@ -202,7 +416,7 @@ export interface NativeNostrReceipt {
     eventId: string;
     postId: string;
     relay: string;
-    action: 'publish' | 'delete';
+    action: 'publish' | 'reply' | 'linked_post' | 'delete';
     state: 'published' | 'deletion_requested' | 'unknown' | 'rejected';
     acknowledged: boolean;
     readBack: 'found' | 'absent' | 'unavailable';
@@ -380,10 +594,13 @@ export interface SocialFollowingFeed {
 export declare class ProtocolsResource {
     private client;
     private subscriptionListeners;
+    private sourceControlListeners;
     constructor(client: HttpClient);
     /** Confirmed changes from this SDK instance only. Unsubscribe when a view unmounts or its account changes. */
     onSubscriptionChange(listener: (change: SocialSubscriptionChange) => void): () => void;
     private subscriptionChanged;
+    /** Confirmed safety choices from this authenticated SDK instance. Unsubscribe when its account or view changes. */
+    onSourceControlChange(listener: (change: SocialSourceControlChange) => void): () => void;
     publicNetworks(): Promise<SingleResponse<SocialNetwork[]>>;
     /** Query the live public network. It does not import users or posts. */
     searchPublicProfiles(params: SearchPublicProfilesParams): Promise<SingleResponse<SocialProfilePage>>;
@@ -419,17 +636,113 @@ export declare class ProtocolsResource {
         limit?: number;
         cursor?: string;
     }): Promise<SingleResponse<SocialTrendFeed>>;
+    /** Prepare one exact shared reply preview. Keep the mutation ID across uncertain responses. */
+    prepareNativeReply(input: NativeReplyPrepareInput): Promise<SingleResponse<NativeReplyBatch>>;
+    /** Send only explicitly approved delivery IDs from this preview. Repeated submissions reconcile; they do not replay a write. */
+    submitNativeReply(id: string, input: {
+        approve: true;
+        deliveryIds: string[];
+    }): Promise<SingleResponse<NativeReplyBatch & {
+        errors: Record<string, {
+            code: string;
+            message: string;
+        }>;
+    }>>;
+    /** Read saved delivery results after refresh. This never publishes or contacts a source network. */
+    nativeReplyStatus(id: string): Promise<SingleResponse<NativeReplyBatch>>;
+    /** Page through this app user's saved delegated drafts/results. This never publishes, refreshes credentials or queries a source network. */
+    nativeReplyHistory(params?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<SingleResponse<NativeReplyHistory>>;
+    /** Review the current own posts before removal. A new preview replaces the previous approval. */
+    prepareNativeReplyRemoval(id: string, input: {
+        deliveryIds: string[];
+    }): Promise<SingleResponse<NativeReplyRemovalPreview>>;
+    /** Remove only selected, freshly reviewed destinations. Repeating approval never repeats a native delete. */
+    removeNativeReply(id: string, input: {
+        approve: true;
+        removals: Array<{
+            deliveryId: string;
+            removalId: string;
+        }>;
+    }): Promise<SingleResponse<NativeReplyBatch & {
+        errors: Record<string, {
+            code: string;
+            message: string;
+        }>;
+    }>>;
+    /** List this app user's delegated accounts. A connection is not approval to post. */
+    nativeSocialAccounts(): Promise<SingleResponse<{
+        enabled: boolean;
+        accounts: NativeSocialAccount[];
+    }>>;
+    /** Private source controls in this app, with bounded pagination. */
+    sourceControls(params?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<SingleResponse<{
+        enabled: boolean;
+        items: SocialSourceControl[];
+        cursor: string | null;
+    }>>;
+    /** Block/mute an actor or hide a post in Minds. This does not impersonate a native network block. */
+    setSourceControl(input: {
+        source: SocialSourceRef;
+        control: 'block' | 'mute' | 'hide';
+        enabled: boolean;
+        scope: 'minds';
+    }): Promise<SingleResponse<SocialSourceControlChange>>;
+    /** File a report in the app's existing moderation queue, using server-read public source evidence. */
+    reportSource(input: {
+        source: SocialSourceRef;
+        readRef?: string;
+        reason: string;
+        details?: string;
+        scope: 'minds';
+    }): Promise<SingleResponse<{
+        id: string;
+        status: string;
+        existing: boolean;
+        scope: 'minds';
+    }>>;
+    /** Open the returned authorization URL in the user's browser; never submit passwords or tokens. */
+    startNativeSocialConnection(input: {
+        protocol: NativeSocialProtocol;
+        identifier: string;
+    }): Promise<SingleResponse<{
+        protocol: NativeSocialProtocol;
+        authorizationUrl: string;
+    }>>;
+    /** Complete a single-use callback with the same signed-in app user. Remove its query from browser history; do not log codes. */
+    finishNativeSocialConnection(input: NativeSocialCallbackInput): Promise<SingleResponse<NativeSocialAccount>>;
+    /** Disable this app's saved authority even when the provider cannot acknowledge revocation. */
+    disconnectNativeSocialAccount(id: string): Promise<SingleResponse<{
+        disconnected: true;
+        providerRevocation: 'acknowledged' | 'unconfirmed';
+    }>>;
+    /** Current Minds-hosted ActivityPub state for this app user; never provisions. */
+    federationIdentity(): Promise<SingleResponse<FederationIdentityView>>;
+    /** Explicit opt-in; the platform provisions once and never rotates keys or re-enables a disabled identity on retry. */
+    enableFederationIdentity(): Promise<SingleResponse<FederationIdentityView>>;
+    /** Stops serving and signing for the identity; its stable URL and keys are retained by the platform. */
+    disableFederationIdentity(): Promise<SingleResponse<{
+        disabled: true;
+        identity: FederationIdentity;
+    }>>;
     /** Native writes are off unless enabled for this exact app; public readers are independent. */
     nativeNostrAccount(): Promise<SingleResponse<NativeNostrAccount>>;
     /** Prepare an exact event for review. A timeout never automatically creates another signing request. */
     prepareNativeNostr(id: string, input: NativeNostrPrepareInput): Promise<SingleResponse<NativeNostrPrepared>>;
-    /** Pass only the public signed event. After a timeout, read the prepared postId (delete) or eventId (publish).
+    /** Pass only the public signed event. After a timeout, read the prepared postId (delete) or eventId (publish/reply/linked_post).
      * Any user-selected retry keeps the same intent/event. */
     submitNativeNostr(id: string, input: {
         intent: string;
         event: HostedNostrIdentityProof;
         approve: true;
     }): Promise<SingleResponse<NativeNostrReceipt>>;
+    /** Check only the event bound to this private saved result; never sign, prepare or resend it. */
+    nativeNostrReplyResult(id: string): Promise<SingleResponse<NativeNostrReplyResult>>;
     getNativeNostrPost(id: string, postId: string): Promise<SingleResponse<NativeNostrPostState>>;
     /** Save a private reading subscription after resolving the immutable native ID. */
     subscribeToProfile(input: {

package/dist/resources/protocols.js

@@ -37,6 +37,7 @@ function hostedIdentityPath(id) {
 export class ProtocolsResource {
     client;
     subscriptionListeners = new Set();
+    sourceControlListeners = new Set();
     constructor(client) {
         this.client = client;
     }
@@ -54,6 +55,11 @@ export class ProtocolsResource {
             catch { /* Other mounted views still receive the change. */ }
         }
     }
+    /** Confirmed safety choices from this authenticated SDK instance. Unsubscribe when its account or view changes. */
+    onSourceControlChange(listener) {
+        this.sourceControlListeners.add(listener);
+        return () => { this.sourceControlListeners.delete(listener); };
+    }
     publicNetworks() {
         return this.client.get('/protocols/social/networks');
     }
@@ -90,6 +96,98 @@ export class ProtocolsResource {
     getPublicTrendFeed(params) {
         return this.client.get('/protocols/social/trend-feed', { protocol: params.protocol, topic: params.topic, limit: params.limit, cursor: params.cursor });
     }
+    /** Prepare one exact shared reply preview. Keep the mutation ID across uncertain responses. */
+    prepareNativeReply(input) {
+        return this.client.post('/protocols/social/replies/prepare', { clientMutationId: input.clientMutationId, text: input.text,
+            parent: { protocol: input.parent.protocol, nativeId: input.parent.nativeId,
+                ...(input.parent.readRef !== undefined ? { readRef: input.parent.readRef } : {}) }, accountIds: input.accountIds,
+            ...(input.linkedPostAccountIds !== undefined ? { linkedPostAccountIds: input.linkedPostAccountIds } : {}),
+            ...(input.recoverFrom !== undefined ? { recoverFrom: { batchId: input.recoverFrom.batchId, deliveryIds: input.recoverFrom.deliveryIds } } : {}) }, { retry: false });
+    }
+    /** Send only explicitly approved delivery IDs from this preview. Repeated submissions reconcile; they do not replay a write. */
+    submitNativeReply(id, input) {
+        hostedIdentityPath(id);
+        return this.client.post(`/protocols/social/replies/${encodeURIComponent(id)}/submit`, { approve: input.approve, deliveryIds: input.deliveryIds }, { retry: false });
+    }
+    /** Read saved delivery results after refresh. This never publishes or contacts a source network. */
+    nativeReplyStatus(id) {
+        hostedIdentityPath(id);
+        return this.client.get(`/protocols/social/replies/${encodeURIComponent(id)}`);
+    }
+    /** Page through this app user's saved delegated drafts/results. This never publishes, refreshes credentials or queries a source network. */
+    nativeReplyHistory(params = {}) {
+        return this.client.get('/protocols/social/replies', { limit: params.limit, cursor: params.cursor });
+    }
+    /** Review the current own posts before removal. A new preview replaces the previous approval. */
+    prepareNativeReplyRemoval(id, input) {
+        hostedIdentityPath(id);
+        return this.client.post(`/protocols/social/replies/${encodeURIComponent(id)}/removals/prepare`, { deliveryIds: input.deliveryIds }, { retry: false });
+    }
+    /** Remove only selected, freshly reviewed destinations. Repeating approval never repeats a native delete. */
+    removeNativeReply(id, input) {
+        hostedIdentityPath(id);
+        return this.client.post(`/protocols/social/replies/${encodeURIComponent(id)}/removals/submit`, { approve: input.approve,
+            removals: input.removals.map(value => ({ deliveryId: value.deliveryId, removalId: value.removalId })) }, { retry: false });
+    }
+    /** List this app user's delegated accounts. A connection is not approval to post. */
+    nativeSocialAccounts() {
+        return this.client.get('/protocols/social/accounts');
+    }
+    /** Private source controls in this app, with bounded pagination. */
+    sourceControls(params = {}) {
+        return this.client.get('/protocols/social/controls', { limit: params.limit, cursor: params.cursor });
+    }
+    /** Block/mute an actor or hide a post in Minds. This does not impersonate a native network block. */
+    async setSourceControl(input) {
+        const choice = { source: { protocol: input.source.protocol, kind: input.source.kind, nativeId: input.source.nativeId },
+            control: input.control, enabled: input.enabled, scope: input.scope };
+        const response = await this.client.post('/protocols/social/controls', choice, { retry: false });
+        const saved = response.data;
+        if (!saved || saved.scope !== choice.scope || saved.enabled !== choice.enabled || saved.control !== choice.control
+            || saved.source?.protocol !== choice.source.protocol || saved.source.kind !== choice.source.kind || saved.source.nativeId !== choice.source.nativeId) {
+            throw new ValidationError({ type: 'validation_error', code: 'source_control_unconfirmed', message: 'The saved safety choice could not be confirmed. Check your safety settings before trying again.' });
+        }
+        for (const listener of [...this.sourceControlListeners]) {
+            // A broken view must not turn a confirmed preference into a failed write.
+            try {
+                listener({ ...choice, source: { ...choice.source } });
+            }
+            catch { /* Continue notifying the other views. */ }
+        }
+        return response;
+    }
+    /** File a report in the app's existing moderation queue, using server-read public source evidence. */
+    reportSource(input) {
+        return this.client.post('/protocols/social/reports', { source: { protocol: input.source.protocol, kind: input.source.kind, nativeId: input.source.nativeId },
+            readRef: input.readRef, reason: input.reason, details: input.details, scope: input.scope }, { retry: false });
+    }
+    /** Open the returned authorization URL in the user's browser; never submit passwords or tokens. */
+    startNativeSocialConnection(input) {
+        return this.client.post('/protocols/social/oauth/start', { protocol: input.protocol, identifier: input.identifier }, { retry: false });
+    }
+    /** Complete a single-use callback with the same signed-in app user. Remove its query from browser history; do not log codes. */
+    finishNativeSocialConnection(input) {
+        const { protocol, state, code, iss, error } = input;
+        return this.client.post('/protocols/social/oauth/callback', { protocol, state,
+            ...(code !== undefined ? { code } : {}), ...(iss !== undefined ? { iss } : {}), ...(error !== undefined ? { error } : {}) }, { retry: false });
+    }
+    /** Disable this app's saved authority even when the provider cannot acknowledge revocation. */
+    disconnectNativeSocialAccount(id) {
+        hostedIdentityPath(id);
+        return this.client.delete(`/protocols/social/accounts/${encodeURIComponent(id)}`);
+    }
+    /** Current Minds-hosted ActivityPub state for this app user; never provisions. */
+    federationIdentity() {
+        return this.client.get('/protocols/social/federation/identity');
+    }
+    /** Explicit opt-in; the platform provisions once and never rotates keys or re-enables a disabled identity on retry. */
+    enableFederationIdentity() {
+        return this.client.post('/protocols/social/federation/identity', { consent: true }, { retry: false });
+    }
+    /** Stops serving and signing for the identity; its stable URL and keys are retained by the platform. */
+    disableFederationIdentity() {
+        return this.client.delete('/protocols/social/federation/identity');
+    }
     /** Native writes are off unless enabled for this exact app; public readers are independent. */
     nativeNostrAccount() {
         return this.client.get('/protocols/social/nostr/account');
@@ -97,10 +195,15 @@ export class ProtocolsResource {
     /** Prepare an exact event for review. A timeout never automatically creates another signing request. */
     prepareNativeNostr(id, input) {
         hostedIdentityPath(id);
-        const body = input.action === 'publish' ? { action: input.action, content: input.content } : { action: input.action, postId: input.postId };
+        const body = input.action === 'publish' ? { action: input.action, content: input.content }
+            : input.action === 'reply' ? { action: input.action, content: input.content, parentId: input.parentId }
+                : input.action === 'linked_post' ? { action: input.action, content: input.content,
+                    source: { protocol: input.source.protocol, nativeId: input.source.nativeId,
+                        ...(input.source.readRef !== undefined ? { readRef: input.source.readRef } : {}) } }
+                    : { action: input.action, postId: input.postId };
         return this.client.post(`/protocols/social/nostr/${encodeURIComponent(id)}/prepare`, body, { retry: false });
     }
-    /** Pass only the public signed event. After a timeout, read the prepared postId (delete) or eventId (publish).
+    /** Pass only the public signed event. After a timeout, read the prepared postId (delete) or eventId (publish/reply/linked_post).
      * Any user-selected retry keeps the same intent/event. */
     submitNativeNostr(id, input) {
         hostedIdentityPath(id);
@@ -109,6 +212,11 @@ export class ProtocolsResource {
             intent: input.intent, event: { id: eventId, pubkey, sig, kind, content, created_at, tags }, approve: input.approve,
         }, { retry: false });
     }
+    /** Check only the event bound to this private saved result; never sign, prepare or resend it. */
+    nativeNostrReplyResult(id) {
+        hostedIdentityPath(id);
+        return this.client.get(`/protocols/social/nostr/replies/${encodeURIComponent(id)}`);
+    }
     getNativeNostrPost(id, postId) {
         hostedIdentityPath(id);
         if (!/^[0-9a-f]{64}$/.test(postId))

package/dist/resources/reports.d.ts

@@ -1,9 +1,10 @@
 import type { HttpClient } from '../client.js';
 import type { PaginatedResponse, SingleResponse } from '../types.js';
-export type ReportTargetType = 'post' | 'user' | 'community' | 'message';
-export type ReportStatus = 'pending' | 'resolved' | 'dismissed';
+export type ReportTargetType = 'post' | 'user' | 'community' | 'message' | 'source_actor' | 'source_post';
+export type ReportStatus = 'pending' | 'in_review' | 'escalated' | 'resolved' | 'dismissed';
 export interface CreateReportInput {
-    target_type: ReportTargetType;
+    /** External sources require protocols.reportSource so evidence is verified. */
+    target_type: Exclude<ReportTargetType, 'source_actor' | 'source_post'>;
     target_id: string;
     reason: string;
     details?: string;

package/llm.md

@@ -619,8 +619,9 @@ if (subscription.active) {
 - `r.admin` — Admin operations (user management, stats, network settings); content reports: `listReports({ status? })`, `resolveReport(id)`, `dismissReport(id)` (project-bound keys see only their app's reports)
 - `r.inviteCodes` / `r.inviteCodesAdmin` — Invite code management
 - `r.organizationSettings` / `r.organizationSecurity` — Org configuration
-- `r.protocols` — 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. 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.
+- 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, 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 and exact `wireText`; connection is not publication approval. `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. 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. 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.
   - Public trends: require `public_trends` from `publicNetworks()`, then `getPublicTrends({ protocol, limit?, cursor? })`; 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.
   - `listCandidates({ protocol?, limit?, cursor? })` and `getCandidate(id)` are read-only quarantine review, not published-post search. Both require `admin` scope, a project-bound key, a live admin role, and existing project-admin access. The key supplies app/network scope; neither method accepts another project or network. They never invoke refresh, change settings, or publish.
   - Lists return `{ data: ProtocolQuarantinedCandidate[], meta: { limit, has_more, next_cursor } }`; use the opaque `next_cursor`, not offset pagination. The API defaults `limit` to 20 and permits at most 50. Details return `{ data: ProtocolQuarantinedCandidate }`. Every candidate has `state: 'quarantined'` and `content_format: 'plain'`; render its bounded `content` as text, respect `content_truncated`, and distinguish upstream `published_at` from local `observed_at` / `created_at`.
@@ -795,3 +796,12 @@ catch (e) { if (e.status === 404) { /* private or doesn't exist */ } }
 9. **`r.memory` rejects secrets.** Facts containing patterns like `sk_`, `api_key=`, `password=`, or private keys are rejected on write. Store secrets in environment variables, not memory.
 10. **Memory is network-scoped.** Facts and decisions are isolated per network (tenant). Two teams on different networks cannot see each other's memory.
 11. **`r.memory.context()` has a token budget.** Default is 2000 tokens (~8000 chars). Pass `max_tokens` to control how much context is returned.
+
+Nostr replies and linked posts are saved in the same `protocols.nativeReplyHistory()`
+feed after signed submission. Items with `type: 'nostr'` use
+`protocols.nativeNostrReplyResult(id)` for a read-only check of the saved event and
+its author's deletion requests on the recorded relay. Other history items use
+`nativeReplyStatus(id)`. Do not turn an unknown result into a fresh preparation or
+publication; history stores no signature, signing key or intent. Keep the acting
+user/app-bound result IDs and discard UI state after an account switch. The last
+read-back observation is separate from retained publication/deletion evidence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recursiv/sdk",
-  "version": "0.7.26",
+  "version": "0.7.27",
   "description": "TypeScript SDK for the Recursiv API",
   "license": "FSL-1.1-ALv2",
   "type": "module",