maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.47.20260922

package/node_modules/@maka/runtime-host/dist/server/client-capability-coordinator.js

@@ -20,11 +20,14 @@ import { createHash } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { buildMcpTools, mcpProxyToolName, } from '@maka/runtime/mcp-tools';
 import { clientCapabilityScopeIdentity, } from '@maka/core/client-capability-grant';
+import { decodeClientCapabilityReplaceInput, } from '../protocol/index.js';
 import { ClientCapabilityInvocationBroker, ClientCapabilityInvocationError, } from './client-capability-invocation-broker.js';
 import { clientCapabilityProviderId } from './client-capability-provider-id.js';
 // Leave the Host deadline outside the provider's bounded action deadline so an
 // accepted call can return its real terminal result instead of outcome_unknown.
 const DEFAULT_CALL_TIMEOUT_MS = 150_000;
+// Bound pre-creation Session publications even when a client invents Session IDs.
+export const MAX_SESSION_REGISTRATIONS_PER_PROVIDER = 64;
 const DESKTOP_BROWSER_SERVER_ID = 'desktop_browser';
 const DESKTOP_SETTINGS_SERVER_ID = 'desktop_settings';
 const DESKTOP_MCP_OFFER_PREFIX = 'desktop_mcp';
@@ -48,6 +51,7 @@ export class HostClientCapabilityCoordinator {
         'client.capability.unregister': (input, context) => this.#unregister(input, context),
     };
     #activation;
+    #isSessionRetired;
     #onModelToolsChanged;
     #interactions;
     #grants;
@@ -62,16 +66,12 @@ export class HostClientCapabilityCoordinator {
     #draining = false;
     constructor(options) {
         this.#activation = options.activation;
+        this.#isSessionRetired = options.isSessionRetired;
         this.#onModelToolsChanged = options.onModelToolsChanged;
         this.#interactions = options.interactions;
         this.#grants = options.grants;
         this.#invocations = new ClientCapabilityInvocationBroker({
-            senderFor: (connectionId) => {
-                const connection = this.#connections.get(connectionId);
-                return connection && this.#activeConnection(connection.provider) === connection
-                    ? connection.sender
-                    : undefined;
-            },
+            senderFor: (registration) => this.#registrationConnection(registration)?.sender,
             onRegistrationIdle: (registration) => this.#releaseRegistrationIfUnused(registration),
         });
     }
@@ -151,10 +151,14 @@ export class HostClientCapabilityCoordinator {
     }
     async bindRecoveredSession(sessionId, binding, toolNames) {
         return this.#activation.runMutation(() => {
-            const provider = [...this.#providers.values()].find((candidate) => providerAuthorityDigest(candidate) === binding && this.#activeConnection(candidate));
+            const provider = [...this.#providers.values()].find((candidate) => providerAuthorityDigest(candidate) === binding &&
+                (this.#activeConnection(candidate) ||
+                    (candidate.sessionRegistrations.get(sessionId) &&
+                        this.#registrationConnection(candidate.sessionRegistrations.get(sessionId)))));
             if (!provider)
                 return false;
-            const connection = this.#activeConnection(provider);
+            const scoped = provider.sessionRegistrations.get(sessionId);
+            const connection = (scoped && this.#registrationConnection(scoped)) || this.#activeConnection(provider);
             const selection = this.#selectSessionState(sessionId, connection.connectionId, 'strict');
             if (!selection.ok || this.#toolProviderBinding(selection.state, toolNames) !== binding)
                 return false;
@@ -171,8 +175,9 @@ export class HostClientCapabilityCoordinator {
             if (binding.kind !== 'bound')
                 continue;
             const provider = this.#providers.get(binding.providerId);
-            const offer = provider?.current?.offersByContract.get(contractId);
-            if (!provider || !this.#activeConnection(provider) || !offer)
+            const registration = this.#bindingRegistration(binding);
+            const offer = registration?.offersByContract.get(contractId);
+            if (!provider || !registration || !this.#registrationConnection(registration) || !offer)
                 continue;
             for (const tool of offer.offer.tools) {
                 if (!missing.delete(mcpProxyToolName(tool.serverId, tool.name)))
@@ -225,7 +230,10 @@ export class HostClientCapabilityCoordinator {
     }
     #selectSessionState(sessionId, initiatingConnectionId, mode) {
         const initiatingProvider = this.#connections.get(initiatingConnectionId)?.provider;
-        const directProvider = initiatingProvider?.current && this.#activeConnection(initiatingProvider)
+        const initiatingScoped = initiatingProvider?.sessionRegistrations.get(sessionId);
+        const directProvider = initiatingProvider &&
+            ((initiatingProvider.current && this.#activeConnection(initiatingProvider)) ||
+                (initiatingScoped && this.#registrationConnection(initiatingScoped)))
             ? initiatingProvider
             : undefined;
         const associatedProviders = initiatingProvider &&
@@ -257,7 +265,7 @@ export class HostClientCapabilityCoordinator {
                 ? initiatingProviderId
                 : undefined);
         const previous = previousState?.sessionBindings ?? new Map();
-        const eligible = this.#eligibleOffersByContract();
+        const eligible = this.#eligibleOffersByContract(sessionId);
         const next = new Map();
         const selected = [];
         const sessionContractIds = new Set([
@@ -271,10 +279,11 @@ export class HostClientCapabilityCoordinator {
             const candidates = eligible.get(contractId) ?? [];
             let candidate;
             if (previousBinding?.kind === 'bound') {
-                candidate = candidates.find((entry) => entry.registration.providerId === previousBinding.providerId);
+                candidate = candidates.find((entry) => entry.registration.providerId === previousBinding.providerId &&
+                    entry.registration.sessionId === previousBinding.sessionId);
                 if (!candidate) {
                     if (mode === 'degrade') {
-                        next.set(contractId, { kind: 'lost', providerId: previousBinding.providerId });
+                        next.set(contractId, { ...previousBinding, kind: 'lost' });
                         continue;
                     }
                     return {
@@ -284,7 +293,8 @@ export class HostClientCapabilityCoordinator {
                 }
             }
             else if (previousBinding?.kind === 'lost') {
-                candidate = candidates.find((entry) => entry.registration.providerId === previousBinding.providerId);
+                candidate = candidates.find((entry) => entry.registration.providerId === previousBinding.providerId &&
+                    entry.registration.sessionId === previousBinding.sessionId);
                 if (!candidate) {
                     if (mode === 'degrade') {
                         next.set(contractId, previousBinding);
@@ -297,8 +307,10 @@ export class HostClientCapabilityCoordinator {
                 }
             }
             else {
-                candidate = selectProviderCandidate(candidates, initiatingProviderId);
-                if (!candidate && initiatingProviderId === undefined && candidates.length > 1) {
+                const selectable = candidates.filter((entry) => entry.registration.sessionId === undefined ||
+                    entry.registration.providerId === initiatingProviderId);
+                candidate = selectProviderCandidate(selectable, initiatingProviderId);
+                if (!candidate && initiatingProviderId === undefined && selectable.length > 1) {
                     if (mode === 'degrade')
                         continue;
                     return {
@@ -312,6 +324,9 @@ export class HostClientCapabilityCoordinator {
             next.set(contractId, {
                 kind: 'bound',
                 providerId: candidate.registration.providerId,
+                ...(candidate.registration.sessionId === undefined
+                    ? {}
+                    : { sessionId: candidate.registration.sessionId }),
             });
             selected.push(candidate);
         }
@@ -323,6 +338,9 @@ export class HostClientCapabilityCoordinator {
                         next.set(candidate.offer.contractId, {
                             kind: 'lost',
                             providerId: candidate.registration.providerId,
+                            ...(candidate.registration.sessionId === undefined
+                                ? {}
+                                : { sessionId: candidate.registration.sessionId }),
                         });
                     }
                     else {
@@ -375,9 +393,9 @@ export class HostClientCapabilityCoordinator {
             if (binding.kind === 'lost')
                 continue;
             const provider = this.#providers.get(binding.providerId);
-            const registration = provider?.current;
+            const registration = this.#bindingRegistration(binding);
             const offer = registration?.offersByContract.get(contractId);
-            if (!provider || !this.#activeConnection(provider) || !registration || !offer) {
+            if (!provider || !registration || !this.#registrationConnection(registration) || !offer) {
                 throw new ClientCapabilityInvocationError('capability_lost', 'A Session-bound Client Capability provider is unavailable');
             }
             selected.push({ registration, offer });
@@ -553,10 +571,28 @@ export class HostClientCapabilityCoordinator {
             provider.current?.servicesByContract.has(serviceContract(serviceId, version)));
     }
     retireSessions(sessionIds) {
-        for (const sessionId of new Set(sessionIds))
-            this.#sessions.delete(sessionId);
-        for (const provider of this.#providers.values())
-            this.#deleteProviderIfUnused(provider);
+        const retiredSessionIds = new Set(sessionIds);
+        return this.#activation.runMutation(() => {
+            // Invalidate binding previews even when this Session has not committed a
+            // stored state or scoped registration yet. Otherwise a preview captured
+            // before retirement can commit afterwards and recreate its state.
+            for (const sessionId of retiredSessionIds) {
+                this.#sessions.delete(sessionId);
+                this.#revision += 1;
+            }
+            for (const provider of this.#providers.values()) {
+                for (const sessionId of retiredSessionIds) {
+                    const registration = provider.sessionRegistrations.get(sessionId);
+                    if (!registration)
+                        continue;
+                    provider.sessionRegistrations.delete(sessionId);
+                    if (hasModelToolOffers(registration))
+                        this.#onModelToolsChanged();
+                    this.#releaseRegistrationIfUnused(registration);
+                }
+                this.#deleteProviderIfUnused(provider);
+            }
+        });
     }
     releaseConnection(connectionId) {
         const invocationCleanup = this.#invocations.releaseConnection(connectionId);
@@ -579,16 +615,23 @@ export class HostClientCapabilityCoordinator {
             return;
         const { provider } = connection;
         this.#connections.delete(connection.connectionId);
-        if (provider.activeConnectionId !== connection.connectionId) {
-            this.#deleteProviderIfUnused(provider);
-            return;
+        if (provider.activeConnectionId === connection.connectionId) {
+            provider.activeConnectionId = undefined;
+            if (provider.current) {
+                const registration = provider.current;
+                provider.current = undefined;
+                this.#markBindingsLost(provider.providerId);
+                this.#removeTurnBindings(provider.providerId);
+                this.#revision += 1;
+                if (hasModelToolOffers(registration))
+                    this.#onModelToolsChanged();
+            }
         }
-        provider.activeConnectionId = undefined;
-        if (provider.current) {
-            const registration = provider.current;
-            provider.current = undefined;
-            this.#markBindingsLost(provider.providerId);
-            this.#removeTurnBindings(provider.providerId);
+        for (const [sessionId, registration] of provider.sessionRegistrations) {
+            if (registration.connectionId !== connection.connectionId)
+                continue;
+            provider.sessionRegistrations.delete(sessionId);
+            this.#markBindingsLost(provider.providerId, undefined, sessionId);
             this.#revision += 1;
             if (hasModelToolOffers(registration))
                 this.#onModelToolsChanged();
@@ -621,6 +664,18 @@ export class HostClientCapabilityCoordinator {
                     },
                 };
             }
+            // The lifecycle owner commits archive/removal before retiring capabilities.
+            // Read that authority inside the mutation lane: a queued refresh must not
+            // recreate a retired slot. Never-created IDs remain valid for ACP preparation.
+            if (input.sessionId !== undefined && (await this.#isSessionRetired(input.sessionId))) {
+                return {
+                    ok: false,
+                    error: {
+                        code: 'invalid_request',
+                        message: 'Client Capability target Session is retired',
+                    },
+                };
+            }
             const connection = this.#connections.get(context.connectionId);
             if (!connection) {
                 return {
@@ -632,7 +687,18 @@ export class HostClientCapabilityCoordinator {
                 };
             }
             const { provider } = connection;
-            if (connection.superseded) {
+            if (input.sessionId !== undefined &&
+                !provider.sessionRegistrations.has(input.sessionId) &&
+                provider.sessionRegistrations.size >= MAX_SESSION_REGISTRATIONS_PER_PROVIDER) {
+                return {
+                    ok: false,
+                    error: {
+                        code: 'invalid_request',
+                        message: 'Client Capability Session registration limit reached',
+                    },
+                };
+            }
+            if (connection.superseded && input.sessionId === undefined) {
                 return {
                     ok: false,
                     error: {
@@ -658,6 +724,12 @@ export class HostClientCapabilityCoordinator {
                     throw new Error('A trusted capability provider may publish only path-independent session capabilities');
                 }
                 registration = freezeRegistration(provider.providerId, context.connectionId, input, provider.trustedProvider);
+                const overlapping = registration.sessionId === undefined
+                    ? [...provider.sessionRegistrations.values()]
+                    : provider.current
+                        ? [provider.current]
+                        : [];
+                assertRegistrationToolsDoNotOverlap(registration, overlapping);
             }
             catch (error) {
                 return {
@@ -668,22 +740,43 @@ export class HostClientCapabilityCoordinator {
                     },
                 };
             }
-            const previous = provider.current;
+            const previous = this.#currentRegistration(provider, registration.sessionId);
             const previousConnectionId = provider.activeConnectionId;
-            if (previousConnectionId && previousConnectionId !== context.connectionId) {
-                const previousConnection = this.#connections.get(previousConnectionId);
-                if (previousConnection)
-                    previousConnection.superseded = true;
-                this.#invocations.releaseConnection(previousConnectionId);
+            if (registration.sessionId !== undefined) {
+                provider.sessionRegistrations.set(registration.sessionId, registration);
+            }
+            else {
+                if (previousConnectionId && previousConnectionId !== context.connectionId) {
+                    const previousConnection = this.#connections.get(previousConnectionId);
+                    if (previousConnection)
+                        previousConnection.superseded = true;
+                    for (const retired of provider.registrations.values()) {
+                        if (retired.sessionId === undefined && retired.connectionId === previousConnectionId) {
+                            void this.#invocations.releaseRegistration(retired);
+                        }
+                    }
+                }
+                provider.activeConnectionId = context.connectionId;
+                provider.current = registration;
             }
-            provider.activeConnectionId = context.connectionId;
-            provider.current = registration;
             const currentContracts = new Set(registration.offersByContract.keys());
+            if (registration.sessionId !== undefined) {
+                // Discovery may have changed while this scope's connection was away.
+                // Republishing is a complete replacement, including previously lost
+                // contracts; keep other Sessions and legacy provider leases untouched.
+                const previousBindings = this.#sessions.get(registration.sessionId)?.sessionBindings;
+                const removed = new Set([...(previousBindings ?? [])]
+                    .filter(([contractId, binding]) => binding.providerId === provider.providerId &&
+                    binding.sessionId === registration.sessionId &&
+                    !currentContracts.has(contractId))
+                    .map(([contractId]) => contractId));
+                this.#retireBindings(provider.providerId, removed, registration.sessionId);
+            }
             if (previous) {
-                this.#retireBindings(provider.providerId, new Set([...previous.offersByContract.keys()].filter((contractId) => !currentContracts.has(contractId))));
-                this.#removeTurnBindings(provider.providerId, new Set([...previous.offersByContract.keys()].filter((contractId) => !currentContracts.has(contractId))));
+                this.#retireBindings(provider.providerId, new Set([...previous.offersByContract.keys()].filter((contractId) => !currentContracts.has(contractId))), registration.sessionId);
+                this.#removeTurnBindings(provider.providerId, new Set([...previous.offersByContract.keys()].filter((contractId) => !currentContracts.has(contractId))), registration.sessionId);
             }
-            this.#restoreBindings(provider.providerId, currentContracts);
+            this.#restoreBindings(provider.providerId, currentContracts, registration.sessionId);
             provider.registrations.set(registration.registrationId, registration);
             this.#revision += 1;
             if (hasModelToolOffers(previous) || hasModelToolOffers(registration)) {
@@ -704,9 +797,11 @@ export class HostClientCapabilityCoordinator {
     #unregister(input, context) {
         return this.#activation.runMutation(async () => {
             const provider = this.#connections.get(context.connectionId)?.provider;
-            if (provider?.activeConnectionId !== context.connectionId ||
-                !provider.current ||
-                provider.current.registrationId !== input.registrationId) {
+            const registration = provider?.registrations.get(input.registrationId);
+            if (!provider ||
+                !registration ||
+                registration.connectionId !== context.connectionId ||
+                this.#currentRegistration(provider, registration.sessionId) !== registration) {
                 return {
                     ok: false,
                     error: {
@@ -715,10 +810,12 @@ export class HostClientCapabilityCoordinator {
                     },
                 };
             }
-            const registration = provider.current;
-            provider.current = undefined;
-            this.#retireBindings(provider.providerId, new Set(registration.offersByContract.keys()));
-            this.#removeTurnBindings(provider.providerId, new Set(registration.offersByContract.keys()));
+            if (registration.sessionId === undefined)
+                provider.current = undefined;
+            else
+                provider.sessionRegistrations.delete(registration.sessionId);
+            this.#retireBindings(provider.providerId, new Set(registration.offersByContract.keys()), registration.sessionId);
+            this.#removeTurnBindings(provider.providerId, new Set(registration.offersByContract.keys()), registration.sessionId);
             this.#revision += 1;
             if (hasModelToolOffers(registration))
                 this.#onModelToolsChanged();
@@ -772,6 +869,7 @@ export class HostClientCapabilityCoordinator {
             toolSnapshot: () => snapshot,
             prepareTool: async (binding, args, options) => {
                 const { selectedBinding, dynamicBinding } = resolveBinding(binding);
+                assertRegistrationSession(dynamicBinding.registration, options.context.sessionId);
                 const prepared = this.#invocations.prepare(dynamicBinding.registration, dynamicBinding.tool, args, options.context, options.signal, options.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS);
                 try {
                     const evidence = await prepared.waitUntilAccepted();
@@ -782,7 +880,7 @@ export class HostClientCapabilityCoordinator {
                         if (options.context.permissionMode !== 'ask' || !options.context.runId) {
                             throw new Error('Client Capability is unavailable in the current permission mode');
                         }
-                        const target = managedClientCapabilityGrantTarget(selectedBinding.contractId, dynamicBinding.registration, dynamicBinding.tool, evidence);
+                        const target = managedClientCapabilityGrantTarget(selectedBinding.contractId, dynamicBinding.registration, dynamicBinding.tool, evidence, options.context.sessionId);
                         if (!target) {
                             return {
                                 execute: ({ emitProgress, requestInteraction } = {}) => prepared.admit(emitProgress, requestInteraction),
@@ -818,6 +916,7 @@ export class HostClientCapabilityCoordinator {
             },
             callTool: (binding, args, options) => {
                 const { dynamicBinding } = resolveBinding(binding);
+                assertRegistrationSession(dynamicBinding.registration, options.context.sessionId);
                 return this.#invocations.invoke(dynamicBinding.registration, dynamicBinding.tool, args, options.context, options.signal, options.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS, options.emitProgress, options.requestInteraction);
             },
         };
@@ -879,6 +978,7 @@ export class HostClientCapabilityCoordinator {
                     ? { capabilityOwner: Object.freeze({ ...identity.capabilityOwner }) }
                     : {}),
                 registrations: new Map(),
+                sessionRegistrations: new Map(),
             };
             this.#providers.set(providerId, provider);
         }
@@ -892,16 +992,21 @@ export class HostClientCapabilityCoordinator {
         }
         return provider;
     }
-    #eligibleOffersByContract() {
+    #eligibleOffersByContract(sessionId) {
         const eligible = new Map();
         for (const provider of this.#providers.values()) {
-            const registration = provider.current;
-            if (!this.#activeConnection(provider) || !registration)
-                continue;
-            for (const offer of registration.offersByContract.values()) {
-                const candidates = eligible.get(offer.contractId) ?? [];
-                candidates.push({ registration, offer });
-                eligible.set(offer.contractId, candidates);
+            const registrations = [
+                provider.current,
+                sessionId === undefined ? undefined : provider.sessionRegistrations.get(sessionId),
+            ];
+            for (const registration of registrations) {
+                if (!registration || !this.#registrationConnection(registration))
+                    continue;
+                for (const offer of registration.offersByContract.values()) {
+                    const candidates = eligible.get(offer.contractId) ?? [];
+                    candidates.push({ registration, offer });
+                    eligible.set(offer.contractId, candidates);
+                }
             }
         }
         for (const candidates of eligible.values()) {
@@ -925,31 +1030,33 @@ export class HostClientCapabilityCoordinator {
         }
         return { registration: candidate.registration, tool };
     }
-    #markBindingsLost(providerId, contracts) {
+    #markBindingsLost(providerId, contracts, scopeSessionId) {
         for (const [sessionId, state] of this.#sessions) {
             const bindings = state.sessionBindings;
             let next;
             for (const [contractId, binding] of bindings) {
                 if (binding.kind !== 'bound' ||
                     binding.providerId !== providerId ||
+                    binding.sessionId !== scopeSessionId ||
                     (contracts && !contracts.has(contractId))) {
                     continue;
                 }
                 next ??= new Map(bindings);
-                next.set(contractId, { kind: 'lost', providerId });
+                next.set(contractId, { ...binding, kind: 'lost' });
             }
             if (next)
                 this.#storeSessionState(sessionId, { ...state, sessionBindings: next });
         }
     }
-    #restoreBindings(providerId, contracts) {
+    #restoreBindings(providerId, contracts, scopeSessionId) {
         for (const [sessionId, state] of this.#sessions) {
             const next = new Map(state.sessionBindings);
             for (const [contractId, binding] of state.sessionBindings) {
                 if (binding.kind === 'lost' &&
                     binding.providerId === providerId &&
+                    binding.sessionId === scopeSessionId &&
                     contracts.has(contractId)) {
-                    next.set(contractId, { kind: 'bound', providerId });
+                    next.set(contractId, { ...binding, kind: 'bound' });
                 }
             }
             if (bindingMapsEqual(state.sessionBindings, next))
@@ -957,13 +1064,14 @@ export class HostClientCapabilityCoordinator {
             this.#storeSessionState(sessionId, { ...state, sessionBindings: next });
         }
     }
-    #retireBindings(providerId, contracts) {
+    #retireBindings(providerId, contracts, scopeSessionId) {
         for (const [sessionId, state] of this.#sessions) {
             const bindings = state.sessionBindings;
             const next = new Map(bindings);
             for (const [contractId, binding] of bindings) {
-                if (binding.kind === 'bound' &&
+                if ((binding.kind === 'bound' || scopeSessionId !== undefined) &&
                     binding.providerId === providerId &&
+                    binding.sessionId === scopeSessionId &&
                     contracts.has(contractId)) {
                     next.delete(contractId);
                 }
@@ -973,13 +1081,14 @@ export class HostClientCapabilityCoordinator {
             this.#storeSessionState(sessionId, { ...state, sessionBindings: next });
         }
     }
-    #removeTurnBindings(providerId, contracts) {
+    #removeTurnBindings(providerId, contracts, scopeSessionId) {
         for (const [sessionId, state] of this.#sessions) {
             const bindings = state.turnBindings;
             const next = new Map(bindings);
             for (const [contractId, binding] of bindings) {
                 if (binding.kind === 'bound' &&
                     binding.providerId === providerId &&
+                    binding.sessionId === scopeSessionId &&
                     (!contracts || contracts.has(contractId))) {
                     next.delete(contractId);
                 }
@@ -1015,7 +1124,7 @@ export class HostClientCapabilityCoordinator {
     }
     #releaseRegistrationIfUnused(registration) {
         const provider = this.#providers.get(registration.providerId);
-        if (provider?.current === registration ||
+        if ((provider && this.#currentRegistration(provider, registration.sessionId) === registration) ||
             registration.snapshotRefs !== 0 ||
             this.#invocations.holdsRegistration(registration)) {
             return;
@@ -1037,8 +1146,28 @@ export class HostClientCapabilityCoordinator {
             : undefined;
         return connection?.provider === provider && !connection.superseded ? connection : undefined;
     }
+    #currentRegistration(provider, sessionId) {
+        return sessionId === undefined
+            ? provider.current
+            : provider.sessionRegistrations.get(sessionId);
+    }
+    #registrationConnection(registration) {
+        const connection = this.#connections.get(registration.connectionId);
+        if (!connection || connection.provider.providerId !== registration.providerId)
+            return;
+        // Session publications have their own owning connection. A replacement of
+        // the legacy connection-wide publication cannot supersede those channels.
+        if (registration.sessionId !== undefined)
+            return connection;
+        return this.#activeConnection(connection.provider) === connection ? connection : undefined;
+    }
+    #bindingRegistration(binding) {
+        const provider = this.#providers.get(binding.providerId);
+        return provider ? this.#currentRegistration(provider, binding.sessionId) : undefined;
+    }
     #deleteProviderIfUnused(provider) {
         if (provider.current ||
+            provider.sessionRegistrations.size > 0 ||
             provider.activeConnectionId ||
             provider.registrations.size > 0 ||
             [...this.#connections.values()].some((connection) => connection.provider === provider) ||
@@ -1060,7 +1189,23 @@ export class HostClientCapabilityCoordinator {
 function trustedClientToolActivityKind(descriptor) {
     return descriptor.activityKind;
 }
+function assertRegistrationSession(registration, sessionId) {
+    if (registration.sessionId !== undefined && registration.sessionId !== sessionId) {
+        throw new ClientCapabilityInvocationError('capability_lost', 'Client Capability belongs to another Session');
+    }
+}
+function assertRegistrationToolsDoNotOverlap(registration, overlapping) {
+    const names = new Set([...registration.offersByContract.values()].flatMap(({ offer }) => offer.tools.map((tool) => mcpProxyToolName(tool.serverId, tool.name))));
+    for (const candidate of overlapping) {
+        for (const { offer } of candidate.offersByContract.values()) {
+            if (offer.tools.some((tool) => names.has(mcpProxyToolName(tool.serverId, tool.name)))) {
+                throw new Error('Connection and Session capabilities expose conflicting model tool identities');
+            }
+        }
+    }
+}
 function freezeRegistration(providerId, connectionId, input, trustedProvider) {
+    input = decodeClientCapabilityReplaceInput(input);
     const offers = input.offers.map((offer) => Object.freeze({
         ...offer,
         tools: Object.freeze(offer.tools.map((tool) => Object.freeze({
@@ -1085,6 +1230,7 @@ function freezeRegistration(providerId, connectionId, input, trustedProvider) {
             toolsByIdentity.set(identity, {
                 offerId: offer.offerId,
                 hostPathAccess: offer.hostPathAccess,
+                ...(offer.admission === undefined ? {} : { admission: offer.admission }),
                 descriptor,
             });
         }
@@ -1105,14 +1251,30 @@ function freezeRegistration(providerId, connectionId, input, trustedProvider) {
         providerId,
         connectionId,
         registrationId: input.registrationId,
+        ...(input.sessionId === undefined ? {} : { sessionId: input.sessionId }),
         trustedProvider,
         offersByContract,
         servicesByContract,
         snapshotRefs: 0,
     };
 }
-function managedClientCapabilityGrantTarget(contractId, registration, tool, evidence) {
+function managedClientCapabilityGrantTarget(contractId, registration, tool, evidence, sessionId) {
     const { serverId, name: toolName } = tool.descriptor;
+    if (tool.admission === 'mcp') {
+        if (registration.sessionId !== sessionId ||
+            tool.hostPathAccess !== 'none' ||
+            evidence.kind !== 'none') {
+            throw new Error('MCP admission requires its target Session and path-independent evidence');
+        }
+        return Object.freeze({
+            providerId: registration.providerId,
+            contractId,
+            serverId,
+            toolName,
+            capability: 'mcp',
+            scope: Object.freeze({ kind: 'mcp_tool', serverId, toolName }),
+        });
+    }
     if (!registration.trustedProvider) {
         throw new Error('Managed Client Capability requires a trusted Desktop provider');
     }
@@ -1203,6 +1365,7 @@ function capabilityGroupId(offer) {
         version: offer.version,
         affinity: offer.affinity,
         hostPathAccess: offer.hostPathAccess,
+        admission: offer.admission,
         tools,
     }))
         .digest('hex')
@@ -1303,7 +1466,8 @@ function bindingMapsEqual(left, right) {
         const candidate = right.get(contractId);
         if (!candidate ||
             candidate.kind !== binding.kind ||
-            candidate.providerId !== binding.providerId) {
+            candidate.providerId !== binding.providerId ||
+            candidate.sessionId !== binding.sessionId) {
             return false;
         }
     }