@awiki/dsh-plugin 0.3.18 → 0.3.20

package/lib/types/index.js

@@ -32,6 +32,8 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
+import { TenantCapabilityCache } from "./tenant-capability-cache.js";
+import { backendAttachmentMaxBytes, projectBackendFeatures, projectBackendSnapshot, requireBackendFeature } from "./backend-capabilities.js";
 export { registerAwikiLoopbackRpc } from "./settings-transport.js";
 import { registerAwikiSettingsTransport } from "./settings-transport.js";
 import { registrationHandleLocalPart } from "./registration-policy.js";
@@ -115,6 +117,8 @@ export const Config = z.object({
     summaryMaxInputBytes: z.number().default(DEFAULT_SUMMARY_MAX_INPUT_BYTES),
 });
 const FAILURE_CODES = new Set([
+    'backend-not-supported',
+    'backend-unconfirmed',
     'client-version-unsupported',
     'not-registered',
     'signed-out',
@@ -155,6 +159,8 @@ const RESUMABLE_JOIN_PHASES = new Set([
     'approval_prepared',
 ]);
 const FAILURE_MESSAGES = {
+    'backend-not-supported': 'This server does not support this feature.',
+    'backend-unconfirmed': 'Server features are not confirmed yet. Please retry.',
     'client-version-unsupported': 'This AWiki plugin version is not supported by the active tenant. Update the plugin or switch tenants.',
     'not-registered': 'No AWiki identity is registered for this deployment.',
     'signed-out': 'This installation is signed out of AWiki.',
@@ -274,7 +280,7 @@ function publishedServiceBaseUrl(services, name, allowInsecureLoopbackForTesting
     if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate))
         return undefined;
     const value = candidate;
-    if (value.enabled !== true || typeof value.base_url !== 'string')
+    if (value.enabled !== true || value.protocol_version !== 1 || typeof value.base_url !== 'string')
         return undefined;
     try {
         const baseUrl = serviceUrl(`server-info.services.${name}.base_url`, value.base_url, allowInsecureLoopbackForTesting);
@@ -804,6 +810,7 @@ let AwikiService = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
     let _getConfig_decorators;
+    let _refreshBackendCapabilities_decorators;
     let _getIntegration_decorators;
     let _createIntegration_decorators;
     let _updateIntegration_decorators;
@@ -876,6 +883,7 @@ let AwikiService = (() => {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getConfig_decorators = [Remote];
+            _refreshBackendCapabilities_decorators = [Remote];
             _getIntegration_decorators = [Remote];
             _createIntegration_decorators = [Remote];
             _updateIntegration_decorators = [Remote];
@@ -945,6 +953,7 @@ let AwikiService = (() => {
             _downloadMailAttachment_decorators = [Remote];
             _clearLocalData_decorators = [Remote];
             __esDecorate(this, null, _getConfig_decorators, { kind: "method", name: "getConfig", static: false, private: false, access: { has: obj => "getConfig" in obj, get: obj => obj.getConfig }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _refreshBackendCapabilities_decorators, { kind: "method", name: "refreshBackendCapabilities", static: false, private: false, access: { has: obj => "refreshBackendCapabilities" in obj, get: obj => obj.refreshBackendCapabilities }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getIntegration_decorators, { kind: "method", name: "getIntegration", static: false, private: false, access: { has: obj => "getIntegration" in obj, get: obj => obj.getIntegration }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _createIntegration_decorators, { kind: "method", name: "createIntegration", static: false, private: false, access: { has: obj => "createIntegration" in obj, get: obj => obj.createIntegration }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateIntegration_decorators, { kind: "method", name: "updateIntegration", static: false, private: false, access: { has: obj => "updateIntegration" in obj, get: obj => obj.updateIntegration }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -1032,6 +1041,15 @@ let AwikiService = (() => {
         tenantSwitching = false;
         tenantParticipants = new Set();
         activeCapabilities;
+        backendFeatures = {};
+        backendDiagnostics = {};
+        backendFeaturesTask;
+        backendFeaturesRevision = -1;
+        backendSubscriptions = new Map();
+        backendSubscriptionPending = new Set();
+        backendAttachmentLimit;
+        capabilityDiscoveryTask;
+        capabilityDiscoveryAt = 0;
         updatePolicyStatus;
         updatePolicyRequest;
         updatePolicyTask;
@@ -1132,6 +1150,7 @@ let AwikiService = (() => {
             registerAwikiTools(ctx, this);
             ctx.effect(() => async () => {
                 this.updatePolicyRequest?.abort();
+                this.stopBackendSubscriptions();
                 const provider = this.provider;
                 if (provider !== undefined)
                     await this.disposeProvider(provider);
@@ -1231,12 +1250,38 @@ let AwikiService = (() => {
             this.conversationPreferenceStore = new AwikiConversationPreferenceStore(options.stateRoot);
             this.mailListClient = new AwikiMailListClient(options.mailServiceUrl, this.externalHttpAuth);
             this.integrationClient = undefined;
+            this.stopBackendSubscriptions();
+            this.backendFeatures = {};
+            this.backendDiagnostics = {};
+            this.backendFeaturesRevision = -1;
+            this.backendFeaturesTask = undefined;
+            this.backendAttachmentLimit = undefined;
+            this.capabilityDiscoveryTask = undefined;
+            this.capabilityDiscoveryAt = 0;
             this.activeCapabilities = {
                 tenantId: tenant.tenantId,
                 generation: this.runtimeGeneration,
                 online: false,
                 handleRecoveryPhoneEnabled: false,
             };
+            const metadata = new TenantCapabilityCache(options.stateRoot, options.userServiceUrl).read(value => {
+                const services = {
+                    model_proxy: { enabled: true, protocol_version: 1, base_url: value.modelProxyBaseUrl },
+                    guest_gateway: { enabled: true, protocol_version: 1, base_url: value.guestGatewayBaseUrl },
+                };
+                const modelProxyBaseUrl = publishedServiceBaseUrl(services, 'model_proxy', this.resolved.allowInsecureLoopbackForTesting);
+                const guestGatewayBaseUrl = publishedServiceBaseUrl(services, 'guest_gateway', false);
+                return {
+                    handleRecoveryPhoneEnabled: value.handleRecoveryPhoneEnabled,
+                    ...modelProxyBaseUrl === undefined ? {} : { modelProxyBaseUrl },
+                    ...guestGatewayBaseUrl === undefined ? {} : { guestGatewayBaseUrl },
+                };
+            });
+            if (metadata !== undefined) {
+                this.activeCapabilities = { ...this.activeCapabilities, ...metadata, online: true };
+                this.integrationClient = metadata.guestGatewayBaseUrl === undefined ? undefined
+                    : new AwikiIntegrationClient(metadata.guestGatewayBaseUrl, this.externalHttpAuth);
+            }
             this.signedOut = undefined;
             this.activeIdentityDid = undefined;
             this.pendingDeviceJoin = undefined;
@@ -1438,7 +1483,7 @@ let AwikiService = (() => {
                     await this.sessionStore.signIn();
                     this.signedOut = false;
                 }
-                await Promise.all([this.discoverTenantCapabilities(3_000), this.refreshUpdatePolicy()]);
+                void Promise.all([this.refreshTenantCapabilities(), this.refreshUpdatePolicy()]).catch(() => undefined);
                 registry.commitActive(target.tenantId);
                 committed = true;
                 for (const participant of prepared)
@@ -1538,17 +1583,22 @@ let AwikiService = (() => {
          */
         async getConfig() {
             this.ensureTenantOptions();
-            const capabilities = await this.discoverTenantCapabilities(10_000);
-            if (this.tenantSwitching
-                || capabilities.generation !== this.runtimeGeneration
-                || capabilities.tenantId !== this.activeTenant?.tenantId) {
+            const requestedGeneration = this.runtimeGeneration;
+            if (requestedGeneration !== this.runtimeGeneration)
                 return { ok: false, error: failure('conflict') };
-            }
+            // Config and local session/history reads never join discovery's network wait.
+            const capabilities = this.activeCapabilities;
+            this.refreshBackendProjection();
+            void this.refreshTenantCapabilities(false).catch(() => undefined);
+            const serverFeatures = this.backendFeatures;
+            const attachmentMaxBytes = this.backendAttachmentLimit ?? this.resolved.attachmentMaxBytes;
             return {
                 ok: true,
                 value: {
+                    serverFeatures,
+                    serverFeatureDiagnostics: this.backendDiagnostics,
                     pollIntervalMs: this.resolved.pollIntervalMs,
-                    attachmentMaxBytes: this.resolved.attachmentMaxBytes,
+                    attachmentMaxBytes,
                     mailAttachmentMaxCount: this.resolved.mailAttachmentMaxCount,
                     mailAttachmentMaxBytes: Math.min(this.resolved.mailAttachmentMaxBytes, MAIL_HTTP_UPLOAD_MAX_BYTES),
                     mailAttachmentDownloadMaxBytes: this.resolved.mailAttachmentMaxBytes,
@@ -1558,7 +1608,7 @@ let AwikiService = (() => {
                         ? {}
                         : { integrationGuideUrl: new URL('/guest/guide/integration', capabilities.guestGatewayBaseUrl).toString() },
                     tenantId: capabilities.tenantId,
-                    tenantStorageScopeId: this.activeTenant?.storageScopeId,
+                    tenantStorageScopeId: this.activeTenant.storageScopeId,
                     tenantGeneration: capabilities.generation,
                     tenantOnline: capabilities.online,
                     services: {
@@ -1568,6 +1618,15 @@ let AwikiService = (() => {
                 },
             };
         }
+        /** Explicit discovery retry; ordinary config reads retain their zero-argument contract. */
+        async refreshBackendCapabilities() {
+            this.ensureTenantOptions();
+            const generation = this.runtimeGeneration;
+            await Promise.allSettled([this.refreshTenantCapabilities(true), this.refreshBackendProjection(true)]);
+            if (generation !== this.runtimeGeneration)
+                return { ok: false, error: failure('conflict') };
+            return this.getConfig();
+        }
         /** Trusted same-process capability binding for optional tenant participants. */
         getTenantCapabilities() {
             const capabilities = this.activeCapabilities;
@@ -1576,9 +1635,124 @@ let AwikiService = (() => {
             return { ...capabilities };
         }
         /** Refresh the active tenant's optional service advertisement without affecting Core availability. */
-        refreshTenantCapabilities() {
+        refreshTenantCapabilities(force = true) {
             this.ensureTenantOptions();
-            return this.discoverTenantCapabilities(10_000);
+            if (this.capabilityDiscoveryTask !== undefined)
+                return this.capabilityDiscoveryTask;
+            if (!force && Date.now() - this.capabilityDiscoveryAt < 300_000 && this.activeCapabilities !== undefined)
+                return Promise.resolve(this.activeCapabilities);
+            const generation = this.runtimeGeneration;
+            const task = this.discoverTenantCapabilities(10_000).finally(() => {
+                if (this.runtimeGeneration === generation && this.capabilityDiscoveryTask === task) {
+                    this.capabilityDiscoveryTask = undefined;
+                    this.capabilityDiscoveryAt = Date.now();
+                }
+            });
+            this.capabilityDiscoveryTask = task;
+            return task;
+        }
+        refreshBackendProjection(force = false) {
+            const provider = this.provider;
+            if (provider === undefined)
+                return Promise.resolve();
+            if (this.backendFeaturesTask !== undefined)
+                return this.backendFeaturesTask;
+            const revision = this.sessionRevision;
+            const generation = this.runtimeGeneration;
+            if (this.backendFeaturesRevision !== revision) {
+                // Only public facts survive a sign-out or identity change in this tenant.
+                this.backendFeatures = Object.fromEntries(Object.entries(this.backendFeatures).filter(([key]) => key.includes('.')));
+                this.backendAttachmentLimit = undefined;
+                this.backendDiagnostics = this.backendDiagnostics.public === undefined ? {} : { public: this.backendDiagnostics.public };
+                this.backendFeaturesRevision = revision;
+            }
+            const current = () => provider === this.provider && revision === this.sessionRevision && generation === this.runtimeGeneration;
+            const task = (async () => {
+                const authenticated = !await this.isSignedOut() && await provider.client.getIdentity() !== null;
+                await Promise.all([false, ...(authenticated ? [true] : [])].map(async (local) => {
+                    try {
+                        this.observeBackendProjection(provider, local, current);
+                        const snapshot = await provider.client.backendCapabilities?.(local, force);
+                        if (!current())
+                            return;
+                        if (snapshot === undefined)
+                            return;
+                        // A subscribed source is authoritative: a query started before a
+                        // disable notification must never restore its older result.
+                        if (this.backendSubscriptions.has(local))
+                            return;
+                        this.recordBackendDiagnostics(local, snapshot);
+                        if (snapshot.status === 'unavailable')
+                            return;
+                        this.backendFeatures = { ...this.backendFeatures, ...projectBackendSnapshot(snapshot, local) };
+                        if (local)
+                            this.backendAttachmentLimit = backendAttachmentMaxBytes(snapshot, this.resolved.attachmentMaxBytes);
+                        if (this.backendFeatures['agents.managed_agents'] === 'unsupported')
+                            await this.detachAgentConsumer(provider);
+                        else if (this.backendFeatures['agents.managed_agents'] === 'supported')
+                            this.ensureAgentConsumer(provider);
+                    }
+                    catch (error) {
+                        // Preserve successful facts; auth failures keep their established category.
+                        if (current())
+                            this.ctx.logger('awiki-capabilities').debug('AWiki capability refresh failed: %s', error instanceof AwikiSdkError ? error.code : 'unavailable');
+                    }
+                }));
+            })().finally(() => { if (this.backendFeaturesTask === task)
+                this.backendFeaturesTask = undefined; });
+            this.backendFeaturesTask = task;
+            void task.catch(() => undefined);
+            return task;
+        }
+        recordBackendDiagnostics(local, snapshot) {
+            this.backendDiagnostics = { ...this.backendDiagnostics, [local ? 'message' : 'public']: {
+                    ...typeof snapshot.fetched_at === 'number' ? { fetchedAt: snapshot.fetched_at } : {},
+                    ...snapshot.refresh_error === undefined ? {} : { refreshError: snapshot.refresh_error },
+                } };
+        }
+        stopBackendSubscriptions() {
+            for (const subscription of this.backendSubscriptions.values())
+                subscription.stop();
+            this.backendSubscriptions.clear();
+            this.backendSubscriptionPending.clear();
+        }
+        observeBackendProjection(provider, local, current) {
+            const subscribe = provider.client.subscribeBackendCapabilities;
+            if (subscribe === undefined || this.backendSubscriptions.has(local) || this.backendSubscriptionPending.has(local))
+                return;
+            this.backendSubscriptionPending.add(local);
+            void (async () => {
+                const subscription = await subscribe.call(provider.client, local);
+                if (!current()) {
+                    subscription.stop();
+                    return;
+                }
+                this.backendSubscriptionPending.delete(local);
+                this.backendSubscriptions.set(local, subscription);
+                try {
+                    while (current()) {
+                        const state = await subscription.nextUpdate();
+                        if (state === null || !current())
+                            break;
+                        this.recordBackendDiagnostics(local, state.snapshot);
+                        if (state.snapshot.status === 'unavailable')
+                            continue;
+                        this.backendFeatures = { ...this.backendFeatures, ...projectBackendSnapshot(state.snapshot, local) };
+                        if (local)
+                            this.backendAttachmentLimit = backendAttachmentMaxBytes(state.snapshot, this.resolved.attachmentMaxBytes);
+                        if (this.backendFeatures['agents.managed_agents'] === 'unsupported')
+                            await this.detachAgentConsumer(provider);
+                        else if (this.backendFeatures['agents.managed_agents'] === 'supported')
+                            this.ensureAgentConsumer(provider);
+                    }
+                }
+                finally {
+                    subscription.stop();
+                    if (this.backendSubscriptions.get(local) === subscription)
+                        this.backendSubscriptions.delete(local);
+                }
+            })().catch(() => { if (current())
+                this.backendSubscriptionPending.delete(local); });
         }
         async discoverTenantCapabilities(timeoutMs) {
             const options = this.activeClientOptions;
@@ -1586,12 +1760,10 @@ let AwikiService = (() => {
             if (options === undefined || tenant === undefined)
                 throw new ProviderUnavailableError();
             const generation = this.runtimeGeneration;
-            const fallback = {
-                tenantId: tenant.tenantId,
-                generation,
-                online: false,
-                handleRecoveryPhoneEnabled: false,
-            };
+            const previous = this.activeCapabilities;
+            const fallback = previous?.tenantId === tenant.tenantId && previous.generation === generation
+                ? { ...previous }
+                : { tenantId: tenant.tenantId, generation, online: false, handleRecoveryPhoneEnabled: false };
             const publish = (capabilities) => {
                 if (this.runtimeGeneration === generation && this.activeTenant?.tenantId === tenant.tenantId) {
                     this.activeCapabilities = capabilities;
@@ -1606,6 +1778,7 @@ let AwikiService = (() => {
             try {
                 const endpoint = new URL('/user-service/v1/server-info', options.userServiceUrl);
                 endpoint.searchParams.set('client_platform', 'dsh');
+                endpoint.searchParams.set('capabilities_version', '1');
                 const response = await fetch(endpoint, {
                     method: 'GET',
                     headers: { accept: 'application/json', 'cache-control': 'no-store' },
@@ -1619,13 +1792,19 @@ let AwikiService = (() => {
                 const value = text === undefined ? undefined : JSON.parse(text);
                 if (typeof value !== 'object' || value === null || value.schema_version !== 1)
                     return publish(fallback);
+                const versioned = value.capabilities_version === 1;
+                if (!versioned) {
+                    if ('capabilities_version' in value)
+                        return publish({ tenantId: tenant.tenantId, generation, online: true, handleRecoveryPhoneEnabled: false });
+                    return publish(fallback);
+                }
                 const methods = value.identity?.handle_recovery?.methods;
-                const handleRecoveryPhoneEnabled = Array.isArray(methods) && methods.some((method) => (typeof method === 'object' && method !== null
+                const handleRecoveryPhoneEnabled = versioned && Array.isArray(methods) && methods.some((method) => (typeof method === 'object' && method !== null
                     && method.id === 'phone'
                     && method.enabled === true
                     && method.verification?.required === true
                     && method.verification?.type === 'sms_otp'));
-                const services = value.services;
+                const services = versioned ? value.services : undefined;
                 const modelProxyBaseUrl = publishedServiceBaseUrl(services, 'model_proxy', this.resolved.allowInsecureLoopbackForTesting);
                 const guestGatewayBaseUrl = publishedServiceBaseUrl(services, 'guest_gateway', false);
                 const capabilities = {
@@ -1636,6 +1815,15 @@ let AwikiService = (() => {
                     ...modelProxyBaseUrl === undefined ? {} : { modelProxyBaseUrl },
                     ...guestGatewayBaseUrl === undefined ? {} : { guestGatewayBaseUrl },
                 };
+                if (this.runtimeGeneration === generation && this.activeTenant?.tenantId === tenant.tenantId) {
+                    const saved = new TenantCapabilityCache(options.stateRoot, options.userServiceUrl).write({
+                        handleRecoveryPhoneEnabled,
+                        ...modelProxyBaseUrl === undefined ? {} : { modelProxyBaseUrl },
+                        ...guestGatewayBaseUrl === undefined ? {} : { guestGatewayBaseUrl },
+                    });
+                    if (!saved)
+                        this.ctx.logger('awiki-capabilities').debug('AWiki capability metadata persistence failed');
+                }
                 return publish(capabilities);
             }
             catch {
@@ -1726,8 +1914,10 @@ let AwikiService = (() => {
                     const session = { status: 'signed-out' };
                     this.publishSession(session);
                     const provider = this.provider;
-                    if (provider !== undefined)
+                    if (provider !== undefined) {
                         await this.stopProviderRuntime(provider);
+                        await this.updateBackendDiscoveryLifecycle(provider, false);
+                    }
                     return { ok: true, value: session };
                 }
                 catch {
@@ -1751,8 +1941,10 @@ let AwikiService = (() => {
                     const session = { status: 'active', identity: identity.value };
                     this.publishSession(session);
                     const provider = this.provider;
-                    if (provider !== undefined)
+                    if (provider !== undefined) {
                         this.ensureProviderRuntime(provider);
+                        await this.updateBackendDiscoveryLifecycle(provider, true);
+                    }
                     return { ok: true, value: session };
                 }
                 catch {
@@ -1939,6 +2131,9 @@ let AwikiService = (() => {
                 const recoveries = await client.listPendingRecoveries();
                 const pendingRegistrations = await client.pendingIdentityRegistrations();
                 const creationMethods = await client.identityCreationMethods().catch(() => []);
+                const backend = await client.backendCapabilities?.(false);
+                const registrationHandleOnly = backend?.capabilities['registration.handle_only']?.support === 'supported'
+                    && (backend.status === 'confirmed' || backend.status === 'stale');
                 const identity = await client.getIdentity();
                 const capabilities = identity === null ? undefined : await client.identityMethodCapabilities(identity.did);
                 const domain = this.activeClientOptions?.userServiceDomain;
@@ -1952,6 +2147,7 @@ let AwikiService = (() => {
                     },
                     joining,
                     creationMethods,
+                    registrationHandleOnly,
                     pendingRegistrations,
                     ...capabilities === undefined ? {} : { methodCapabilities: capabilities },
                     recoveries: recoveries.filter(value => domain !== undefined && value.fullHandle.slice(value.fullHandle.indexOf('.') + 1) === domain),
@@ -2310,7 +2506,14 @@ let AwikiService = (() => {
             const normalized = normalizeCreateGroupRequest(request);
             if (normalized === undefined)
                 return { ok: false, error: failure('invalid-request') };
-            const created = await this.run(client => client.createGroup(normalized.name, normalized.encrypted, normalized.operationId));
+            const created = await this.run(async (client) => {
+                await requireBackendFeature(client, 'groups');
+                if (normalized.encrypted)
+                    await requireBackendFeature(client, 'group_e2ee');
+                if (normalized.members.length > 0)
+                    await requireBackendFeature(client, 'group_admin_add');
+                return client.createGroup(normalized.name, normalized.encrypted, normalized.operationId);
+            });
             if (!created.ok)
                 return created;
             const addedMembers = [];
@@ -2339,14 +2542,14 @@ let AwikiService = (() => {
             const groupDid = normalizeGroupDid(request?.groupDid);
             if (groupDid === undefined)
                 return Promise.resolve({ ok: false, error: failure('invalid-request') });
-            return this.run(client => client.repairGroupSecurity(groupDid));
+            return this.run(async (client) => { await requireBackendFeature(client, 'group_e2ee'); return client.repairGroupSecurity(groupDid); });
         }
         /** Join one open group and return its authoritative membership state. */
         joinGroup(request) {
             const groupDid = normalizeGroupDid(request?.groupDid);
             if (groupDid === undefined)
                 return Promise.resolve({ ok: false, error: failure('invalid-request') });
-            return this.run(client => client.joinGroup(groupDid));
+            return this.run(async (client) => { await requireBackendFeature(client, 'group_open_join'); return client.joinGroup(groupDid); });
         }
         /** Leave one group. Core rejects owner leave and unsupported security profiles. */
         async leaveGroup(request) {
@@ -2888,12 +3091,14 @@ let AwikiService = (() => {
             return client.getLocalDeviceJoinVerificationProgress(notice.joinSessionId);
         }
         async requireDeviceManager(client) {
+            await requireBackendFeature(client, 'identity.multi_device');
             const current = await client.getCurrentDeviceSummary();
             if (!current.canManage || current.role !== 'admin' || current.readiness !== 'admin_ready') {
                 throw Object.assign(new Error('device manager required'), { name: 'AwikiSdkError', code: 'forbidden' });
             }
         }
         async requireRootTransferRecipient(client, deviceId) {
+            await requireBackendFeature(client, 'identity.root_transfer');
             if (!client.trustedUserPresenceSupported) {
                 throw Object.assign(new Error('trusted user presence unsupported'), { name: 'AwikiSdkError', code: 'forbidden' });
             }
@@ -3026,6 +3231,7 @@ let AwikiService = (() => {
         }
         /** Invalidate cached session work and cancel every model request still owned by the old session. */
         invalidateSummaries() {
+            this.stopBackendSubscriptions();
             this.sessionRevision += 1;
             this.requestRefs.clear();
             this.requestSessions.clear();
@@ -3107,7 +3313,10 @@ let AwikiService = (() => {
             catch {
                 return Promise.resolve({ ok: false, error: failure('invalid-request') });
             }
-            return this.run(client => operation(client, request), options);
+            return this.run(async (client) => {
+                await requireBackendFeature(client, 'services.mail');
+                return operation(client, request);
+            }, options);
         }
         /** Read and cache the private Host-owned session marker. */
         async isSignedOut() {
@@ -3168,6 +3377,16 @@ let AwikiService = (() => {
             this.sessionMutation = pending.then(() => undefined, () => undefined);
             return pending;
         }
+        /** Discovery is an optional projection, not authority for a committed session transition. */
+        async updateBackendDiscoveryLifecycle(provider, active) {
+            try {
+                await provider.client.setBackendDiscoveryActive?.(active);
+            }
+            catch {
+                // Do not include bridge errors: provider diagnostics may contain private context.
+                this.ctx.logger('awiki-backend').warn('AWiki backend discovery lifecycle unavailable');
+            }
+        }
         /** Start identity realtime and the optional Agent consumer without blocking identity success. */
         ensureProviderRuntime(provider) {
             if (this.tenantSwitching)
@@ -3181,6 +3400,7 @@ let AwikiService = (() => {
                 this.replaceProviderRuntime(provider, identityDid);
                 return;
             }
+            this.refreshBackendProjection();
             this.ensureRealtimeSupervisor(provider);
             this.ensureAgentConsumer(provider);
         }
@@ -3287,6 +3507,9 @@ let AwikiService = (() => {
             const logger = this.ctx.logger('awiki-listener');
             const startup = (async () => {
                 await this.detachAgentConsumer(provider);
+                const features = await projectBackendFeatures(provider.client, false);
+                if (features['agents.managed_agents'] !== 'supported')
+                    return;
                 if (!this.agentConsumerFenceMatches(provider, workspaceContext, identityDid, generation))
                     return;
                 const agents = new DshAwikiListenerAgentRuntime(workspaceContext, this.resolved.listener.workspacePath);