@awiki/dsh-plugin 0.3.7-dsh-test.20260831.2 → 0.3.10

package/lib/types/index.js

@@ -1,4 +1,3 @@
-/** Unified AWiki identity, messaging, attachment, Remote, and model-tool service. */
 var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
     var useValue = arguments.length > 2;
     for (var i = 0; i < initializers.length; i++) {
@@ -33,6 +32,8 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
+import { decodeDesktopDistribution } from "./desktop-distribution.js";
+/** Unified AWiki identity, messaging, attachment, Remote, and model-tool service. */
 import { Context } from '@deepseek-ai/cordis';
 import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
 import { homedir } from 'node:os';
@@ -42,20 +43,29 @@ import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { settingsNamespace } from '@deepseek-ai/dsh-settings';
 import { AWIKI_CLEAR_LOCAL_DATA_CONFIRMATION, AWIKI_LOGOUT_CONFIRMATION } from "./types.js";
 import { AwikiExternalHttpAuthError, createAwikiExternalHttpAuth, externalHttpAuthError, mapProviderError as mapExternalHttpProviderError, } from "./external-http-auth.js";
-import { downloadedAttachment } from "./sdk-adapter.js";
+import { AwikiIntegrationClient } from "./integration-client.js";
+import { clearLegacySentMailCache } from "./legacy-sent-mail-cache.js";
+import { AwikiMailListClient } from "./mail-list-client.js";
+import { AwikiSdkError, downloadedAttachment } from "./sdk-adapter.js";
+import { failedMailRecoveryObservability, fencedMailRecoveryObservability, successfulMailRecoveryObservability, } from "./mail-recovery-observability.js";
 import { registerAwikiTools } from "./tools.js";
 import { mailInboxRequest, mailMarkReadRequest, mailReadRequest, mailSendRequest, } from "./mail.js";
 import { AwikiSettingsSchema, validateAwikiSettings, } from "./settings.js";
 import { AWIKI_SETTINGS_NAMESPACE, DEFAULT_AWIKI_DOMAIN, normalizeAwikiDomain } from "./domain.js";
+import { AWIKI_DEFAULT_BUILTIN_TENANT, } from "./builtin-tenant-config.js";
 import { AWIKI_SETTINGS_RPC_CHANNEL } from "./settings-rpc-contract.js";
 import { createAwikiSettingsRpcHandler } from "./settings-rpc.js";
 import { AwikiSessionStore } from "./session.js";
 import { AwikiImageAttachmentCache, minimumImageAttachmentCacheMaxBytes } from "./attachment-cache.js";
-import { AwikiSentMailStore, isLocalSentMailId } from "./sent-mail-store.js";
 import { AwikiConversationPreferenceStore, normalizeConversationPreferenceMutation, } from "./conversation-preferences.js";
 import { AwikiAgentListener, DshAwikiListenerAgentRuntime, } from "./listener.js";
 import { IdentityRealtimeSupervisor, } from "./realtime-supervisor.js";
+import { resolveAwikiStateRoot } from "./profile-state.js";
+import { AwikiTenantRegistry, } from "./tenant-registry.js";
+import { checkAwikiUpdatePolicy, readAwikiUpdatePolicyStatus, DSH_AWIKI_VERSION, } from "./update-policy.js";
 export { AWIKI_CLEAR_LOCAL_DATA_CONFIRMATION, AWIKI_LOGOUT_CONFIRMATION } from "./types.js";
+export { AWIKI_CHINA_TENANT_ID, AWIKI_GLOBAL_TENANT_ID, AWIKI_OFFICIAL_CATALOG_VERSION, AWIKI_TENANT_REGISTRY_SCHEMA_VERSION, } from "./tenant-registry.js";
+export { DSH_AWIKI_MODEL_PROXY_VERSION, DSH_AWIKI_VERSION, compareVersions as compareAwikiPluginVersions, } from "./update-policy.js";
 export { AWIKI_EXTERNAL_HTTP_MAX_BODY_BYTES, AwikiExternalHttpAuthError, } from "./external-http-auth.js";
 export { AWIKI_DOMAIN_FIELD, AWIKI_SETTINGS_NAMESPACE, AwikiSettingsSchema, DEFAULT_AWIKI_DOMAIN, normalizeAwikiDomain, validateAwikiSettings, } from "./settings.js";
 export { AWIKI_HISTORY_TOOL, AWIKI_IDENTITY_STATUS_TOOL, AWIKI_LIST_CONVERSATIONS_TOOL, AWIKI_MAIL_ACCOUNT_TOOL, AWIKI_MAIL_INBOX_TOOL, AWIKI_MAIL_MARK_READ_TOOL, AWIKI_MAIL_READ_TOOL, AWIKI_MAIL_SEND_TOOL, AWIKI_SEND_ATTACHMENT_TOOL, AWIKI_SEND_MESSAGE_TOOL, } from "./tools.js";
@@ -65,10 +75,10 @@ export const DEFAULT_ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024;
 export const DEFAULT_IMAGE_ATTACHMENT_CACHE_MAX_BYTES = 64 * 1024 * 1024;
 /** Default browser polling interval while the AWiki drawer is open. */
 export const DEFAULT_POLL_INTERVAL_MS = 3_000;
-/** Default AWiki production service origin. */
-export const DEFAULT_AWIKI_SERVICE_URL = 'https://awiki.ai';
-/** Default authoritative AWiki message-service DID. */
-export const DEFAULT_AWIKI_MESSAGE_SERVICE_DID = 'did:wba:awiki.ai';
+/** Package-configured primary AWiki service origin. */
+export const DEFAULT_AWIKI_SERVICE_URL = AWIKI_DEFAULT_BUILTIN_TENANT.backendOrigin;
+/** Package-configured primary authoritative AWiki message-service DID. */
+export const DEFAULT_AWIKI_MESSAGE_SERVICE_DID = `did:wba:${AWIKI_DEFAULT_BUILTIN_TENANT.didHost}`;
 /** Host-owned model input cap after message minimization. */
 export const DEFAULT_SUMMARY_MAX_INPUT_BYTES = 32 * 1024;
 /** Hard limit for one user-triggered conversation summary. */
@@ -77,6 +87,7 @@ export const MAX_SUMMARY_MESSAGES = 50;
 export const Config = z.object({
     userServiceUrl: z.string().default(DEFAULT_AWIKI_SERVICE_URL),
     userServiceDomain: z.string().default(DEFAULT_AWIKI_DOMAIN),
+    legacyTenantSlot: z.string(),
     messageServiceUrl: z.string().default(DEFAULT_AWIKI_SERVICE_URL),
     mailServiceUrl: z.string(),
     messageServicePublicUrl: z.string().default(DEFAULT_AWIKI_SERVICE_URL),
@@ -94,6 +105,7 @@ export const Config = z.object({
     summaryMaxInputBytes: z.number().default(DEFAULT_SUMMARY_MAX_INPUT_BYTES),
 });
 const FAILURE_CODES = new Set([
+    'client-version-unsupported',
     'not-registered',
     'signed-out',
     'already-registered',
@@ -103,6 +115,7 @@ const FAILURE_CODES = new Set([
     'handle-unavailable',
     'not-found',
     'forbidden',
+    'device-rejoin-required',
     'identity-recovery-required',
     'conflict',
     'rate-limited',
@@ -127,9 +140,9 @@ const RESUMABLE_JOIN_PHASES = new Set([
     'response_prepared',
     'response_verified',
     'approval_prepared',
-    'authorized',
 ]);
 const FAILURE_MESSAGES = {
+    '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.',
     'already-registered': 'This deployment already has an AWiki identity.',
@@ -139,6 +152,7 @@ const FAILURE_MESSAGES = {
     'handle-unavailable': 'The requested AWiki handle is unavailable.',
     'not-found': 'The requested AWiki resource was not found.',
     'forbidden': 'The AWiki operation is not permitted.',
+    'device-rejoin-required': 'This device credential was revoked and must join the Handle again.',
     'identity-recovery-required': 'The local AWiki identity must be recovered before it can be used again.',
     'conflict': 'The AWiki operation conflicts with current state.',
     'rate-limited': 'The AWiki service rate-limited the request.',
@@ -237,41 +251,25 @@ function serviceUrl(field, raw, allowInsecureLoopbackForTesting) {
     }
     return raw;
 }
-/** Resolve the only supported post-recovery endpoint without accepting URL-carried state. */
-function recoveryReconciliationEndpoint(target, allowInsecureLoopbackForTesting) {
-    if (target?.kind !== 'model-proxy-v1' || typeof target.baseURL !== 'string') {
-        throw new TypeError('awiki: recovery reconciliation target is invalid');
-    }
-    const baseURL = serviceUrl('recoveryReconciliationTarget.baseURL', target.baseURL, allowInsecureLoopbackForTesting);
-    const parsed = new URL(baseURL);
-    if (parsed.search !== '') {
-        throw new TypeError('awiki: recovery reconciliation target must not contain a query');
-    }
-    return new URL('/api/identity-recovery', parsed).toString();
-}
-/** Accept only the closed Model Proxy success response; no ledger identifier may cross back. */
-async function acceptsRecoveryReconciliation(response) {
-    if (!response.ok)
-        return false;
-    let value;
+function publishedServiceBaseUrl(services, name, allowInsecureLoopbackForTesting) {
+    if (typeof services !== 'object' || services === null || Array.isArray(services))
+        return undefined;
+    const candidate = services[name];
+    if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate))
+        return undefined;
+    const value = candidate;
+    if (value.enabled !== true || typeof value.base_url !== 'string')
+        return undefined;
     try {
-        const text = await readBoundedResponseText(response, RECOVERY_RECONCILIATION_RESPONSE_MAX_BYTES);
-        if (text === undefined)
-            return false;
-        value = JSON.parse(text);
+        const baseUrl = serviceUrl(`server-info.services.${name}.base_url`, value.base_url, allowInsecureLoopbackForTesting);
+        const parsed = new URL(baseUrl);
+        if (parsed.search !== '')
+            return undefined;
+        return baseUrl;
     }
     catch {
-        return false;
+        return undefined;
     }
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return false;
-    const result = value;
-    const keys = Object.keys(result).sort();
-    return keys.length === 2
-        && keys[0] === 'idempotent'
-        && keys[1] === 'restored'
-        && result.restored === true
-        && typeof result.idempotent === 'boolean';
 }
 /** Validate a provider domain without inferring it from an API endpoint. */
 function serviceDomain(raw, field = 'userServiceDomain') {
@@ -320,7 +318,7 @@ function listenerAllowedPeers(raw, enabled) {
     return peers;
 }
 /** Resolve and validate every deployment choice before publishing the service. */
-function resolveConfig(config) {
+function resolveConfig(ctx, config) {
     const allowInsecureLoopbackForTesting = config.allowInsecureLoopbackForTesting ?? false;
     const configuredStateRoot = config.stateRoot?.trim();
     const configuredDshHome = process.env.DSH_HOME?.trim();
@@ -328,7 +326,7 @@ function resolveConfig(config) {
         ? join(homedir(), '.dsh')
         : configuredDshHome;
     const stateRoot = configuredStateRoot === undefined || configuredStateRoot.length === 0
-        ? join(dshHome, 'awiki', 'im-core')
+        ? resolveAwikiStateRoot(ctx, dshHome)
         : configuredStateRoot;
     if (!isAbsolute(stateRoot))
         throw new TypeError('awiki: stateRoot must be an absolute path');
@@ -363,9 +361,16 @@ function resolveConfig(config) {
     const messageServiceUrl = serviceUrl('messageServiceUrl', config.messageServiceUrl ?? DEFAULT_AWIKI_SERVICE_URL, allowInsecureLoopbackForTesting);
     const mailServiceUrl = serviceUrl('mailServiceUrl', config.mailServiceUrl ?? userServiceUrl, allowInsecureLoopbackForTesting);
     const messageServicePublicUrl = serviceUrl('messageServicePublicUrl', config.messageServicePublicUrl ?? DEFAULT_AWIKI_SERVICE_URL, allowInsecureLoopbackForTesting);
+    const legacyTenantSlot = config.legacyTenantSlot?.trim();
+    if (legacyTenantSlot !== undefined
+        && legacyTenantSlot !== 'primary'
+        && legacyTenantSlot !== 'secondary') {
+        throw new TypeError('awiki: legacyTenantSlot must be primary or secondary');
+    }
     return {
         userServiceUrl,
         userServiceDomain: serviceDomain(config.userServiceDomain ?? DEFAULT_AWIKI_DOMAIN),
+        ...legacyTenantSlot === undefined ? {} : { legacyTenantSlot },
         messageServiceUrl,
         mailServiceUrl,
         messageServicePublicUrl,
@@ -390,6 +395,15 @@ function resolveConfig(config) {
 function failure(code) {
     return { code, message: FAILURE_MESSAGES[code] };
 }
+function integrationUnavailable() {
+    return {
+        ok: false,
+        error: {
+            code: 'unavailable',
+            message: 'Guest messaging is not available for the active AWiki tenant.',
+        },
+    };
+}
 /** Normalize SDK and provider failures without returning remote bodies, credentials, or causes. */
 function normalizeFailure(error) {
     if (error instanceof ProviderUnavailableError) {
@@ -506,7 +520,6 @@ function normalizeRecoveryPrepareRequest(request) {
 }
 const IDENTITY_ACCESS_RESPONSE_MAX_BYTES = 64 * 1024;
 const SERVER_INFO_RESPONSE_MAX_BYTES = 64 * 1024;
-const RECOVERY_RECONCILIATION_RESPONSE_MAX_BYTES = 4 * 1024;
 /** Read one untrusted discovery response without buffering beyond the fixed Host limit. */
 async function readBoundedResponseText(response, maxBytes) {
     const declaredLength = response.headers.get('content-length');
@@ -728,6 +741,12 @@ let AwikiService = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
     let _getConfig_decorators;
+    let _getIntegration_decorators;
+    let _createIntegration_decorators;
+    let _updateIntegration_decorators;
+    let _rotateIntegrationId_decorators;
+    let _closeIntegration_decorators;
+    let _reopenIntegration_decorators;
     let _getIdentity_decorators;
     let _getSession_decorators;
     let _logout_decorators;
@@ -735,7 +754,9 @@ let AwikiService = (() => {
     let _inspectIdentityAccess_decorators;
     let _sendRegistrationOtp_decorators;
     let _registerIdentity_decorators;
+    let _retireDeviceIdentityForRejoin_decorators;
     let _beginDeviceJoin_decorators;
+    let _getIdentityAccessState_decorators;
     let _getDeviceJoinStatus_decorators;
     let _cancelDeviceJoin_decorators;
     let _refreshDeviceManagement_decorators;
@@ -743,6 +764,8 @@ let AwikiService = (() => {
     let _approveDeviceJoin_decorators;
     let _rejectDeviceJoin_decorators;
     let _revokeDevice_decorators;
+    let _prepareRootTransfer_decorators;
+    let _confirmRootTransfer_decorators;
     let _updateDisplayName_decorators;
     let _getProfile_decorators;
     let _updateProfile_decorators;
@@ -751,12 +774,14 @@ let AwikiService = (() => {
     let _activateRecovery_decorators;
     let _getRecoveryStatus_decorators;
     let _resumeRecovery_decorators;
+    let _enterRecoveredSession_decorators;
     let _discardRecovery_decorators;
     let _resolvePeer_decorators;
     let _createGroup_decorators;
     let _getGroup_decorators;
     let _joinGroup_decorators;
     let _leaveGroup_decorators;
+    let _getDisplayProfiles_decorators;
     let _listGroupMembers_decorators;
     let _addGroupMember_decorators;
     let _removeGroupMember_decorators;
@@ -780,6 +805,12 @@ let AwikiService = (() => {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getConfig_decorators = [Remote];
+            _getIntegration_decorators = [Remote];
+            _createIntegration_decorators = [Remote];
+            _updateIntegration_decorators = [Remote];
+            _rotateIntegrationId_decorators = [Remote];
+            _closeIntegration_decorators = [Remote];
+            _reopenIntegration_decorators = [Remote];
             _getIdentity_decorators = [Remote];
             _getSession_decorators = [Remote];
             _logout_decorators = [Remote];
@@ -787,7 +818,9 @@ let AwikiService = (() => {
             _inspectIdentityAccess_decorators = [Remote];
             _sendRegistrationOtp_decorators = [Remote];
             _registerIdentity_decorators = [Remote];
+            _retireDeviceIdentityForRejoin_decorators = [Remote];
             _beginDeviceJoin_decorators = [Remote];
+            _getIdentityAccessState_decorators = [Remote];
             _getDeviceJoinStatus_decorators = [Remote];
             _cancelDeviceJoin_decorators = [Remote];
             _refreshDeviceManagement_decorators = [Remote];
@@ -795,6 +828,8 @@ let AwikiService = (() => {
             _approveDeviceJoin_decorators = [Remote];
             _rejectDeviceJoin_decorators = [Remote];
             _revokeDevice_decorators = [Remote];
+            _prepareRootTransfer_decorators = [Remote];
+            _confirmRootTransfer_decorators = [Remote];
             _updateDisplayName_decorators = [Remote];
             _getProfile_decorators = [Remote];
             _updateProfile_decorators = [Remote];
@@ -803,12 +838,14 @@ let AwikiService = (() => {
             _activateRecovery_decorators = [Remote];
             _getRecoveryStatus_decorators = [Remote];
             _resumeRecovery_decorators = [Remote];
+            _enterRecoveredSession_decorators = [Remote];
             _discardRecovery_decorators = [Remote];
             _resolvePeer_decorators = [Remote];
             _createGroup_decorators = [Remote];
             _getGroup_decorators = [Remote];
             _joinGroup_decorators = [Remote];
             _leaveGroup_decorators = [Remote];
+            _getDisplayProfiles_decorators = [Remote];
             _listGroupMembers_decorators = [Remote];
             _addGroupMember_decorators = [Remote];
             _removeGroupMember_decorators = [Remote];
@@ -829,6 +866,12 @@ let AwikiService = (() => {
             _sendMail_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, _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);
+            __esDecorate(this, null, _rotateIntegrationId_decorators, { kind: "method", name: "rotateIntegrationId", static: false, private: false, access: { has: obj => "rotateIntegrationId" in obj, get: obj => obj.rotateIntegrationId }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _closeIntegration_decorators, { kind: "method", name: "closeIntegration", static: false, private: false, access: { has: obj => "closeIntegration" in obj, get: obj => obj.closeIntegration }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _reopenIntegration_decorators, { kind: "method", name: "reopenIntegration", static: false, private: false, access: { has: obj => "reopenIntegration" in obj, get: obj => obj.reopenIntegration }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getIdentity_decorators, { kind: "method", name: "getIdentity", static: false, private: false, access: { has: obj => "getIdentity" in obj, get: obj => obj.getIdentity }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getSession_decorators, { kind: "method", name: "getSession", static: false, private: false, access: { has: obj => "getSession" in obj, get: obj => obj.getSession }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _logout_decorators, { kind: "method", name: "logout", static: false, private: false, access: { has: obj => "logout" in obj, get: obj => obj.logout }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -836,7 +879,9 @@ let AwikiService = (() => {
             __esDecorate(this, null, _inspectIdentityAccess_decorators, { kind: "method", name: "inspectIdentityAccess", static: false, private: false, access: { has: obj => "inspectIdentityAccess" in obj, get: obj => obj.inspectIdentityAccess }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _sendRegistrationOtp_decorators, { kind: "method", name: "sendRegistrationOtp", static: false, private: false, access: { has: obj => "sendRegistrationOtp" in obj, get: obj => obj.sendRegistrationOtp }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _registerIdentity_decorators, { kind: "method", name: "registerIdentity", static: false, private: false, access: { has: obj => "registerIdentity" in obj, get: obj => obj.registerIdentity }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _retireDeviceIdentityForRejoin_decorators, { kind: "method", name: "retireDeviceIdentityForRejoin", static: false, private: false, access: { has: obj => "retireDeviceIdentityForRejoin" in obj, get: obj => obj.retireDeviceIdentityForRejoin }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _beginDeviceJoin_decorators, { kind: "method", name: "beginDeviceJoin", static: false, private: false, access: { has: obj => "beginDeviceJoin" in obj, get: obj => obj.beginDeviceJoin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getIdentityAccessState_decorators, { kind: "method", name: "getIdentityAccessState", static: false, private: false, access: { has: obj => "getIdentityAccessState" in obj, get: obj => obj.getIdentityAccessState }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getDeviceJoinStatus_decorators, { kind: "method", name: "getDeviceJoinStatus", static: false, private: false, access: { has: obj => "getDeviceJoinStatus" in obj, get: obj => obj.getDeviceJoinStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _cancelDeviceJoin_decorators, { kind: "method", name: "cancelDeviceJoin", static: false, private: false, access: { has: obj => "cancelDeviceJoin" in obj, get: obj => obj.cancelDeviceJoin }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _refreshDeviceManagement_decorators, { kind: "method", name: "refreshDeviceManagement", static: false, private: false, access: { has: obj => "refreshDeviceManagement" in obj, get: obj => obj.refreshDeviceManagement }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -844,6 +889,8 @@ let AwikiService = (() => {
             __esDecorate(this, null, _approveDeviceJoin_decorators, { kind: "method", name: "approveDeviceJoin", static: false, private: false, access: { has: obj => "approveDeviceJoin" in obj, get: obj => obj.approveDeviceJoin }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _rejectDeviceJoin_decorators, { kind: "method", name: "rejectDeviceJoin", static: false, private: false, access: { has: obj => "rejectDeviceJoin" in obj, get: obj => obj.rejectDeviceJoin }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _revokeDevice_decorators, { kind: "method", name: "revokeDevice", static: false, private: false, access: { has: obj => "revokeDevice" in obj, get: obj => obj.revokeDevice }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _prepareRootTransfer_decorators, { kind: "method", name: "prepareRootTransfer", static: false, private: false, access: { has: obj => "prepareRootTransfer" in obj, get: obj => obj.prepareRootTransfer }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _confirmRootTransfer_decorators, { kind: "method", name: "confirmRootTransfer", static: false, private: false, access: { has: obj => "confirmRootTransfer" in obj, get: obj => obj.confirmRootTransfer }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateDisplayName_decorators, { kind: "method", name: "updateDisplayName", static: false, private: false, access: { has: obj => "updateDisplayName" in obj, get: obj => obj.updateDisplayName }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getProfile_decorators, { kind: "method", name: "getProfile", static: false, private: false, access: { has: obj => "getProfile" in obj, get: obj => obj.getProfile }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateProfile_decorators, { kind: "method", name: "updateProfile", static: false, private: false, access: { has: obj => "updateProfile" in obj, get: obj => obj.updateProfile }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -852,12 +899,14 @@ let AwikiService = (() => {
             __esDecorate(this, null, _activateRecovery_decorators, { kind: "method", name: "activateRecovery", static: false, private: false, access: { has: obj => "activateRecovery" in obj, get: obj => obj.activateRecovery }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getRecoveryStatus_decorators, { kind: "method", name: "getRecoveryStatus", static: false, private: false, access: { has: obj => "getRecoveryStatus" in obj, get: obj => obj.getRecoveryStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _resumeRecovery_decorators, { kind: "method", name: "resumeRecovery", static: false, private: false, access: { has: obj => "resumeRecovery" in obj, get: obj => obj.resumeRecovery }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _enterRecoveredSession_decorators, { kind: "method", name: "enterRecoveredSession", static: false, private: false, access: { has: obj => "enterRecoveredSession" in obj, get: obj => obj.enterRecoveredSession }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _discardRecovery_decorators, { kind: "method", name: "discardRecovery", static: false, private: false, access: { has: obj => "discardRecovery" in obj, get: obj => obj.discardRecovery }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _resolvePeer_decorators, { kind: "method", name: "resolvePeer", static: false, private: false, access: { has: obj => "resolvePeer" in obj, get: obj => obj.resolvePeer }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _createGroup_decorators, { kind: "method", name: "createGroup", static: false, private: false, access: { has: obj => "createGroup" in obj, get: obj => obj.createGroup }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getGroup_decorators, { kind: "method", name: "getGroup", static: false, private: false, access: { has: obj => "getGroup" in obj, get: obj => obj.getGroup }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _joinGroup_decorators, { kind: "method", name: "joinGroup", static: false, private: false, access: { has: obj => "joinGroup" in obj, get: obj => obj.joinGroup }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _leaveGroup_decorators, { kind: "method", name: "leaveGroup", static: false, private: false, access: { has: obj => "leaveGroup" in obj, get: obj => obj.leaveGroup }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getDisplayProfiles_decorators, { kind: "method", name: "getDisplayProfiles", static: false, private: false, access: { has: obj => "getDisplayProfiles" in obj, get: obj => obj.getDisplayProfiles }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _listGroupMembers_decorators, { kind: "method", name: "listGroupMembers", static: false, private: false, access: { has: obj => "listGroupMembers" in obj, get: obj => obj.listGroupMembers }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _addGroupMember_decorators, { kind: "method", name: "addGroupMember", static: false, private: false, access: { has: obj => "addGroupMember" in obj, get: obj => obj.addGroupMember }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _removeGroupMember_decorators, { kind: "method", name: "removeGroupMember", static: false, private: false, access: { has: obj => "removeGroupMember" in obj, get: obj => obj.removeGroupMember }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -884,11 +933,23 @@ let AwikiService = (() => {
         resolved = __runInitializers(this, _instanceExtraInitializers);
         sessionStore;
         imageAttachmentCache;
-        sentMailStore;
         conversationPreferenceStore;
         startupUserServiceDomain;
         settingsProvider;
+        tenantRegistry;
+        activeTenant;
+        activeClientOptions;
+        clientFactory;
         provider;
+        runtimeGeneration = 0;
+        tenantSwitching = false;
+        tenantParticipants = new Set();
+        activeCapabilities;
+        updatePolicyStatus;
+        updatePolicyRequest;
+        updatePolicyTask;
+        updatePolicyTaskKey;
+        desktopDistribution;
         signedOut;
         sessionMutation = Promise.resolve();
         sessionRevision = 0;
@@ -899,12 +960,14 @@ let AwikiService = (() => {
         requestSessions = new Map();
         deviceRefs = new Map();
         deviceIds = new Map();
+        rootTransfers = new Map();
         activeSummaryRequests = new Set();
         summaryProvider;
-        recoveryReconciliationTarget;
         hostContext;
         /** Trusted same-process external HTTP authentication dispatcher. Never Remote. */
         externalHttpAuth;
+        integrationClient;
+        mailListClient;
         workspaceContext;
         /**
          * @param ctx - owning Host context.
@@ -913,12 +976,8 @@ let AwikiService = (() => {
         constructor(ctx, config) {
             super(ctx, 'awiki');
             this.hostContext = ctx;
-            this.resolved = resolveConfig(config);
+            this.resolved = resolveConfig(ctx, config);
             this.externalHttpAuth = createAwikiExternalHttpAuth(() => this.acquireExternalHttpAuthSession());
-            this.sessionStore = new AwikiSessionStore(this.resolved.stateRoot);
-            this.imageAttachmentCache = new AwikiImageAttachmentCache(this.resolved.stateRoot, this.resolved.attachmentMaxBytes, this.resolved.imageAttachmentCacheMaxBytes);
-            this.sentMailStore = new AwikiSentMailStore(this.resolved.stateRoot);
-            this.conversationPreferenceStore = new AwikiConversationPreferenceStore(this.resolved.stateRoot);
             this.startupUserServiceDomain = this.resolved.userServiceDomain;
             ctx.inject(['settings'], (settingsCtx) => {
                 const provider = settingsCtx.settings;
@@ -937,7 +996,17 @@ let AwikiService = (() => {
                 }, 'awiki: release settings namespace');
             });
             ctx.inject(['connection'], (connectionCtx) => {
-                connectionCtx.connection.rpc.handle(AWIKI_SETTINGS_RPC_CHANNEL, createAwikiSettingsRpcHandler(() => this.settingsProvider), { authority: 'loopback' });
+                connectionCtx.connection.rpc.handle(AWIKI_SETTINGS_RPC_CHANNEL, createAwikiSettingsRpcHandler(() => this.settingsProvider, {
+                    describe: () => this.getTenantRegistryView(),
+                    create: (displayName, domain) => this.createCustomTenant(displayName, domain),
+                    rename: (tenantId, displayName) => this.renameCustomTenant(tenantId, displayName),
+                    switch: tenantId => this.switchTenant(tenantId),
+                    archive: tenantId => this.archiveCustomTenant(tenantId),
+                    describeUpdate: () => this.getUpdatePolicyStatus(),
+                    refreshUpdate: () => this.refreshUpdatePolicy(),
+                    describeDesktopUpdate: () => this.getDesktopUpdate(),
+                    refreshDesktopUpdate: () => this.refreshDesktopUpdate(),
+                }), { authority: 'loopback' });
             });
             ctx.inject(['workspaceRegistry'], (workspaceCtx) => {
                 this.workspaceContext = workspaceCtx;
@@ -953,8 +1022,29 @@ let AwikiService = (() => {
                         await this.stopAgentConsumer(current);
                 }, 'awiki: release Workspace listener composition');
             });
+            ctx.inject(['desktopDistribution'], desktopCtx => {
+                const service = desktopCtx.get('desktopDistribution');
+                if (typeof service !== 'object' || service === null
+                    || !('getSnapshot' in service) || typeof service.getSnapshot !== 'function'
+                    || !('check' in service) || typeof service.check !== 'function')
+                    return;
+                const candidate = service;
+                if (decodeDesktopDistribution(candidate.getSnapshot()) === undefined)
+                    return;
+                this.desktopDistribution = candidate;
+                desktopCtx.effect(() => () => {
+                    if (this.desktopDistribution === candidate)
+                        this.desktopDistribution = undefined;
+                });
+            });
+            ctx.effect(() => {
+                const timer = setInterval(() => { void this.refreshUpdatePolicy().catch(() => undefined); }, 6 * 60 * 60 * 1000);
+                timer.unref();
+                return () => { clearInterval(timer); };
+            });
             registerAwikiTools(ctx, this);
             ctx.effect(() => async () => {
+                this.updatePolicyRequest?.abort();
                 const provider = this.provider;
                 if (provider !== undefined)
                     await this.disposeProvider(provider);
@@ -971,32 +1061,334 @@ let AwikiService = (() => {
          * @returns asynchronous disposer for the exact registered client.
          */
         registerClientFactory(factory) {
-            if (this.provider !== undefined)
+            if (this.clientFactory !== undefined || this.provider !== undefined) {
                 throw new Error('awiki: a client provider is already registered');
-            this.pendingDeviceJoin = undefined;
-            this.activeDeviceJoinSessionId = undefined;
-            const client = factory({
-                userServiceUrl: this.resolved.userServiceUrl,
-                userServiceDomain: this.startupUserServiceDomain,
-                messageServiceUrl: this.resolved.messageServiceUrl,
-                mailServiceUrl: this.resolved.mailServiceUrl,
-                messageServicePublicUrl: this.resolved.messageServicePublicUrl,
-                messageServiceDid: this.resolved.messageServiceDid,
-                allowedAttachmentOrigins: this.resolved.allowedAttachmentOrigins,
+            }
+            this.clientFactory = factory;
+            try {
+                this.openTenantProvider(this.ensureTenantRegistry().active(), factory);
+            }
+            catch (error) {
+                this.clientFactory = undefined;
+                throw error;
+            }
+            let active = true;
+            return async () => {
+                if (!active)
+                    return;
+                active = false;
+                this.clientFactory = undefined;
+                const current = this.provider;
+                if (current !== undefined)
+                    await this.disposeProvider(current);
+            };
+        }
+        ensureTenantRegistry() {
+            if (this.tenantRegistry !== undefined)
+                return this.tenantRegistry;
+            const domain = this.startupUserServiceDomain;
+            const configuredOrigin = `https://${this.resolved.userServiceDomain}`;
+            const tenantOrigin = `https://${domain}`;
+            const derive = (value) => value.replace(/\/$/u, '') === configuredOrigin ? tenantOrigin : value;
+            const seed = {
+                domain,
+                configured: domain !== DEFAULT_AWIKI_DOMAIN
+                    || this.resolved.userServiceUrl.replace(/\/$/u, '') !== configuredOrigin
+                    || this.resolved.messageServiceUrl.replace(/\/$/u, '') !== configuredOrigin,
+                ...this.resolved.legacyTenantSlot === undefined
+                    ? {}
+                    : { legacyTenantSlot: this.resolved.legacyTenantSlot },
+                userServiceUrl: derive(this.resolved.userServiceUrl),
+                messageServiceUrl: derive(this.resolved.messageServiceUrl),
+                mailServiceUrl: derive(this.resolved.mailServiceUrl),
+                messageServicePublicUrl: derive(this.resolved.messageServicePublicUrl),
+                messageServiceDid: this.resolved.messageServiceDid === `did:wba:${this.resolved.userServiceDomain}`
+                    ? `did:wba:${domain}`
+                    : this.resolved.messageServiceDid,
+            };
+            this.tenantRegistry = AwikiTenantRegistry.open(this.resolved.stateRoot, seed);
+            return this.tenantRegistry;
+        }
+        optionsForTenant(tenant) {
+            const endpoints = tenant.endpoints;
+            const messageServicePublicOrigin = new URL(endpoints.messageServicePublicUrl).origin;
+            return {
+                ...endpoints,
+                userServiceDomain: tenant.didHost,
+                allowedAttachmentOrigins: tenant.storageLayout === 'legacy-base'
+                    ? this.resolved.allowedAttachmentOrigins
+                    : [messageServicePublicOrigin],
                 attachmentMaxBytes: this.resolved.attachmentMaxBytes,
                 allowInsecureLoopbackForTesting: this.resolved.allowInsecureLoopbackForTesting,
-                stateRoot: this.resolved.stateRoot,
-            });
+                stateRoot: this.ensureTenantRegistry().stateRoot(tenant),
+            };
+        }
+        ensureTenantOptions() {
+            if (this.activeClientOptions !== undefined)
+                return this.activeClientOptions;
+            const tenant = this.ensureTenantRegistry().active();
+            const options = this.optionsForTenant(tenant);
+            this.bindTenantState(tenant, options);
+            return options;
+        }
+        bindTenantState(tenant, options) {
+            this.updatePolicyRequest?.abort();
+            this.updatePolicyStatus = undefined;
+            this.updatePolicyTask = undefined;
+            this.activeTenant = tenant;
+            this.activeClientOptions = options;
+            this.startupUserServiceDomain = tenant.didHost;
+            this.sessionStore = new AwikiSessionStore(options.stateRoot);
+            this.imageAttachmentCache = new AwikiImageAttachmentCache(options.stateRoot, this.resolved.attachmentMaxBytes, this.resolved.imageAttachmentCacheMaxBytes);
+            this.conversationPreferenceStore = new AwikiConversationPreferenceStore(options.stateRoot);
+            this.mailListClient = new AwikiMailListClient(options.mailServiceUrl, this.externalHttpAuth);
+            this.integrationClient = undefined;
+            this.activeCapabilities = {
+                tenantId: tenant.tenantId,
+                generation: this.runtimeGeneration,
+                online: false,
+                handleRecoveryPhoneEnabled: false,
+            };
+            this.signedOut = undefined;
+            this.activeIdentityDid = undefined;
+            this.pendingDeviceJoin = undefined;
+            this.activeDeviceJoinSessionId = undefined;
+        }
+        openTenantProvider(tenant, factory, startRuntime = true) {
+            const options = this.optionsForTenant(tenant);
+            const client = factory(options);
             const provider = {
                 client,
                 realtimeGeneration: 0,
                 agentConsumerGeneration: 0,
                 localDeviceJoinRequestCountAfterSync: 0,
             };
+            this.bindTenantState(tenant, options);
             this.provider = provider;
-            this.ensureRealtimeSupervisor(provider);
-            this.ensureAgentConsumer(provider);
-            return () => this.disposeProvider(provider);
+            void this.refreshUpdatePolicy().catch(() => undefined);
+            if (startRuntime)
+                this.ensureProviderRuntime(provider);
+            return provider;
+        }
+        /** Read the Host-owned catalog for trusted loopback settings surfaces. */
+        getTenantRegistryView() {
+            return this.ensureTenantRegistry().snapshot(this.tenantSwitching);
+        }
+        /** Browser-safe, same-process update state for Desktop and loopback settings. */
+        getUpdatePolicyStatus() {
+            const tenant = this.activeTenant ?? this.ensureTenantRegistry().active();
+            const modelProxyVersion = this.currentModelProxyVersion();
+            return this.updatePolicyStatus ?? readAwikiUpdatePolicyStatus({
+                tenant, generation: this.runtimeGeneration, stateRoot: this.resolved.stateRoot,
+                currentPluginVersion: DSH_AWIKI_VERSION,
+                ...modelProxyVersion === undefined ? {} : { currentModelProxyVersion: modelProxyVersion },
+            });
+        }
+        /** Only the Desktop provider owns its release source; tenants cannot override it. */
+        getDesktopUpdate() {
+            return decodeDesktopDistribution(this.desktopDistribution?.getSnapshot());
+        }
+        async refreshDesktopUpdate() {
+            const provider = this.desktopDistribution;
+            if (provider === undefined)
+                return undefined;
+            const value = await provider.check();
+            return provider === this.desktopDistribution ? decodeDesktopDistribution(value) : this.getDesktopUpdate();
+        }
+        /** Refresh only the active generation; late results from old tenants are discarded. */
+        refreshUpdatePolicy() {
+            const key = JSON.stringify([this.runtimeGeneration, this.currentModelProxyVersion()]);
+            if (this.updatePolicyTask !== undefined && this.updatePolicyTaskKey === key)
+                return this.updatePolicyTask;
+            const task = this.performUpdatePolicyRefresh().finally(() => {
+                if (this.updatePolicyTask === task)
+                    this.updatePolicyTask = undefined;
+            });
+            this.updatePolicyTask = task;
+            this.updatePolicyTaskKey = key;
+            return task;
+        }
+        async performUpdatePolicyRefresh() {
+            const tenant = this.activeTenant ?? this.ensureTenantRegistry().active();
+            const generation = this.runtimeGeneration;
+            this.updatePolicyRequest?.abort();
+            const request = new AbortController();
+            this.updatePolicyRequest = request;
+            const currentModelProxyVersion = this.currentModelProxyVersion();
+            const status = await checkAwikiUpdatePolicy({
+                tenant,
+                generation,
+                stateRoot: this.resolved.stateRoot,
+                currentPluginVersion: DSH_AWIKI_VERSION,
+                ...currentModelProxyVersion === undefined ? {} : { currentModelProxyVersion },
+                allowInsecureLoopback: this.resolved.allowInsecureLoopbackForTesting,
+                signal: request.signal,
+            });
+            if (this.updatePolicyRequest === request
+                && this.runtimeGeneration === generation
+                && this.activeTenant?.tenantId === tenant.tenantId) {
+                const wasRestricted = this.getUpdatePolicyStatus().restricted;
+                this.updatePolicyStatus = status;
+                this.hostContext.emit('awiki/update-policy', status);
+                if (status.restricted) {
+                    this.invalidateSummaries();
+                    const provider = this.provider;
+                    if (provider !== undefined) {
+                        try {
+                            await this.stopProviderRuntime(provider);
+                        }
+                        catch (error) {
+                            this.ctx.logger('awiki-update').warn('AWiki restricted-version runtime shutdown failed: %s', error instanceof Error ? error.message : 'unknown failure');
+                        }
+                    }
+                }
+                else if (wasRestricted && this.provider !== undefined && !this.tenantSwitching) {
+                    this.ensureProviderRuntime(this.provider);
+                }
+            }
+            return this.getUpdatePolicyStatus();
+        }
+        currentModelProxyVersion() {
+            for (const participant of this.tenantParticipants) {
+                if (participant.component?.product === 'dsh-awiki-model-proxy')
+                    return participant.component.version;
+            }
+            return undefined;
+        }
+        createCustomTenant(displayName, domain) {
+            this.assertVersionSupported();
+            this.ensureTenantRegistry().createCustom(displayName, domain);
+            return this.getTenantRegistryView();
+        }
+        renameCustomTenant(tenantId, displayName) {
+            this.assertVersionSupported();
+            this.ensureTenantRegistry().renameCustom(tenantId, displayName);
+            return this.getTenantRegistryView();
+        }
+        archiveCustomTenant(tenantId) {
+            this.assertVersionSupported();
+            this.ensureTenantRegistry().archiveCustom(tenantId);
+            return this.getTenantRegistryView();
+        }
+        /** Register one same-process resource owner in every transactional tenant change. */
+        registerTenantLifecycleParticipant(participant) {
+            if (this.tenantParticipants.has(participant))
+                throw new Error('awiki: tenant lifecycle participant is already registered');
+            this.tenantParticipants.add(participant);
+            if (participant.component !== undefined)
+                this.updatePolicyStatus = undefined;
+            void this.refreshUpdatePolicy().catch(() => undefined);
+            let active = true;
+            return () => {
+                if (!active)
+                    return;
+                active = false;
+                this.tenantParticipants.delete(participant);
+                if (participant.component !== undefined)
+                    this.updatePolicyStatus = undefined;
+                void this.refreshUpdatePolicy().catch(() => undefined);
+            };
+        }
+        /** Replace the complete Core runtime and commit the active tenant only after opening succeeds. */
+        async switchTenant(tenantId) {
+            if (this.tenantSwitching)
+                throw new Error('awiki: a tenant switch is already in progress');
+            const registry = this.ensureTenantRegistry();
+            const previousTenant = registry.active();
+            if (previousTenant.tenantId === tenantId)
+                return this.getTenantRegistryView();
+            const target = registry.find(tenantId);
+            if (target === undefined || target.lifecycle === 'archived')
+                throw new Error('awiki: target tenant is unavailable');
+            const factory = this.clientFactory;
+            const previousProvider = this.provider;
+            if (factory === undefined || previousProvider === undefined)
+                throw new Error('awiki: client provider is unavailable');
+            this.tenantSwitching = true;
+            this.updatePolicyRequest?.abort();
+            this.updatePolicyTask = undefined;
+            const context = {
+                from: previousTenant,
+                to: target,
+                generation: ++this.runtimeGeneration,
+            };
+            const prepared = [];
+            let targetOpened = false;
+            let committed = false;
+            try {
+                await this.sessionMutation;
+                this.invalidateSummaries();
+                for (const participant of this.tenantParticipants) {
+                    await participant.prepareSwitch(context);
+                    prepared.push(participant);
+                }
+                await this.disposeProvider(previousProvider);
+                const targetProvider = this.openTenantProvider(target, factory, false);
+                targetOpened = true;
+                // The factory returns an adapter immediately; its native Core opens asynchronously.
+                // A local identity read proves both open and Registry loading before committing the switch.
+                await targetProvider.client.getIdentity();
+                await Promise.all([this.discoverTenantCapabilities(3_000), this.refreshUpdatePolicy()]);
+                registry.commitActive(target.tenantId);
+                committed = true;
+                for (const participant of prepared)
+                    await participant.commitSwitch?.(context);
+                this.tenantSwitching = false;
+                this.ensureProviderRuntime(targetProvider);
+                const view = this.getTenantRegistryView();
+                this.hostContext.emit('awiki/tenant', view);
+                return view;
+            }
+            catch (error) {
+                const rollbackFailures = [];
+                if (targetOpened) {
+                    const current = this.provider;
+                    if (current !== undefined) {
+                        try {
+                            await this.disposeProvider(current);
+                        }
+                        catch (rollbackError) {
+                            rollbackFailures.push(rollbackError);
+                        }
+                    }
+                }
+                if (committed) {
+                    try {
+                        registry.commitActive(previousTenant.tenantId);
+                    }
+                    catch (rollbackError) {
+                        rollbackFailures.push(rollbackError);
+                    }
+                }
+                if (this.provider === undefined) {
+                    try {
+                        const restored = this.openTenantProvider(previousTenant, factory, false);
+                        await restored.client.getIdentity();
+                        this.ensureProviderRuntime(restored);
+                    }
+                    catch (rollbackError) {
+                        rollbackFailures.push(rollbackError);
+                    }
+                }
+                for (const participant of prepared.reverse()) {
+                    try {
+                        await participant.rollbackSwitch?.(context);
+                    }
+                    catch (rollbackError) {
+                        rollbackFailures.push(rollbackError);
+                    }
+                }
+                if (rollbackFailures.length > 0) {
+                    throw new AggregateError([error, ...rollbackFailures], 'awiki: tenant switch failed and rollback was incomplete');
+                }
+                this.tenantSwitching = false;
+                if (this.provider !== undefined)
+                    this.ensureProviderRuntime(this.provider);
+                throw new Error('awiki: tenant switch failed; the previous tenant was restored', { cause: error });
+            }
+            finally {
+                this.tenantSwitching = false;
+            }
         }
         /** Safe same-process diagnostics for focused E2E. Never exposed through Typert Remote. */
         getRealtimeDiagnostics() {
@@ -1016,25 +1408,6 @@ let AwikiService = (() => {
                 localDeviceJoinRequestCountAfterSync: provider?.localDeviceJoinRequestCountAfterSync ?? 0,
             };
         }
-        /** Register the optional Model Proxy recovery target without exposing an arbitrary callback or token. */
-        registerRecoveryReconciliationTarget(target) {
-            if (this.recoveryReconciliationTarget !== undefined) {
-                throw new Error('awiki: a recovery reconciliation target is already registered');
-            }
-            const registered = Object.freeze({
-                endpoint: recoveryReconciliationEndpoint(target, this.resolved.allowInsecureLoopbackForTesting),
-            });
-            this.recoveryReconciliationTarget = registered;
-            let active = true;
-            return () => {
-                if (!active)
-                    return;
-                active = false;
-                if (this.recoveryReconciliationTarget === registered) {
-                    this.recoveryReconciliationTarget = undefined;
-                }
-            };
-        }
         /** Register one replaceable conversation-summary provider for this deployment. */
         registerSummaryProvider(provider) {
             if (this.summaryProvider !== undefined)
@@ -1054,42 +1427,144 @@ let AwikiService = (() => {
          * @returns Browser-safe polling configuration without SDK endpoints or state paths.
          */
         async getConfig() {
-            let handleRecoveryPhoneEnabled = false;
+            this.ensureTenantOptions();
+            const capabilities = await this.discoverTenantCapabilities(10_000);
+            if (this.tenantSwitching
+                || capabilities.generation !== this.runtimeGeneration
+                || capabilities.tenantId !== this.activeTenant?.tenantId) {
+                return { ok: false, error: failure('conflict') };
+            }
+            return {
+                ok: true,
+                value: {
+                    pollIntervalMs: this.resolved.pollIntervalMs,
+                    attachmentMaxBytes: this.resolved.attachmentMaxBytes,
+                    handleRecoveryPhoneEnabled: capabilities.handleRecoveryPhoneEnabled,
+                    ...capabilities.guestGatewayBaseUrl === undefined
+                        ? {}
+                        : { integrationGuideUrl: new URL('/guest/guide/integration', capabilities.guestGatewayBaseUrl).toString() },
+                    tenantId: capabilities.tenantId,
+                    tenantGeneration: capabilities.generation,
+                    tenantOnline: capabilities.online,
+                    services: {
+                        modelProxy: { enabled: capabilities.modelProxyBaseUrl !== undefined },
+                        guestGateway: { enabled: capabilities.guestGatewayBaseUrl !== undefined },
+                    },
+                },
+            };
+        }
+        /** Trusted same-process capability binding for optional tenant participants. */
+        getTenantCapabilities() {
+            const capabilities = this.activeCapabilities;
+            if (capabilities === undefined)
+                throw new Error('awiki: tenant capabilities are unavailable');
+            return { ...capabilities };
+        }
+        /** Refresh the active tenant's optional service advertisement without affecting Core availability. */
+        refreshTenantCapabilities() {
+            this.ensureTenantOptions();
+            return this.discoverTenantCapabilities(10_000);
+        }
+        async discoverTenantCapabilities(timeoutMs) {
+            const options = this.activeClientOptions;
+            const tenant = this.activeTenant;
+            if (options === undefined || tenant === undefined)
+                throw new ProviderUnavailableError();
+            const generation = this.runtimeGeneration;
+            const fallback = {
+                tenantId: tenant.tenantId,
+                generation,
+                online: false,
+                handleRecoveryPhoneEnabled: false,
+            };
+            const publish = (capabilities) => {
+                if (this.runtimeGeneration === generation && this.activeTenant?.tenantId === tenant.tenantId) {
+                    this.activeCapabilities = capabilities;
+                    this.integrationClient = capabilities.guestGatewayBaseUrl === undefined
+                        ? undefined
+                        : new AwikiIntegrationClient(capabilities.guestGatewayBaseUrl, this.externalHttpAuth);
+                }
+                return capabilities;
+            };
             const abort = new AbortController();
-            const timeout = setTimeout(() => { abort.abort(); }, 10_000);
+            const timeout = setTimeout(() => { abort.abort(); }, timeoutMs);
             try {
-                const response = await fetch(new URL('/user-service/v1/server-info', this.resolved.userServiceUrl), {
+                const endpoint = new URL('/user-service/v1/server-info', options.userServiceUrl);
+                endpoint.searchParams.set('client_platform', 'dsh');
+                const response = await fetch(endpoint, {
                     method: 'GET',
                     headers: { accept: 'application/json', 'cache-control': 'no-store' },
                     cache: 'no-store',
                     redirect: 'error',
                     signal: abort.signal,
                 });
-                if (response.ok) {
-                    const text = await readBoundedResponseText(response, SERVER_INFO_RESPONSE_MAX_BYTES);
-                    const value = text === undefined ? undefined : JSON.parse(text);
-                    if (typeof value === 'object' && value !== null && value.schema_version === 1) {
-                        const methods = value.identity?.handle_recovery?.methods;
-                        handleRecoveryPhoneEnabled = 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'));
-                    }
-                }
+                if (!response.ok)
+                    return publish(fallback);
+                const text = await readBoundedResponseText(response, SERVER_INFO_RESPONSE_MAX_BYTES);
+                const value = text === undefined ? undefined : JSON.parse(text);
+                if (typeof value !== 'object' || value === null || value.schema_version !== 1)
+                    return publish(fallback);
+                const methods = value.identity?.handle_recovery?.methods;
+                const handleRecoveryPhoneEnabled = 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 modelProxyBaseUrl = publishedServiceBaseUrl(services, 'model_proxy', this.resolved.allowInsecureLoopbackForTesting);
+                const guestGatewayBaseUrl = publishedServiceBaseUrl(services, 'guest_gateway', false);
+                const capabilities = {
+                    tenantId: tenant.tenantId,
+                    generation,
+                    online: true,
+                    handleRecoveryPhoneEnabled,
+                    ...modelProxyBaseUrl === undefined ? {} : { modelProxyBaseUrl },
+                    ...guestGatewayBaseUrl === undefined ? {} : { guestGatewayBaseUrl },
+                };
+                return publish(capabilities);
+            }
+            catch {
+                return publish(fallback);
             }
-            catch { }
             finally {
                 clearTimeout(timeout);
             }
-            return {
-                ok: true,
-                value: {
-                    pollIntervalMs: this.resolved.pollIntervalMs,
-                    attachmentMaxBytes: this.resolved.attachmentMaxBytes,
-                    handleRecoveryPhoneEnabled,
-                },
-            };
+        }
+        /** Read the Integration owned by the active full Handle through the fixed Host client. */
+        getIntegration() {
+            if (this.getUpdatePolicyStatus().restricted)
+                return Promise.resolve(integrationUnavailable());
+            return this.integrationClient?.read() ?? Promise.resolve(integrationUnavailable());
+        }
+        /** Create the active full Handle's only Integration. */
+        createIntegration(request) {
+            if (this.getUpdatePolicyStatus().restricted)
+                return Promise.resolve(integrationUnavailable());
+            return this.integrationClient?.create(request) ?? Promise.resolve(integrationUnavailable());
+        }
+        /** Update editable Integration fields with optimistic concurrency. */
+        updateIntegration(request) {
+            if (this.getUpdatePolicyStatus().restricted)
+                return Promise.resolve(integrationUnavailable());
+            return this.integrationClient?.update(request) ?? Promise.resolve(integrationUnavailable());
+        }
+        /** Atomically replace the current public Integration id. */
+        rotateIntegrationId(request) {
+            if (this.getUpdatePolicyStatus().restricted)
+                return Promise.resolve(integrationUnavailable());
+            return this.integrationClient?.rotate(request) ?? Promise.resolve(integrationUnavailable());
+        }
+        /** Close the Integration and revoke its current public id. */
+        closeIntegration(request) {
+            if (this.getUpdatePolicyStatus().restricted)
+                return Promise.resolve(integrationUnavailable());
+            return this.integrationClient?.close(request) ?? Promise.resolve(integrationUnavailable());
+        }
+        /** Revalidate one closed Integration and issue a new public id. */
+        reopenIntegration(request) {
+            if (this.getUpdatePolicyStatus().restricted)
+                return Promise.resolve(integrationUnavailable());
+            return this.integrationClient?.reopen(request) ?? Promise.resolve(integrationUnavailable());
         }
         /**
          * Read the deployment's identity status.
@@ -1123,6 +1598,8 @@ let AwikiService = (() => {
             if (request?.confirmation !== AWIKI_LOGOUT_CONFIRMATION) {
                 return Promise.resolve({ ok: false, error: failure('invalid-request') });
             }
+            // Fence pending post-Recovery work before the serialized sign-out reaches the head of the queue.
+            this.sessionRevision += 1;
             return this.mutateSession(async () => {
                 if (await this.isSignedOut())
                     return { ok: true, value: { status: 'signed-out' } };
@@ -1175,10 +1652,13 @@ let AwikiService = (() => {
         }
         /** Classify one configured-domain Handle before selecting the registration or recovery OTP purpose. */
         async inspectIdentityAccess(request) {
-            const target = identityAccessTarget(request, this.startupUserServiceDomain);
+            const options = this.activeClientOptions;
+            if (options === undefined)
+                return { ok: false, error: normalizeFailure(new ProviderUnavailableError()) };
+            const target = identityAccessTarget(request, options.userServiceDomain);
             if (target === undefined)
                 return { ok: false, error: failure('invalid-request') };
-            const endpoint = new URL(`/.well-known/handle/${encodeURIComponent(target.localPart)}`, this.resolved.userServiceUrl);
+            const endpoint = new URL(`/.well-known/handle/${encodeURIComponent(target.localPart)}`, options.userServiceUrl);
             const abort = new AbortController();
             const timeout = setTimeout(() => { abort.abort(); }, 10_000);
             let response;
@@ -1267,25 +1747,88 @@ let AwikiService = (() => {
                 },
             };
         }
+        /** Retire only this revoked device credential; ordinary local messages remain for the rejoined identity. */
+        retireDeviceIdentityForRejoin() {
+            return this.mutateSession(async () => {
+                const provider = this.provider;
+                if (provider !== undefined)
+                    await this.stopProviderRuntime(provider);
+                const result = await this.run(client => client.retireDefaultIdentityForRejoin(), { allowSignedOut: true });
+                if (!result.ok) {
+                    if (provider !== undefined && this.provider === provider)
+                        this.ensureProviderRuntime(provider);
+                    return result;
+                }
+                try {
+                    await this.sessionStore.signIn();
+                }
+                catch {
+                    try {
+                        await this.sessionStore.signIn();
+                    }
+                    catch {
+                        this.ctx.logger('awiki').warn('AWiki local session marker could not be refreshed after device retirement');
+                    }
+                }
+                this.signedOut = false;
+                this.activeIdentityDid = undefined;
+                this.pendingDeviceJoin = undefined;
+                this.activeDeviceJoinSessionId = undefined;
+                this.invalidateSummaries();
+                this.publishSession({ status: 'unregistered' });
+                return { ok: true, value: { completed: true } };
+            });
+        }
         /** Consume the exact in-memory continuation; ordinary Join never claims rebind user presence. */
         async beginDeviceJoin() {
             const continuation = this.pendingDeviceJoin;
             if (continuation === undefined)
                 return { ok: false, error: failure('conflict') };
-            if (continuation.mode !== 'ordinary' || continuation.requiresUserPresence) {
+            if ((continuation.mode === 'ordinary' && continuation.requiresUserPresence)
+                || (continuation.mode === 'handle-recovery-rebind' && !continuation.requiresUserPresence)) {
                 return { ok: false, error: failure('forbidden') };
             }
-            this.pendingDeviceJoin = undefined;
-            const result = await this.run(client => client.beginDeviceJoin({
-                continuationId: continuation.continuationId,
-                operationId: `dsh-device-join-${randomUUID()}`,
-                userPresenceConfirmed: false,
-            }));
+            const result = await this.run(async (client) => {
+                let userPresenceConfirmed = false;
+                if (continuation.mode === 'handle-recovery-rebind') {
+                    if (!client.trustedUserPresenceSupported) {
+                        throw Object.assign(new Error('trusted user presence unsupported'), { name: 'AwikiSdkError', code: 'forbidden' });
+                    }
+                    userPresenceConfirmed = await client.confirmUserPresence('Rejoin your recovered AWiki identity on this device');
+                    if (!userPresenceConfirmed) {
+                        throw Object.assign(new Error('user presence denied'), { name: 'AwikiSdkError', code: 'forbidden' });
+                    }
+                }
+                this.pendingDeviceJoin = undefined;
+                return client.beginDeviceJoin({
+                    continuationId: continuation.continuationId,
+                    operationId: `dsh-device-join-${randomUUID()}`,
+                    userPresenceConfirmed,
+                });
+            });
             if (!result.ok)
                 return result;
             this.activeDeviceJoinSessionId = result.value.joinSessionId;
             return this.applyCandidateJoinProgress(result.value);
         }
+        /** Read local workflow authority before offering a new login. No remote mutations. */
+        getIdentityAccessState() {
+            return this.run(async (client) => {
+                const joining = await this.selectDeviceJoinSession(client) !== null;
+                const recoveries = await client.listPendingRecoveries();
+                const domain = this.activeClientOptions?.userServiceDomain;
+                const choice = this.pendingDeviceJoin;
+                return {
+                    choice: joining || choice === undefined ? null : {
+                        status: 'join-required',
+                        fullHandle: choice.fullHandle,
+                        mode: choice.mode, requiresUserPresence: choice.requiresUserPresence,
+                    },
+                    joining,
+                    recoveries: recoveries.filter(value => domain !== undefined && value.fullHandle.slice(value.fullHandle.indexOf('.') + 1) === domain),
+                };
+            }, { allowSignedOut: true });
+        }
         /** Restore from Core local_sessions and advance only the exact resumable Join. */
         async getDeviceJoinStatus() {
             const result = await this.run(async (client) => {
@@ -1376,7 +1919,26 @@ let AwikiService = (() => {
                     throw Object.assign(new Error('sas mismatch'), { name: 'AwikiSdkError', code: 'forbidden' });
                 }
                 const prompt = await client.prepareDeviceJoinApproval(joinSessionId);
-                return client.confirmDeviceJoinApproval(prompt.approvalHandle);
+                try {
+                    return await client.confirmDeviceJoinApproval(prompt.approvalHandle);
+                }
+                catch (error) {
+                    // Approval is a remote mutation: its response may fail after Core has
+                    // already committed both the provider document and the local terminal
+                    // Join state. Re-read the authoritative terminal state before exposing
+                    // a false failure to the administrator.
+                    try {
+                        await client.syncDeviceManagement();
+                    }
+                    catch { }
+                    try {
+                        const recovered = await client.getLocalDeviceJoinVerificationProgress(joinSessionId);
+                        if (adminJoinPhase(recovered) === 'authorized')
+                            return recovered;
+                    }
+                    catch { }
+                    throw error;
+                }
             });
             return result.ok ? this.publicAdminJoinProgress(request.requestRef, result.value) : result;
         }
@@ -1410,6 +1972,53 @@ let AwikiService = (() => {
                 return this.deviceManagementSnapshot(client);
             });
         }
+        /** Prepare a short-lived Core authorization without exposing it to Browser. */
+        async prepareRootTransfer(request) {
+            const deviceId = this.deviceIds.get(request?.deviceRef);
+            if (deviceId === undefined)
+                return { ok: false, error: failure('invalid-request') };
+            return this.run(async (client) => {
+                const did = await this.requireRootTransferRecipient(client, deviceId);
+                const preparation = await client.prepareRootKeyTransfer(deviceId);
+                if (preparation.recipient.did !== did || preparation.recipient.deviceId !== deviceId) {
+                    throw Object.assign(new Error('root transfer recipient mismatch'), { name: 'AwikiSdkError', code: 'remote' });
+                }
+                for (const [reference, pending] of this.rootTransfers) {
+                    if (pending.deviceId === deviceId)
+                        this.rootTransfers.delete(reference);
+                }
+                const transferRef = `root-transfer-${randomUUID()}`;
+                this.rootTransfers.set(transferRef, {
+                    authorizationHandle: preparation.authorizationHandle,
+                    deviceId,
+                    deviceRef: request.deviceRef,
+                    did,
+                });
+                return { transferRef, deviceRef: request.deviceRef, expiresAt: preparation.expiresAt };
+            });
+        }
+        /** Authenticate locally, recheck fresh context, then consume one exact Core authorization. */
+        async confirmRootTransfer(request) {
+            const pending = this.rootTransfers.get(request?.transferRef);
+            if (pending === undefined)
+                return { ok: false, error: failure('invalid-request') };
+            this.rootTransfers.delete(request.transferRef);
+            return this.run(async (client) => {
+                const confirmed = await client.confirmUserPresence('Grant AWiki device management access');
+                if (!confirmed) {
+                    throw Object.assign(new Error('user presence denied'), { name: 'AwikiSdkError', code: 'forbidden' });
+                }
+                const did = await this.requireRootTransferRecipient(client, pending.deviceId);
+                if (did !== pending.did) {
+                    throw Object.assign(new Error('root transfer identity changed'), { name: 'AwikiSdkError', code: 'forbidden' });
+                }
+                const sent = await client.confirmAndSendRootKeyTransfer(pending.authorizationHandle);
+                if (sent.recipientDeviceId !== pending.deviceId) {
+                    throw Object.assign(new Error('root transfer receipt mismatch'), { name: 'AwikiSdkError', code: 'remote' });
+                }
+                return { deviceRef: pending.deviceRef, acceptedAt: sent.acceptedAt };
+            });
+        }
         /**
          * Update the deployment identity's public WNS display name.
          * @param request - replacement display name selected by the user.
@@ -1457,33 +2066,35 @@ let AwikiService = (() => {
             const normalized = normalizeRecoveryOperation(request);
             if (normalized === undefined)
                 return { ok: false, error: failure('invalid-request') };
-            const result = await this.run(client => client.activateRecovery(normalized), { allowSignedOut: true });
-            if (result.ok && !await this.applyRecoveredSession(result.value)) {
-                return { ok: false, error: failure('remote') };
-            }
-            return result;
+            return this.run(client => client.activateRecovery(normalized), { allowSignedOut: true });
         }
         /** Read durable recovery state before deciding whether a retry is valid. */
         async getRecoveryStatus(request) {
             const normalized = normalizeRecoveryOperation(request);
             if (normalized === undefined)
                 return { ok: false, error: failure('invalid-request') };
-            const result = await this.run(client => client.getRecoveryStatus(normalized), { allowSignedOut: true });
-            if (result.ok && !await this.applyRecoveredSession(result.value)) {
-                return { ok: false, error: failure('remote') };
-            }
-            return result;
+            return this.run(client => client.getRecoveryStatus(normalized), { allowSignedOut: true });
         }
         /** Resume only the exact Core-owned operation selected by the browser. */
         async resumeRecovery(request) {
             const normalized = normalizeRecoveryOperation(request);
             if (normalized === undefined)
                 return { ok: false, error: failure('invalid-request') };
-            const result = await this.run(client => client.resumeRecovery(normalized), { allowSignedOut: true });
-            if (result.ok && !await this.applyRecoveredSession(result.value)) {
-                return { ok: false, error: failure('remote') };
+            return this.run(client => client.resumeRecovery(normalized), { allowSignedOut: true });
+        }
+        /** Explicitly enter an applied identity; reads and late Core completions never sign in. */
+        async enterRecoveredSession(request) {
+            const normalized = normalizeRecoveryOperation(request);
+            if (normalized === undefined)
+                return { ok: false, error: failure('invalid-request') };
+            const requestGeneration = this.sessionRevision;
+            const result = await this.run(client => client.getRecoveryStatus(normalized), { allowSignedOut: true });
+            if (!result.ok)
+                return result;
+            if (result.value.phase !== 'applied' || !result.value.allowedActions?.includes('activate_identity')) {
+                return { ok: false, error: failure('conflict') };
             }
-            return result;
+            return this.applyRecoveredSession(result.value, requestGeneration);
         }
         /** Discard only a pre-attempt operation; Core rejects post-attempt deletion. */
         async discardRecovery(request) {
@@ -1550,6 +2161,12 @@ let AwikiService = (() => {
             return result.ok ? { ok: true, value: { completed: true } } : result;
         }
         /** Read one authoritative versioned member page. */
+        getDisplayProfiles(peers) {
+            if (!Array.isArray(peers) || peers.length > 100 || peers.some(peer => typeof peer !== 'string' || !peer.startsWith('did:'))) {
+                return Promise.resolve({ ok: false, error: failure('invalid-request') });
+            }
+            return this.run(client => client.getDisplayProfiles(peers));
+        }
         listGroupMembers(request) {
             const groupDid = normalizeGroupDid(request?.groupDid);
             if (groupDid === undefined
@@ -1812,10 +2429,14 @@ let AwikiService = (() => {
             catch {
                 return { ok: false, error: failure('invalid-request') };
             }
+            const requestGeneration = this.sessionRevision;
             return this.run(async (client) => {
-                if (normalized.folder !== 'sent')
-                    return client.listMailInbox(normalized);
-                return this.sentMailStore.list(await this.ownerDid(client), normalized);
+                const page = normalized.folder === 'sent'
+                    ? await this.mailListClient.listOutbound(normalized)
+                    : await client.listMailInbox(normalized);
+                if (this.sessionRevision !== requestGeneration)
+                    throw new AwikiSdkError('network');
+                return page;
             });
         }
         /** Read one bounded plain-text mail message. */
@@ -1827,15 +2448,7 @@ let AwikiService = (() => {
             catch {
                 return { ok: false, error: failure('invalid-request') };
             }
-            return this.run(async (client) => {
-                if (!isLocalSentMailId(normalized.messageId))
-                    return client.readMail(normalized);
-                const local = await this.sentMailStore.read(await this.ownerDid(client), normalized.messageId);
-                if (local === undefined) {
-                    throw Object.assign(new Error('sent mail not found'), { name: 'AwikiSdkError', code: 'not-found' });
-                }
-                return local;
-            });
+            return this.run(client => client.readMail(normalized));
         }
         /** Mark explicitly selected mail messages read. Browser callers require an explicit click. */
         markMailRead(request) {
@@ -1850,22 +2463,7 @@ let AwikiService = (() => {
             catch {
                 return { ok: false, error: failure('invalid-request') };
             }
-            return this.run(async (client) => {
-                const result = await client.sendMail(normalized);
-                if (!result.accepted)
-                    return result;
-                try {
-                    const ownerDid = await this.ownerDid(client);
-                    const account = await client.getMailAccount().catch(() => undefined);
-                    await this.sentMailStore.append(ownerDid, normalized, result, account);
-                    return result;
-                }
-                catch {
-                    return result.warnings.length >= 100
-                        ? result
-                        : { ...result, warnings: [...result.warnings, 'Sent history could not be saved locally.'] };
-                }
-            });
+            return this.run(client => client.sendMail(normalized));
         }
         /**
          * Permanently remove the exact SDK-owned local state after an explicit browser acknowledgement.
@@ -1877,11 +2475,19 @@ let AwikiService = (() => {
             if (request?.confirmation !== AWIKI_CLEAR_LOCAL_DATA_CONFIRMATION) {
                 return Promise.resolve({ ok: false, error: failure('invalid-request') });
             }
+            // Fence pending post-Recovery work before the serialized clear reaches the head of the queue.
+            this.sessionRevision += 1;
             return this.mutateSession(async () => {
                 const provider = this.provider;
                 if (provider !== undefined)
                     await this.stopProviderRuntime(provider);
-                const result = await this.run(client => client.clearLocalData(), { allowSignedOut: true });
+                let result = await this.run(client => client.clearLocalData(), { allowSignedOut: true });
+                // Core's clear is local and idempotent. A provider mutation that was still
+                // settling can surface once as the deliberately opaque `remote` failure.
+                // Retry only that class once after the runtime has already been stopped.
+                if (!result.ok && result.error.code === 'remote') {
+                    result = await this.run(client => client.clearLocalData(), { allowSignedOut: true });
+                }
                 if (!result.ok) {
                     if (provider !== undefined && this.provider === provider)
                         this.ensureProviderRuntime(provider);
@@ -1889,7 +2495,7 @@ let AwikiService = (() => {
                 }
                 try {
                     await this.imageAttachmentCache.clear();
-                    await this.sentMailStore.clear();
+                    await clearLegacySentMailCache(this.activeClientOptions?.stateRoot ?? this.resolved.stateRoot);
                     await this.conversationPreferenceStore.clear();
                     await this.sessionStore.signIn();
                     this.signedOut = false;
@@ -1906,81 +2512,102 @@ let AwikiService = (() => {
             });
         }
         /** Re-enter only after Core confirms that the exact recovered identity is applied locally. */
-        async applyRecoveredSession(progress) {
+        async applyRecoveredSession(progress, requestGeneration) {
             if (progress.phase !== 'applied')
-                return true;
+                return { ok: true, value: progress };
             return this.mutateSession(async () => {
                 const provider = this.provider;
                 if (provider === undefined)
-                    return false;
+                    return { ok: false, error: failure('remote') };
+                if (this.sessionRevision !== requestGeneration) {
+                    return {
+                        ok: false,
+                        error: {
+                            ...failure('remote'),
+                            mailRecoveryObservability: fencedMailRecoveryObservability(this.activeIdentityDid === progress.currentDid, 'replaced'),
+                        },
+                    };
+                }
                 try {
                     const identity = await provider.client.getIdentity();
-                    if (identity === null || identity.did !== progress.currentDid)
-                        return false;
+                    const currentPrincipalMatchesRecovery = identity !== null && identity.did === progress.currentDid;
+                    if (this.provider !== provider || this.sessionRevision !== requestGeneration) {
+                        return {
+                            ok: false,
+                            error: {
+                                ...failure('remote'),
+                                mailRecoveryObservability: fencedMailRecoveryObservability(currentPrincipalMatchesRecovery, 'replaced'),
+                            },
+                        };
+                    }
+                    if (!currentPrincipalMatchesRecovery) {
+                        return {
+                            ok: false,
+                            error: {
+                                ...failure('remote'),
+                                mailRecoveryObservability: fencedMailRecoveryObservability(false, 'current'),
+                            },
+                        };
+                    }
                     const alreadyActive = this.signedOut === false && this.activeIdentityDid === identity.did;
                     if (!alreadyActive) {
                         await this.sessionStore.signIn();
+                        if (this.provider !== provider || this.sessionRevision !== requestGeneration) {
+                            return {
+                                ok: false,
+                                error: {
+                                    ...failure('remote'),
+                                    mailRecoveryObservability: fencedMailRecoveryObservability(true, 'replaced'),
+                                },
+                            };
+                        }
                         this.signedOut = false;
                         this.activeIdentityDid = identity.did;
                         this.invalidateSummaries();
+                        requestGeneration = this.sessionRevision;
+                    }
+                    const mailRecoveryObservability = await this.reconcileRecoveredMailbox(provider);
+                    if (this.provider !== provider || this.sessionRevision !== requestGeneration) {
+                        return {
+                            ok: false,
+                            error: {
+                                ...failure('remote'),
+                                mailRecoveryObservability: fencedMailRecoveryObservability(true, 'replaced'),
+                            },
+                        };
                     }
-                    const reconciled = await this.reconcileRecoveredIdentity(provider, progress.operationId);
-                    if (this.provider !== provider)
-                        return false;
                     if (!alreadyActive) {
                         const session = { status: 'active', identity };
                         this.publishSession(session);
                         this.ensureProviderRuntime(provider);
                     }
-                    return reconciled;
+                    return { ok: true, value: { ...progress, mailRecoveryObservability } };
                 }
                 catch {
-                    return false;
+                    return { ok: false, error: failure('remote') };
                 }
             });
         }
-        /** Rebind Mail first-use ownership and, when installed, the canonical model billing account. */
-        async reconcileRecoveredIdentity(provider, operationId) {
-            const logger = this.ctx.logger('awiki-recovery');
-            let mailboxRestored = false;
+        /** Rebind Mail first-use ownership and retain only its closed, secret-free classification. */
+        async reconcileRecoveredMailbox(provider) {
             try {
                 await provider.client.getMailAccount();
-                mailboxRestored = true;
+                return successfulMailRecoveryObservability();
             }
-            catch {
-                logger.warn('awiki: recovered mailbox reconciliation is pending');
-            }
-            const target = this.recoveryReconciliationTarget;
-            if (target === undefined)
-                return mailboxRestored;
-            try {
-                const authority = await provider.client.issueRecoveryAttestation({ operationId });
-                const response = await this.externalHttpAuth.dispatch(new Request(target.endpoint, {
-                    method: 'POST',
-                    headers: { 'content-type': 'application/json' },
-                    body: JSON.stringify({ attestation: authority.attestation }),
-                }), request => fetch(request));
-                if (!await acceptsRecoveryReconciliation(response)) {
-                    logger.warn('awiki: recovered model account reconciliation is pending');
-                    return false;
-                }
-                return mailboxRestored;
-            }
-            catch {
-                logger.warn('awiki: recovered model account reconciliation is pending');
-                return false;
+            catch (error) {
+                return failedMailRecoveryObservability(error);
             }
         }
         /** Select the only resumable new-device session; Core local_sessions is the sole restart SoT. */
         async selectDeviceJoinSession(client) {
             const sessions = await client.listLocalDeviceJoinSessions();
+            const resumable = sessions.filter(value => (value.side === 'new_device' && RESUMABLE_JOIN_PHASES.has(value.localPhase)));
             if (this.activeDeviceJoinSessionId !== undefined) {
-                const tracked = sessions.find(value => (value.side === 'new_device' && value.joinSessionId === this.activeDeviceJoinSessionId));
+                const tracked = resumable.find(value => value.joinSessionId === this.activeDeviceJoinSessionId);
                 if (tracked !== undefined)
                     return tracked.joinSessionId;
                 this.activeDeviceJoinSessionId = undefined;
             }
-            const resumable = sessions.filter(value => (value.side === 'new_device' && RESUMABLE_JOIN_PHASES.has(value.localPhase)));
             if (resumable.length > 1) {
                 throw Object.assign(new Error('multiple local joins'), { name: 'AwikiSdkError', code: 'conflict' });
             }
@@ -2048,6 +2675,26 @@ let AwikiService = (() => {
                 throw Object.assign(new Error('device manager required'), { name: 'AwikiSdkError', code: 'forbidden' });
             }
         }
+        async requireRootTransferRecipient(client, deviceId) {
+            if (!client.trustedUserPresenceSupported) {
+                throw Object.assign(new Error('trusted user presence unsupported'), { name: 'AwikiSdkError', code: 'forbidden' });
+            }
+            await this.requireDeviceManager(client);
+            await client.syncDeviceManagement();
+            const identity = await client.getIdentity();
+            if (identity === null) {
+                throw Object.assign(new Error('identity required'), { name: 'AwikiSdkError', code: 'not-registered' });
+            }
+            const target = (await client.getDeviceRegistry()).find(device => device.deviceId === deviceId);
+            if (target === undefined
+                || target.isCurrent
+                || target.status !== 'active'
+                || target.role !== 'member'
+                || target.managementReady) {
+                throw Object.assign(new Error('root transfer recipient unavailable'), { name: 'AwikiSdkError', code: 'forbidden' });
+            }
+            return identity.did;
+        }
         requestRef(joinSessionId) {
             const existing = this.requestRefs.get(joinSessionId);
             if (existing !== undefined)
@@ -2074,8 +2721,10 @@ let AwikiService = (() => {
                 this.requestSessions.clear();
                 this.deviceRefs.clear();
                 this.deviceIds.clear();
+                this.rootTransfers.clear();
                 return {
                     canManage: false,
+                    rootTransferSupported: client.trustedUserPresenceSupported,
                     ...current.role === undefined ? {} : { role: current.role },
                     readiness: current.readiness,
                     devices: [],
@@ -2087,11 +2736,25 @@ let AwikiService = (() => {
                 .filter(request => request.claimedByCurrentDevice)
                 .map(request => client.getLocalDeviceJoinVerificationProgress(request.joinSessionId).catch(() => undefined)));
             const devices = await client.getDeviceRegistry();
+            const identity = await client.getIdentity();
+            const joinedAtByDeviceId = new Map();
+            for (const request of requests) {
+                const previous = joinedAtByDeviceId.get(request.protocolDeviceId);
+                if (previous === undefined || request.issuedAt > previous) {
+                    joinedAtByDeviceId.set(request.protocolDeviceId, request.issuedAt);
+                }
+            }
+            const initialDeviceJoinedAt = identity === null
+                ? undefined
+                : new Date(identity.registeredAt).toISOString();
             return {
                 canManage: true,
+                rootTransferSupported: client.trustedUserPresenceSupported,
                 role: 'admin',
                 readiness: 'admin_ready',
-                devices: devices.map(device => this.publicDevice(device)),
+                devices: devices
+                    .filter(device => device.status === 'active')
+                    .map(device => this.publicDevice(device, joinedAtByDeviceId.get(device.deviceId) ?? (device.isCurrent ? initialDeviceJoinedAt : undefined))),
                 requests: requests.map(request => ({
                     requestRef: this.requestRef(request.joinSessionId),
                     candidateKeyFingerprint: request.candidateKeyFingerprint,
@@ -2103,9 +2766,12 @@ let AwikiService = (() => {
                 })),
             };
         }
-        publicDevice(device) {
+        publicDevice(device, joinedAt) {
+            const fingerprint = createHash('sha256').update(device.deviceId).digest('hex').slice(0, 8).toUpperCase();
             return {
                 deviceRef: this.deviceRef(device.deviceId),
+                displayId: `${fingerprint.slice(0, 4)}-${fingerprint.slice(4)}`,
+                ...joinedAt === undefined ? {} : { joinedAt },
                 status: device.status,
                 role: device.role,
                 managementReady: device.managementReady,
@@ -2129,6 +2795,7 @@ let AwikiService = (() => {
             this.requestSessions.clear();
             this.deviceRefs.clear();
             this.deviceIds.clear();
+            this.rootTransfers.clear();
             for (const controller of this.activeSummaryRequests)
                 controller.abort();
             this.activeSummaryRequests.clear();
@@ -2150,6 +2817,10 @@ let AwikiService = (() => {
         /** Invoke the current client and normalize every rejection to a public result. */
         async run(operation, options = {}) {
             try {
+                const generation = this.runtimeGeneration;
+                if (this.getUpdatePolicyStatus().restricted) {
+                    return { ok: false, error: failure('client-version-unsupported') };
+                }
                 if (options.allowSignedOut !== true && await this.isSignedOut()) {
                     return { ok: false, error: failure('signed-out') };
                 }
@@ -2157,6 +2828,9 @@ let AwikiService = (() => {
                 if (provider === undefined)
                     throw new ProviderUnavailableError();
                 const value = await operation(provider.client);
+                if (this.runtimeGeneration !== generation || this.provider !== provider) {
+                    return { ok: false, error: failure('conflict') };
+                }
                 if (options.skipAttachmentByteValidation !== true && containsUnexpectedBinary(value, new Set())) {
                     return { ok: false, error: failure('remote') };
                 }
@@ -2166,6 +2840,11 @@ let AwikiService = (() => {
                 return { ok: false, error: normalizeFailure(error) };
             }
         }
+        assertVersionSupported() {
+            if (this.getUpdatePolicyStatus().restricted) {
+                throw new Error('awiki: this plugin version must be updated before using the active tenant');
+            }
+        }
         /** Validate mail input before entering the provider and preserve fixed public failures. */
         runValidatedMail(validate, operation) {
             let request;
@@ -2226,12 +2905,20 @@ let AwikiService = (() => {
         }
         /** Serialize sign-in, sign-out, and destructive clear transitions. */
         mutateSession(operation) {
-            const pending = this.sessionMutation.then(operation, operation);
+            const generation = this.runtimeGeneration;
+            if (this.tenantSwitching)
+                return Promise.resolve({ ok: false, error: failure('conflict') });
+            const invoke = () => this.tenantSwitching || generation !== this.runtimeGeneration
+                ? Promise.resolve({ ok: false, error: failure('conflict') })
+                : operation();
+            const pending = this.sessionMutation.then(invoke, invoke);
             this.sessionMutation = pending.then(() => undefined, () => undefined);
             return pending;
         }
         /** Start identity realtime and the optional Agent consumer without blocking identity success. */
         ensureProviderRuntime(provider) {
+            if (this.tenantSwitching)
+                return;
             const identityDid = this.activeIdentityDid;
             if (provider.runtimeReplacement !== undefined)
                 return;
@@ -2267,6 +2954,8 @@ let AwikiService = (() => {
             provider.runtimeReplacement = observed;
         }
         ensureRealtimeSupervisor(provider) {
+            if (this.getUpdatePolicyStatus().restricted)
+                return;
             if (!this.resolved.realtimeEnabled
                 || provider.realtimeSupervisor !== undefined
                 || provider.realtimeStartup !== undefined
@@ -2326,6 +3015,8 @@ let AwikiService = (() => {
             await provider.agentConsumer?.reconcileOnce();
         }
         ensureAgentConsumer(provider) {
+            if (this.getUpdatePolicyStatus().restricted)
+                return;
             const workspaceContext = this.workspaceContext;
             const source = provider.client.agentInbox ?? provider.client.listener;
             const identityDid = this.activeIdentityDid;
@@ -2348,6 +3039,7 @@ let AwikiService = (() => {
                 const agents = new DshAwikiListenerAgentRuntime(workspaceContext, this.resolved.listener.workspacePath);
                 const consumer = new AwikiAgentListener(source, agents, {
                     ...this.resolved.listener,
+                    stateRoot: this.activeClientOptions?.stateRoot ?? this.resolved.listener.stateRoot,
                     identityScope: identityDid,
                 }, logger);
                 provider.agentConsumer = consumer;