@opengeni/core 0.28.1 → 1.0.0

package/src/domain/capabilities.ts

@@ -1,7 +1,10 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { isDeepStrictEqual } from "node:util";
+import { withLockedCapabilityInstallation } from "@opengeni/db/capability-reconciliation";
 import { environmentsEncryptionKeyBytes, type Settings } from "@opengeni/config";
+import { pinnedFetch } from "@opengeni/network";
 import {
   CapabilityCatalogItem,
   capabilityCatalogItemIsTrustedForExposure,
@@ -16,6 +19,7 @@ import {
   type EnableCapabilityRequest,
   type McpServerConnectionRef,
   type McpPersonalConnectionDelegation,
+  assertOrganizationIntegrationAllowed,
   type SocialConnection,
 } from "@opengeni/contracts";
 import {
@@ -42,7 +46,6 @@ import {
   listEnabledMcpCapabilityServers,
   listInstalledApiIntegrations,
   listInstalledSkills,
-  listPackInstallations,
   listSocialConnections,
   mcpServerIdForCapability,
   upsertCapabilityCatalogItem,
@@ -52,10 +55,14 @@ import {
   type InstalledSkillSummary,
 } from "@opengeni/db";
 import { HTTPException } from "hono/http-exception";
+import {
+  withOrganizationIntegrationAcquisition,
+  withOrganizationIntegrationPolicyFence,
+} from "@opengeni/db/organization-integration-policy";
 import { hasPermission } from "../access";
 import { isFikenConnection, preferredFikenConnection } from "./fiken";
 import { listSkillLibraryEntries, type SkillLibraryEntry } from "@opengeni/runtime/skill-library";
-import { listCapabilityPacks, listWorkspaceCapabilityPacks } from "./packs";
+import { assertNativeMcpConnectionRef } from "./native-mcp-connection-admission";
 
 const officialMcpRegistryUrl = "https://registry.modelcontextprotocol.io";
 const firstPartyMcpServerIds = new Set(["opengeni", "files", "docs"]);
@@ -64,7 +71,6 @@ const mcpRegistryMaxPages = 3;
 const mcpCapabilityProbeTimeoutMs = 15000;
 const maxMcpCredentialHeaders = 16;
 const maxMcpCredentialHeaderValueLength = 4096;
-const officialGmailMcpUrl = "https://gmailmcp.googleapis.com/mcp/v1";
 // RFC 9110 field-name token characters.
 const mcpCredentialHeaderName = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
 
@@ -77,18 +83,15 @@ export async function buildCapabilityCatalog(input: {
   const [
     persistedItems,
     capabilityInstallations,
-    packInstallations,
-    workspacePacks,
     socialConnections,
     workspaceConnections,
     curatedLibrarySkills,
     installedSkills,
     codexAppsCredentialId,
+    runnableMcpServers,
   ] = await Promise.all([
     listCapabilityCatalogItems(input.db, input.workspaceId),
     listCapabilityInstallations(input.db, input.workspaceId),
-    listPackInstallations(input.db, input.workspaceId),
-    listWorkspaceCapabilityPacks(input.db, input.workspaceId),
     listSocialConnections(input.db, input.workspaceId, 500, input.subjectId),
     listConnectionsMetadata(input.db, input.workspaceId, null),
     discoverCuratedSkillLibraryItems(),
@@ -96,7 +99,9 @@ export async function buildCapabilityCatalog(input: {
     input.settings.codexConnectedAppsEnabled
       ? resolveCodexAppsCredentialIdForRun(input.db, input.workspaceId)
       : Promise.resolve(null),
+    listEnabledMcpCapabilityServers(input.db, input.workspaceId),
   ]);
+  const runnableCapabilityIds = new Set(runnableMcpServers.map((server) => server.capabilityId));
   const catalogInstallations = capabilityInstallations.filter(
     (installation) => installation.kind === "mcp",
   );
@@ -108,20 +113,11 @@ export async function buildCapabilityCatalog(input: {
       .filter((skill) => skill.owners.some((owner) => owner.kind === "direct"))
       .map((skill) => [skill.capabilityId, skill]),
   );
-  const activePackIds = new Set(
-    packInstallations
-      .filter((installation) => installation.status === "active")
-      .map((installation) => installation.packId),
-  );
-  const builtInPackIds = new Set(listCapabilityPacks().map((pack) => pack.id));
   const builtIns = [
-    ...workspacePacks.map((pack) =>
-      packCatalogItem(pack, builtInPackIds.has(pack.id) ? "built_in" : "manual"),
-    ),
     ...configuredMcpCatalogItems(input.settings),
     ...providerIntegrationCatalogItems(socialConnections),
     fikenCatalogItem(workspaceConnections.filter(isFikenConnection)),
-    ...curatedLibrarySkills,
+    ...curatedLibrarySkills.filter((item) => installedSkillById.has(item.id)),
     ...installedSkills
       .filter(
         (skill) =>
@@ -149,8 +145,26 @@ export async function buildCapabilityCatalog(input: {
       const projected =
         item.kind === "skill"
           ? applyInstalledSkillEnablement(item, installedSkillById.get(item.id))
-          : applyCapabilityEnablement(item, capabilityInstallationById.get(item.id), activePackIds);
-      return applyCapabilityLifecycle(projected);
+          : applyCapabilityEnablement(item, capabilityInstallationById.get(item.id));
+      // An installed connector can become unrunnable after a lifecycle or
+      // ownership change. Use the execution registry rather than presenting
+      // its stale catalog definition as a selectable tool.
+      const runtimeProjected =
+        projected.kind === "mcp" &&
+        projected.enabled &&
+        projected.source !== "configured" &&
+        projected.source !== "built_in" &&
+        !runnableCapabilityIds.has(projected.id)
+          ? {
+              ...projected,
+              runtime: {
+                ...projected.runtime,
+                available: false,
+                notes: "This installed connection is unavailable. Review its connection settings.",
+              },
+            }
+          : projected;
+      return applyCapabilityLifecycle(runtimeProjected);
     })
     .sort(compareCatalogItems);
   return {
@@ -166,11 +180,7 @@ export async function createCatalogItem(input: {
   payload: CreateCapabilityCatalogItemRequest;
 }): Promise<CapabilityCatalogItem> {
   const id = input.payload.id?.trim() || generatedCapabilityId(input.payload);
-  if (id.startsWith("pack:")) {
-    throw new HTTPException(422, {
-      message: "packs are managed by OpenGeni and cannot be manually created",
-    });
-  }
+
   if (id.startsWith("skill:")) {
     throw new HTTPException(422, {
       message: "Skills are installed through the Skill library or source import flow",
@@ -229,7 +239,7 @@ export async function createCatalogItem(input: {
   });
 }
 
-export async function enableCapability(input: {
+type EnableCapabilityInput = {
   db: Database;
   grant: AccessGrant;
   accountId: string;
@@ -238,13 +248,29 @@ export async function enableCapability(input: {
   capabilityId: string;
   payload: EnableCapabilityRequest;
   probeMcpServer?: McpCapabilityProbe;
-}): Promise<CapabilityInstallation> {
+};
+
+export async function enableCapability(
+  input: EnableCapabilityInput,
+): Promise<CapabilityInstallation> {
+  const prepared = await prepareCapabilityEnable(input);
+  return prepared.commit(input.db);
+}
+
+/** Probe outside a durable Connect commit; persist the exact prepared settings
+ * inside the caller's authorized receipt transaction. Native enable uses this too. */
+export async function prepareCapabilityEnable(input: EnableCapabilityInput) {
+  input = { ...input, payload: structuredClone(input.payload) };
   const item = await requireCatalogItem(
     input.db,
     input.workspaceId,
     input.settings,
     input.capabilityId,
   );
+  if (isReservedCodexAppsCatalogItem(item))
+    throw new HTTPException(422, {
+      message: "Codex Apps use the dedicated account designation flow",
+    });
   if (item.kind === "skill") {
     throw new HTTPException(409, {
       message: "Install Skills through the Skill library or source import flow",
@@ -260,11 +286,7 @@ export async function enableCapability(input: {
       message: "Install Plugins through the Plugin Package flow",
     });
   }
-  if (item.kind === "pack") {
-    throw new HTTPException(409, {
-      message: "Install Packs through the Pack installation preview flow",
-    });
-  }
+
   if (item.kind === "mcp" && !item.runtime.available) {
     throw new HTTPException(422, {
       message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled",
@@ -280,6 +302,49 @@ export async function enableCapability(input: {
   delete installationConfig.headerNames;
   delete installationConfig.connectionRef;
   if (item.kind === "mcp") {
+    if (
+      item.endpointUrl?.replace(/\/+$/u, "") === "https://gmailmcp.googleapis.com/mcp/v1" &&
+      (input.payload.connectionRef?.subjectScope !== "subject" ||
+        Object.keys(input.payload.headers ?? {}).length > 0)
+    ) {
+      throw new HTTPException(422, {
+        message: "Gmail requires a personal-owned connection reference",
+      });
+    }
+    // This generic, potentially workspace-authored catalog is not proof of a
+    // curated provider identity. Dedicated Connect adapters classify separately.
+    const unchanged = await withOrganizationIntegrationPolicyFence(
+      input.db,
+      input,
+      async (tx, policy) => {
+        const existing = await unchangedMcpInstallation(
+          { ...input, db: tx },
+          item,
+          installationConfig,
+        );
+        if (existing) return existing;
+        assertOrganizationIntegrationAllowed(policy, "custom:mcp");
+        return null;
+      },
+    );
+    if (unchanged) {
+      return {
+        commit: (db: Database) =>
+          withOrganizationIntegrationPolicyFence(db, input, async (tx) => {
+            const current = await unchangedMcpInstallation(
+              { ...input, db: tx },
+              item,
+              installationConfig,
+            );
+            if (!current || !isDeepStrictEqual(current, unchanged)) {
+              throw new HTTPException(409, {
+                message: "Capability installation changed; reload before reconciling",
+              });
+            }
+            return current;
+          }),
+      };
+    }
     const headers = await resolveMcpCredentialHeaders(input, item);
     const connectionRef = input.payload.connectionRef
       ? await validateMcpCapabilityConnectionRef(input, item, input.payload.connectionRef)
@@ -289,7 +354,12 @@ export async function enableCapability(input: {
       ...installationMetadata,
       ...(connectionRef && !headers
         ? authDeferredMcpConnectivity()
-        : await validateMcpCapabilityConnection(item, input.probeMcpServer, headers ?? undefined)),
+        : await validateMcpCapabilityConnection(
+            item,
+            input.probeMcpServer,
+            headers ?? undefined,
+            input.settings,
+          )),
     };
     if (connectionRef) {
       installationConfig.connectionRef = connectionRef;
@@ -301,14 +371,66 @@ export async function enableCapability(input: {
       );
     }
   }
-  return await enableCapabilityInstallation(input.db, {
+  const installation = {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
     capabilityId: item.id,
     kind: item.kind,
     config: installationConfig,
     metadata: installationMetadata,
-  });
+    ...(input.payload.onlyIfUninstalled ? { onlyIfUninstalled: true } : {}),
+  };
+  return {
+    commit: (db: Database) =>
+      item.kind === "mcp"
+        ? withOrganizationIntegrationAcquisition(db, installation, ["custom:mcp"], (tx) =>
+            enableCapabilityInstallation(tx, installation),
+          )
+        : enableCapabilityInstallation(db, installation),
+  };
+}
+
+/** A no-effect reconciliation is not a new acquisition. Validate ordinary
+ * connection visibility before locking the installation, and compare actual
+ * stored credentials rather than trusting caller-supplied identity hints. */
+async function unchangedMcpInstallation(
+  input: EnableCapabilityInput,
+  item: CapabilityCatalogItem,
+  requestedConfig: Record<string, unknown>,
+): Promise<CapabilityInstallation | null> {
+  const connectionRef = input.payload.connectionRef
+    ? await validateMcpCapabilityConnectionRef(input, item, input.payload.connectionRef)
+    : null;
+  const existing = await withLockedCapabilityInstallation(
+    input.db,
+    input.workspaceId,
+    item.id,
+    (tx) => getCapabilityInstallation(tx, input.workspaceId, item.id),
+  );
+  if (!existing || existing.kind !== "mcp" || existing.status !== "active") return null;
+  const {
+    headerNames: _names,
+    headersEncrypted: _encrypted,
+    headers: _headers,
+    ...storedConfig
+  } = existing.config;
+  const config = { ...requestedConfig, ...(connectionRef ? { connectionRef } : {}) };
+  const { mcpConnectivity: _storedConnectivity, ...storedMetadata } = existing.metadata;
+  const { mcpConnectivity: _requestedConnectivity, ...requestedMetadata } = input.payload.metadata;
+  if (
+    !isDeepStrictEqual(config, storedConfig) ||
+    !isDeepStrictEqual(requestedMetadata, storedMetadata)
+  )
+    return null;
+  const provided = normalizedMcpCredentialHeaders(input.payload.headers);
+  if (provided) {
+    const stored = await resolveMcpCredentialHeaders(
+      { ...input, payload: { ...input.payload, headers: {} } },
+      item,
+    );
+    if (!isDeepStrictEqual(provided, stored)) return null;
+  }
+  return existing;
 }
 
 /**
@@ -402,24 +524,17 @@ function normalizedMcpCredentialHeaders(
 }
 
 async function validateMcpCapabilityConnectionRef(
-  input: { db: Database; grant: AccessGrant; workspaceId: string },
+  input: { db: Database; grant: AccessGrant; workspaceId: string; settings: Settings },
   item: CapabilityCatalogItem,
   ref: McpServerConnectionRef,
 ): Promise<McpServerConnectionRef> {
   const subjectScope = ref.subjectScope ?? "workspace";
-  const personalOnly =
-    item.metadata.connectionOwnership === "personal_only" ||
-    item.endpointUrl?.replace(/\/+$/, "") === officialGmailMcpUrl;
-  if (personalOnly && subjectScope !== "subject") {
-    throw new HTTPException(422, {
-      message:
-        "this capability requires a personal connection; each workspace member must connect their own account",
-    });
-  }
   const normalized: McpServerConnectionRef = {
     providerDomain: ref.providerDomain.trim(),
     subjectScope,
     ...(ref.connectionId ? { connectionId: ref.connectionId } : {}),
+    ...(ref.accountSelection ? { accountSelection: ref.accountSelection } : {}),
+    ...(ref.authoritySource === "host" ? { authoritySource: "host" as const } : {}),
     ...(ref.provider ? { provider: ref.provider.trim() } : {}),
     ...(ref.kind ? { kind: ref.kind } : {}),
     ...(ref.scopes ? { scopes: uniqueStrings(ref.scopes) } : {}),
@@ -443,6 +558,10 @@ async function validateMcpCapabilityConnectionRef(
         "MCP capabilities need a remote streamable HTTP endpoint before they can use a connectionRef",
     });
   }
+  if (normalized.authoritySource === "host") {
+    assertNativeMcpConnectionRef(normalized);
+    return normalized;
+  }
 
   let connection = normalized.connectionId
     ? await getConnectionMetadata(
@@ -452,7 +571,11 @@ async function validateMcpCapabilityConnectionRef(
         input.grant.subjectId,
       )
     : null;
-  if (!connection && subjectScope === "subject" && !normalized.connectionId) {
+  if (
+    !connection &&
+    !normalized.connectionId &&
+    (subjectScope === "subject" || normalized.accountSelection === "all_eligible")
+  ) {
     const visible = await listConnectionsMetadata(
       input.db,
       input.workspaceId,
@@ -461,7 +584,7 @@ async function validateMcpCapabilityConnectionRef(
     connection =
       visible.find(
         (candidate) =>
-          candidate.subjectId === input.grant.subjectId &&
+          candidate.subjectId === (subjectScope === "subject" ? input.grant.subjectId : null) &&
           candidate.providerDomain === normalized.providerDomain &&
           (!normalized.kind || candidate.kind === normalized.kind) &&
           candidate.status === "active",
@@ -561,6 +684,7 @@ export type McpCapabilityProbeInput = {
   url: string;
   timeoutMs: number;
   headers?: Record<string, string>;
+  settings?: Settings;
 };
 
 export type McpCapabilityProbeResult = {
@@ -575,6 +699,7 @@ export async function validateMcpCapabilityConnection(
   item: CapabilityCatalogItem,
   probe: McpCapabilityProbe = probeStreamableHttpMcpServer,
   headers?: Record<string, string>,
+  settings?: Settings,
 ): Promise<Record<string, unknown>> {
   if (item.kind !== "mcp") {
     return {};
@@ -591,6 +716,7 @@ export async function validateMcpCapabilityConnection(
       url: item.endpointUrl,
       timeoutMs: mcpCapabilityProbeTimeoutMs,
       ...(headers ? { headers } : {}),
+      ...(settings ? { settings } : {}),
     });
     return {
       mcpConnectivity: {
@@ -609,6 +735,8 @@ export async function validateMcpCapabilityConnection(
 async function probeStreamableHttpMcpServer(
   input: McpCapabilityProbeInput,
 ): Promise<McpCapabilityProbeResult> {
+  const settings = input.settings;
+  if (!settings) throw new Error("Network policy is unavailable for MCP validation");
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
   const client = new Client(
@@ -621,6 +749,11 @@ async function probeStreamableHttpMcpServer(
         signal: controller.signal,
         ...(input.headers ? { headers: input.headers } : {}),
       },
+      fetch: (url, init) =>
+        pinnedFetch(url, init, settings, {
+          label: "MCP capability probe",
+          requireHttpsOutsideLocalTest: true,
+        }),
     });
     await client.connect(transport as unknown as Transport, {
       timeout: input.timeoutMs,
@@ -646,9 +779,9 @@ function mcpProbeErrorMessage(error: unknown, endpointUrl: string): string {
       normalized,
     )
   ) {
-    return `OpenGeni could not reach a valid Streamable HTTP MCP server at ${endpoint}. Check the endpoint URL or choose a different catalog entry.`;
+    return `Opengeni could not reach a valid Streamable HTTP MCP server at ${endpoint}. Check the endpoint URL or choose a different catalog entry.`;
   }
-  return `OpenGeni could not initialize ${endpoint}. Check the endpoint configuration or try again.`;
+  return `Opengeni could not initialize ${endpoint}. Check the endpoint configuration or try again.`;
 }
 
 function safeEndpointLabel(endpointUrl: string): string {
@@ -687,11 +820,7 @@ export async function disableCapability(input: {
       message: "Remove Plugins through the Plugin Package flow",
     });
   }
-  if (item.kind === "pack") {
-    throw new HTTPException(409, {
-      message: "Uninstall Packs through the Pack uninstall preview flow",
-    });
-  }
+
   if (item.source === "built_in" || item.source === "configured") {
     throw new HTTPException(409, {
       message:
@@ -745,7 +874,7 @@ export function apiIntegrationsMatchingDelegations(
   const exact = new Set(
     delegations.map((delegation) =>
       [
-        delegation.serverId,
+        delegation.canonicalServerId ?? delegation.serverId,
         delegation.connectionId,
         delegation.providerDomain.toLowerCase(),
         delegation.kind ?? "",
@@ -952,9 +1081,6 @@ export async function discoverMcpRegistryCapabilities(input: {
       if (!item || seen.has(item.id)) {
         continue;
       }
-      if (query && !catalogSearchText(item).includes(query)) {
-        continue;
-      }
       seen.add(item.id);
       items.push(item);
       if (items.length >= limit) {
@@ -962,7 +1088,9 @@ export async function discoverMcpRegistryCapabilities(input: {
       }
     }
     cursor = typeof page.metadata?.nextCursor === "string" ? page.metadata.nextCursor : undefined;
-    if (!cursor) {
+    // Return usable results promptly rather than fetching more pages merely
+    // to fill the requested limit. The registry already applies the search.
+    if (items.length > 0 || !cursor) {
       break;
     }
   }
@@ -1028,52 +1156,6 @@ async function requireCatalogItem(
   return item;
 }
 
-function packCatalogItem(
-  pack: ReturnType<typeof listCapabilityPacks>[number],
-  source: "built_in" | "manual",
-): CapabilityCatalogItem {
-  const customMetadata = { ...pack.metadata };
-  for (const key of [
-    "packId",
-    "version",
-    "connectors",
-    "knowledge",
-    "scheduledTaskTemplates",
-    "sandboxImage",
-    "sandboxProviderImages",
-    "skills",
-  ]) {
-    delete customMetadata[key];
-  }
-  return CapabilityCatalogItem.parse({
-    id: `pack:${pack.id}`,
-    kind: "pack",
-    source,
-    name: pack.name,
-    description: pack.description,
-    category: pack.category,
-    tags: [pack.role, pack.category, "pack"],
-    tools: pack.tools,
-    runtime: {
-      available: true,
-      notes: "Enables role-scoped tools, connectors, knowledge, and scheduled-task templates.",
-    },
-    metadata: {
-      ...customMetadata,
-      packId: pack.id,
-      version: pack.version,
-      connectors: pack.connectors,
-      knowledge: pack.knowledge,
-      scheduledTaskTemplates: pack.scheduledTaskTemplates,
-      ...(pack.variableSet ? { variableSet: pack.variableSet } : {}),
-      // Runtime composition surface only: skill names, never file content.
-      ...(pack.sandboxImage ? { sandboxImage: pack.sandboxImage } : {}),
-      ...(pack.sandboxProviderImages ? { sandboxProviderImages: pack.sandboxProviderImages } : {}),
-      ...(pack.skills.length > 0 ? { skills: pack.skills.map((skill) => skill.name) } : {}),
-    },
-  });
-}
-
 function configuredMcpCatalogItems(settings: Settings): CapabilityCatalogItem[] {
   return (
     settings.mcpServers
@@ -1094,12 +1176,23 @@ function configuredMcpCatalogItems(settings: Settings): CapabilityCatalogItem[]
           category: "configured",
           tags: ["mcp", ...(server.allowedTools?.length ? ["limited-tools"] : [])],
           endpointUrl: server.url,
+          authKind:
+            server.connectionRef?.authoritySource !== "host" &&
+            server.connectionRef?.kind === "oauth2"
+              ? "oauth2"
+              : null,
+          // Deployment-managed personal selectors need the same account picker
+          // as installed connectors. Fixed bindings remain server-resolved.
+          connectionRef:
+            server.connectionRef?.subjectScope === "subject" && !server.connectionRef.connectionId
+              ? installationConnectionRef({ connectionRef: server.connectionRef })
+              : null,
           tools: [{ kind: "mcp", id: server.id }],
           runtime: {
             available: true,
             mcpServerId: server.id,
             transport: "streamable-http",
-            notes: "Managed by this OpenGeni deployment through OPENGENI_MCP_SERVERS.",
+            notes: "Managed by this Opengeni deployment through OPENGENI_MCP_SERVERS.",
           },
           metadata: {
             mcpServerId: server.id,
@@ -1235,7 +1328,7 @@ function fikenCatalogItem(fikenConnections: ConnectionMetadata[]): CapabilityCat
     runtime: {
       available: true,
       mcpServerId: "opengeni",
-      notes: "Fiken access is provided through OpenGeni's first-party fiken tools.",
+      notes: "Fiken access is provided through Opengeni's first-party fiken tools.",
     },
     enabled: fikenEnabled,
     enabledReason: fikenEnabled
@@ -1246,6 +1339,7 @@ function fikenCatalogItem(fikenConnections: ConnectionMetadata[]): CapabilityCat
     metadata: {
       connectorMode: "first_party_fiken",
       ownership: "workspace",
+      connectionStatus: fikenConnection?.status ?? null,
       // Derived from the contracts catalog so a new fiken_* tool cannot be
       // registered without also appearing on the capability tile.
       firstPartyMcpTools: FIRST_PARTY_MCP_TOOL_NAMES.filter((name) => name.startsWith("fiken_")),
@@ -1277,11 +1371,11 @@ function providerIntegrationCatalogItems(
         available: true,
         mcpServerId: "opengeni",
         notes:
-          "OpenGeni's social provider adapter routes every call through an exact visible account Connection.",
+          "Opengeni's social provider adapter routes every call through an exact visible account Connection.",
       },
       enabled,
       enabledReason: socialConnectionSummary(counts),
-      provenance: "OpenGeni provider adapter",
+      provenance: "Opengeni provider adapter",
       metadata: {
         providerAdapter: "social",
         provider: definition.provider,
@@ -1306,7 +1400,7 @@ export function nativeConnectionCapabilityRecommendations(): CapabilityCatalogIt
       kind: "api",
       source: "built_in",
       name: "GitHub App",
-      description: "Connect repositories through OpenGeni's GitHub resource picker.",
+      description: "Connect repositories through Opengeni's GitHub resource picker.",
       category: "source-control",
       tags: ["github", "repositories", "source-control"],
       homepageUrl: "https://github.com",
@@ -1494,31 +1588,21 @@ function socialProviderConnectionCounts(item: CapabilityCatalogItem): {
 export function applyCapabilityEnablement(
   item: CapabilityCatalogItem,
   installation: CapabilityInstallation | undefined,
-  activePackIds: Set<string>,
 ): CapabilityCatalogItem {
+  if (item.surfaceType === "first_party_fiken") {
+    // Fiken is an API item with connection-derived state, not a generic API
+    // installation. Preserve that state before the non-MCP fallback below.
+    return { ...item, connectionRef: null };
+  }
   if (item.kind === "skill" || item.kind === "api" || item.kind === "plugin") {
     return { ...item, enabled: false, enabledReason: null, connectionRef: null };
   }
-  if (item.kind === "pack") {
-    const enabled = activePackIds.has(packIdFromCapabilityId(item.id));
-    return {
-      ...item,
-      enabled,
-      enabledReason: enabled ? "enabled" : null,
-    };
-  }
   if (isSocialProviderIntegration(item)) {
     // Provider-integration state is derived from every authoritative visible
     // social Connection while the catalog is built. The catalog summary never
     // publishes a personal connection UUID or collapses many accounts to one.
     return { ...item, connectionRef: null };
   }
-  if (item.surfaceType === "first_party_fiken") {
-    // Fiken connector state is derived from the authoritative workspace
-    // connection row while the catalog is built; browseable never means an
-    // account is already connected.
-    return { ...item, connectionRef: null };
-  }
   if (item.surfaceType === "codex_apps") {
     // Unlike ordinary built-ins, Apps availability is derived from the exact
     // active workspace designation above. Do not overwrite it with the
@@ -1530,7 +1614,7 @@ export function applyCapabilityEnablement(
       ...item,
       enabled: true,
       enabledReason: "managed by deployment",
-      connectionRef: null,
+      connectionRef: item.connectionRef,
     };
   }
   if (item.source === "built_in") {
@@ -1541,11 +1625,17 @@ export function applyCapabilityEnablement(
   }
   const activeInstallation = installation?.status === "active";
   const enabled = !!activeInstallation && capabilityInstallationRuntimeReady(item, installation);
+  const connectionRef =
+    enabled && installation ? installationConnectionRef(installation.config) : null;
   return {
     ...item,
+    // Older custom entries recorded the native credential kind on the
+    // installation only. Project it without guessing from a URL or overwriting
+    // an explicit catalog authentication contract.
+    authKind: item.authKind ?? (connectionRef?.kind === "oauth2" ? "oauth2" : null),
     enabled,
     enabledReason: enabled ? "enabled" : null,
-    connectionRef: enabled && installation ? installationConnectionRef(installation.config) : null,
+    connectionRef,
   };
 }
 
@@ -1572,7 +1662,10 @@ function applyCapabilityLifecycle(item: CapabilityCatalogItem): CapabilityCatalo
         detail: item.runtime.notes,
         managedBy: item.source === "built_in" ? "platform" : null,
       },
-      actions: ["inspect"],
+      actions:
+        item.enabled && item.kind === "mcp" && item.source !== "built_in"
+          ? ["disconnect", "inspect"]
+          : ["inspect"],
     };
   }
 
@@ -1611,7 +1704,7 @@ function applyCapabilityLifecycle(item: CapabilityCatalogItem): CapabilityCatalo
 
   const installed = item.enabled;
   const actions: CapabilityAction[] = installed
-    ? item.kind === "pack" || item.kind === "skill" || item.kind === "plugin"
+    ? item.kind === "skill" || item.kind === "plugin"
       ? ["configure", "update", "uninstall", "inspect"]
       : ["configure", "disconnect", "inspect"]
     : item.kind === "mcp" || item.kind === "api"
@@ -1674,14 +1767,34 @@ function installationConnectionRef(
   if (!ref || typeof ref !== "object") {
     return null;
   }
-  const { connectionId, providerDomain, kind, subjectScope } = ref as Record<string, unknown>;
+  const { authoritySource, connectionId, providerDomain, kind, subjectScope, accountSelection } =
+    ref as Record<string, unknown>;
   if (typeof providerDomain !== "string" || typeof kind !== "string") {
     return null;
   }
+  if (authoritySource === "host") {
+    // The internal installation/runtime ref retains the exact host binding.
+    // Public capability catalogs use the existing null representation for an
+    // enabled capability without a native OpenGeni connection, so indefinitely
+    // open old browser bundles cannot treat a host UUID as native OAuth state.
+    return null;
+  }
+  if (accountSelection === "all_eligible" && connectionId === undefined) {
+    return {
+      providerDomain,
+      kind,
+      accountSelection,
+      ...(subjectScope === "subject" ? { subjectScope } : {}),
+    };
+  }
   if (subjectScope === "subject") {
-    // Never project a personal connection UUID through workspace-visible
+    // Never project a native personal connection UUID through workspace-visible
     // capability configuration, including legacy rows that still contain one.
-    return { providerDomain, kind, subjectScope: "subject" };
+    return {
+      providerDomain,
+      kind,
+      subjectScope: "subject",
+    };
   }
   if (typeof connectionId !== "string") {
     return null;
@@ -1807,10 +1920,6 @@ function publicRegistryCapabilityId(name: string, version: string, endpointUrl:
   return `mcp-registry:${slugify(name)}-${shortHash(`${name}:${version}:${endpointUrl}`)}`;
 }
 
-function packIdFromCapabilityId(capabilityId: string): string {
-  return capabilityId.replace(/^pack:/, "");
-}
-
 function uniqueTags(tags: string[]): string[] {
   return [...new Set(tags.map((tag) => tag.trim()).filter(Boolean))];
 }
@@ -1958,22 +2067,6 @@ function validUrl(value: string | undefined): string | null {
   }
 }
 
-function catalogSearchText(item: CapabilityCatalogItem): string {
-  return [
-    item.name,
-    item.description,
-    item.category,
-    ...item.tags,
-    item.endpointUrl,
-    item.homepageUrl,
-    item.installUrl,
-    JSON.stringify(item.metadata),
-  ]
-    .filter(Boolean)
-    .join(" ")
-    .toLowerCase();
-}
-
 function capabilityInstallationRuntimeReady(
   item: CapabilityCatalogItem,
   installation: CapabilityInstallation | undefined,