@anton.andrusenko/shopify-mcp-admin 0.7.0 → 1.0.0

package/dist/index.js

@@ -25,7 +25,17 @@ var configSchema = z.object({
   TRANSPORT: z.enum(["stdio", "http"]).default("stdio"),
   // Store info cache TTL (milliseconds)
   // Default: 5 minutes (300000ms) - configurable for performance tuning
-  STORE_INFO_CACHE_TTL_MS: z.string().optional().default("300000").transform(Number).describe("Cache TTL for store info in milliseconds (default: 5 minutes)")
+  STORE_INFO_CACHE_TTL_MS: z.string().optional().default("300000").transform(Number).describe("Cache TTL for store info in milliseconds (default: 5 minutes)"),
+  // Lazy loading configuration (Epic 12)
+  // Default: true - enables module-based lazy loading for optimal AI performance
+  // Set to 'false' or '0' to load all tools at startup (legacy mode)
+  SHOPIFY_MCP_LAZY_LOADING: z.string().optional().default("true").transform((val) => val === "true" || val === "1").describe("Enable lazy loading of tools via modules (default: true)"),
+  // Role preset configuration (Story 12.3: Progressive Loading)
+  // Automatically loads appropriate modules at startup based on role
+  // Valid roles: inventory-manager, product-manager, content-manager,
+  //              seo-specialist, international-manager, full-access
+  // When not set, only core module is loaded (requires manual module loading)
+  SHOPIFY_MCP_ROLE: z.string().optional().describe("Role preset for automatic module loading at startup")
 }).refine(
   (data) => {
     const hasLegacyAuth = !!data.SHOPIFY_ACCESS_TOKEN;
@@ -73,6 +83,12 @@ function isDebugEnabled(debugValue) {
   const normalized = debugValue.toLowerCase().trim();
   return normalized === "1" || normalized === "true";
 }
+function isLazyLoadingEnabled(config) {
+  return config.SHOPIFY_MCP_LAZY_LOADING;
+}
+function getConfiguredRole(config) {
+  return config.SHOPIFY_MCP_ROLE;
+}
 
 // src/config/index.ts
 var _config = null;
@@ -917,9 +933,351 @@ var PRODUCTS_QUERY = `
     }
   }
 `;
+var STORE_LIMITS_QUERY = `
+  query ShopResourceLimits {
+    shop {
+      resourceLimits {
+        maxProductVariants
+        maxProductOptions
+        locationLimit
+        redirectLimitReached
+      }
+    }
+  }
+`;
+var STORE_FEATURES_QUERY = `
+  query ShopFeatures {
+    shop {
+      features {
+        giftCards
+        reports
+        storefront
+        bundles {
+          eligibleForBundles
+        }
+        sellsSubscriptions
+      }
+    }
+  }
+`;
+var STORE_CURRENCIES_QUERY = `
+  query ShopCurrencies {
+    shop {
+      currencyCode
+      enabledPresentmentCurrencies
+      currencyFormats {
+        moneyFormat
+        moneyWithCurrencyFormat
+      }
+    }
+  }
+`;
+var STORE_SHIPPING_QUERY = `
+  query ShopShipping {
+    shop {
+      shipsToCountries
+      countriesInShippingZones {
+        countryCodes
+      }
+    }
+  }
+`;
+var STORE_DOMAIN_QUERY = `
+  query ShopDomain {
+    shop {
+      primaryDomain {
+        host
+        url
+        sslEnabled
+      }
+    }
+  }
+`;
+var STORE_TAXES_QUERY = `
+  query ShopTaxes {
+    shop {
+      taxesIncluded
+      taxShipping
+    }
+  }
+`;
+var STORE_POLICIES_QUERY = `
+  query ShopPolicies {
+    shop {
+      shopPolicies {
+        title
+        type
+        url
+      }
+    }
+  }
+`;
+var STORE_ALERTS_QUERY = `
+  query ShopAlerts {
+    shop {
+      alerts {
+        action {
+          title
+          url
+        }
+        description
+      }
+      setupRequired
+    }
+  }
+`;
 
-// src/shopify/store-info.ts
+// src/shopify/store-info-extended.ts
 var DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
+var ALERTS_CACHE_TTL_MS = 60 * 1e3;
+var _cachedStoreLimits = null;
+var _limitsTimestamp = 0;
+var _cachedStoreFeatures = null;
+var _featuresTimestamp = 0;
+var _cachedStoreCurrencies = null;
+var _currenciesTimestamp = 0;
+var _cachedStoreShipping = null;
+var _shippingTimestamp = 0;
+var _cachedStoreDomain = null;
+var _domainTimestamp = 0;
+var _cachedStoreTaxes = null;
+var _taxesTimestamp = 0;
+var _cachedStorePolicies = null;
+var _policiesTimestamp = 0;
+var _cachedStoreAlerts = null;
+var _alertsTimestamp = 0;
+async function getStoreLimits() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreLimits && now - _limitsTimestamp < ttl) {
+    log.debug("Returning cached store limits");
+    return _cachedStoreLimits;
+  }
+  log.debug("Fetching fresh store limits from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_LIMITS_QUERY),
+    "getStoreLimits"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop?.resourceLimits) {
+    throw new Error("Invalid response: missing shop.resourceLimits data");
+  }
+  _cachedStoreLimits = response.data.shop.resourceLimits;
+  _limitsTimestamp = now;
+  return _cachedStoreLimits;
+}
+async function getStoreFeatures() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreFeatures && now - _featuresTimestamp < ttl) {
+    log.debug("Returning cached store features");
+    return _cachedStoreFeatures;
+  }
+  log.debug("Fetching fresh store features from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_FEATURES_QUERY),
+    "getStoreFeatures"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop?.features) {
+    throw new Error("Invalid response: missing shop.features data");
+  }
+  _cachedStoreFeatures = response.data.shop.features;
+  _featuresTimestamp = now;
+  return _cachedStoreFeatures;
+}
+async function getStoreCurrencies() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreCurrencies && now - _currenciesTimestamp < ttl) {
+    log.debug("Returning cached store currencies");
+    return _cachedStoreCurrencies;
+  }
+  log.debug("Fetching fresh store currencies from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_CURRENCIES_QUERY),
+    "getStoreCurrencies"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop) {
+    throw new Error("Invalid response: missing shop data");
+  }
+  const { currencyCode, enabledPresentmentCurrencies, currencyFormats } = response.data.shop;
+  _cachedStoreCurrencies = {
+    currencyCode,
+    enabledPresentmentCurrencies,
+    currencyFormats
+  };
+  _currenciesTimestamp = now;
+  return _cachedStoreCurrencies;
+}
+async function getStoreShipping() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreShipping && now - _shippingTimestamp < ttl) {
+    log.debug("Returning cached store shipping");
+    return _cachedStoreShipping;
+  }
+  log.debug("Fetching fresh store shipping from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_SHIPPING_QUERY),
+    "getStoreShipping"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop) {
+    throw new Error("Invalid response: missing shop data");
+  }
+  _cachedStoreShipping = {
+    shipsToCountries: response.data.shop.shipsToCountries,
+    countriesInShippingZones: response.data.shop.countriesInShippingZones
+  };
+  _shippingTimestamp = now;
+  return _cachedStoreShipping;
+}
+async function getStoreDomain() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreDomain && now - _domainTimestamp < ttl) {
+    log.debug("Returning cached store domain");
+    return _cachedStoreDomain;
+  }
+  log.debug("Fetching fresh store domain from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_DOMAIN_QUERY),
+    "getStoreDomain"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop?.primaryDomain) {
+    throw new Error("Invalid response: missing shop.primaryDomain data");
+  }
+  _cachedStoreDomain = {
+    primaryDomain: response.data.shop.primaryDomain
+  };
+  _domainTimestamp = now;
+  return _cachedStoreDomain;
+}
+async function getStoreTaxes() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreTaxes && now - _taxesTimestamp < ttl) {
+    log.debug("Returning cached store taxes");
+    return _cachedStoreTaxes;
+  }
+  log.debug("Fetching fresh store taxes from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_TAXES_QUERY),
+    "getStoreTaxes"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (response.data?.shop === void 0 || response.data?.shop === null) {
+    throw new Error("Invalid response: missing shop data");
+  }
+  _cachedStoreTaxes = {
+    taxesIncluded: response.data.shop.taxesIncluded,
+    taxShipping: response.data.shop.taxShipping
+  };
+  _taxesTimestamp = now;
+  return _cachedStoreTaxes;
+}
+async function getStorePolicies() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStorePolicies && now - _policiesTimestamp < ttl) {
+    log.debug("Returning cached store policies");
+    return _cachedStorePolicies;
+  }
+  try {
+    log.debug("Fetching fresh store policies from Shopify");
+    const client = await getShopifyClient();
+    const response = await withRateLimit(
+      () => client.graphql.request(STORE_POLICIES_QUERY),
+      "getStorePolicies"
+    );
+    if (response.errors && response.errors.length > 0) {
+      const errorMessages = response.errors.map((e) => e.message).join(", ");
+      if (errorMessages.toLowerCase().includes("access denied") || errorMessages.toLowerCase().includes("unauthorized")) {
+        log.debug("read_legal_policies scope not available, returning empty policies");
+        _cachedStorePolicies = { shopPolicies: [] };
+        _policiesTimestamp = now;
+        return _cachedStorePolicies;
+      }
+      throw new Error(`GraphQL errors: ${errorMessages}`);
+    }
+    const policies = response.data?.shop?.shopPolicies ?? [];
+    _cachedStorePolicies = { shopPolicies: policies };
+    _policiesTimestamp = now;
+    return _cachedStorePolicies;
+  } catch (error) {
+    if (error instanceof Error && (error.message.toLowerCase().includes("access denied") || error.message.toLowerCase().includes("unauthorized"))) {
+      log.debug("read_legal_policies scope not available, returning empty policies");
+      _cachedStorePolicies = { shopPolicies: [] };
+      _policiesTimestamp = now;
+      return _cachedStorePolicies;
+    }
+    throw error;
+  }
+}
+async function getStoreAlerts() {
+  const now = Date.now();
+  const ttl = ALERTS_CACHE_TTL_MS;
+  if (_cachedStoreAlerts && now - _alertsTimestamp < ttl) {
+    log.debug("Returning cached store alerts");
+    return _cachedStoreAlerts;
+  }
+  log.debug("Fetching fresh store alerts from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_ALERTS_QUERY),
+    "getStoreAlerts"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (response.data?.shop === void 0 || response.data?.shop === null) {
+    throw new Error("Invalid response: missing shop data");
+  }
+  _cachedStoreAlerts = {
+    alerts: response.data.shop.alerts ?? [],
+    setupRequired: response.data.shop.setupRequired
+  };
+  _alertsTimestamp = now;
+  return _cachedStoreAlerts;
+}
+
+// src/shopify/store-info.ts
+var DEFAULT_CACHE_TTL_MS2 = 5 * 60 * 1e3;
 var _cachedStoreInfo = null;
 var _cacheTimestamp = 0;
 function transformShopResponse(shop) {
@@ -939,7 +1297,7 @@ function transformShopResponse(shop) {
 async function getStoreInfo() {
   const now = Date.now();
   const config = getConfig();
-  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS2;
   if (_cachedStoreInfo && now - _cacheTimestamp < ttl) {
     log.debug("Returning cached store info");
     return _cachedStoreInfo;
@@ -968,14 +1326,45 @@ var packageJson = require2("../package.json");
 var SERVER_NAME = "shopify-mcp-admin";
 var SERVER_INSTRUCTIONS = `This MCP server provides access to a Shopify store's Admin API.
 
-KEY CONCEPTS:
-- Products contain variants; each variant has its own price, SKU, and inventory
-- Inventory is tracked per variant AND per location (multi-location stores)
-- Metafields store custom data using namespace/key pairs
-- Collections organize products for navigation and SEO
-- All IDs use Shopify GID format: "gid://shopify/Product/123"
+## TOOL MODULES (Modular Architecture)
+
+Tools are organized into modules for optimal AI performance. Start with core tools and load additional modules as needed.
+
+**Discovery & Loading:**
+- Use "list-modules" to see all available modules and their loading status
+- Use "load-module" with module name to enable additional tools
+- Tool responses may include suggestions for relevant modules to load
+
+**Available Modules:**
+| Module | Description | Tools |
+|--------|-------------|-------|
+| core | Products, inventory, store info (always loaded) | 15 |
+| store-context | Extended store configuration (features, currencies, shipping) | 7 |
+| collections | Collection management and metafields | 10 |
+| product-extensions | Product metafields, images, and URL redirects | 9 |
+| content | Pages, blogs, and articles management | 22 |
+| international | Markets, web presence, and translations | 14 |
+| advanced-redirects | Bulk redirect operations | 4 |
+
+**Role Presets (SHOPIFY_MCP_ROLE):**
+Pre-configured module sets for common workflows:
+- inventory-manager: Core only (15 tools) - stock management
+- product-manager: Core + store-context + collections + product-extensions (41 tools)
+- content-manager: Core + content (37 tools) - pages and blogs
+- seo-specialist: Core + collections + product-extensions + advanced-redirects (38 tools)
+- international-manager: Core + store-context + international + collections (46 tools)
+- full-access: All modules (81 tools) - full store administration
+
+## KEY CONCEPTS
+
+- **Products & Variants**: Products contain variants; each variant has its own price, SKU, and inventory
+- **Multi-location Inventory**: Inventory is tracked per variant AND per location
+- **Metafields**: Store custom data using namespace/key pairs on products, collections, pages, blogs, and articles
+- **Collections**: Organize products for navigation and SEO
+- **GID Format**: All IDs use Shopify GID format: "gid://shopify/Product/123"
+
+## RESOURCE TYPES & GID FORMATS
 
-RESOURCE TYPES & GID FORMATS:
 - Products: gid://shopify/Product/{id}
 - Variants: gid://shopify/ProductVariant/{id}
 - Collections: gid://shopify/Collection/{id}
@@ -987,21 +1376,25 @@ RESOURCE TYPES & GID FORMATS:
 - InventoryItems: gid://shopify/InventoryItem/{id}
 - Locations: gid://shopify/Location/{id}
 
-BEST PRACTICES:
-- Always verify product/variant IDs using get-product before updates
-- Use list-low-inventory to proactively identify stock issues
-- When updating SEO, consider updating URL redirects
-- For bulk operations, prefer bulk tools when available
-- Use metafields to store custom SEO data (JSON-LD, Open Graph)
+## BEST PRACTICES
+
+- **Verify before modifying**: Use get-product to verify IDs before updates
+- **Proactive inventory**: Use list-low-inventory to identify stock issues
+- **SEO redirects**: When updating product handles, consider creating URL redirects
+- **Bulk operations**: Use bulk tools (get-bulk-inventory, bulk-delete-redirects) when available
+- **Metafields for SEO**: Store custom SEO data (JSON-LD, Open Graph) in metafields
+
+## RATE LIMITS
 
-RATE LIMITS:
 - Shopify GraphQL has cost-based rate limiting (~50 points/sec)
 - Large queries may retry automatically with exponential backoff
 - Rate limit errors include helpful retry suggestions
 
-WORKFLOW HINTS:
+## WORKFLOW HINTS
+
 - Tool descriptions include **Prerequisites:** and **Follow-ups:** for multi-step operations
-- Check tool category and relationships for semantic grouping`;
+- Check tool category and relationships for semantic grouping
+- After successful operations, note any module suggestions in the response`;
 function getServerVersion() {
   return packageJson.version;
 }
@@ -1022,8 +1415,12 @@ function createServer() {
         logging: {}
         // Enable logging capability (AC-9.5.1.2)
       },
-      instructions: SERVER_INSTRUCTIONS
+      instructions: SERVER_INSTRUCTIONS,
       // Provide Shopify context to AI agents (AC-9.5.1.1)
+      // Epic 12: Notification debouncing for module loading (AC-12.1.6)
+      // When multiple tools are enabled in rapid succession (e.g., loading a module),
+      // coalesce into a single notifications/tools/list_changed notification
+      debouncedNotificationMethods: ["notifications/tools/list_changed"]
     }
   );
   return server;
@@ -1067,71 +1464,375 @@ function registerResources(server) {
       }
     }
   );
-}
-
-// src/tools/index.ts
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-
-// node_modules/zod-to-json-schema/dist/esm/Options.js
-var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-var defaultOptions = {
-  name: void 0,
-  $refStrategy: "root",
-  basePath: ["#"],
-  effectStrategy: "input",
-  pipeStrategy: "all",
-  dateStrategy: "format:date-time",
-  mapStrategy: "entries",
-  removeAdditionalStrategy: "passthrough",
-  allowedAdditionalProperties: true,
-  rejectedAdditionalProperties: false,
-  definitionPath: "definitions",
-  target: "jsonSchema7",
-  strictUnions: false,
-  definitions: {},
-  errorMessages: false,
-  markdownDescription: false,
-  patternStrategy: "escape",
-  applyRegexFlags: false,
-  emailStrategy: "format:email",
-  base64Strategy: "contentEncoding:base64",
-  nameStrategy: "ref",
-  openAiAnyTypeName: "OpenAiAnyType"
-};
-var getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-
-// node_modules/zod-to-json-schema/dist/esm/Refs.js
-var getRefs = (options) => {
-  const _options = getDefaultOptions(options);
-  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
-  return {
-    ..._options,
-    flags: { hasReferencedOpenAiAnyType: false },
-    currentPath,
-    propertyPath: void 0,
-    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-      def._def,
-      {
-        def: def._def,
-        path: [..._options.basePath, _options.definitionPath, name],
-        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-        jsonSchema: void 0
+  server.resource(
+    "store-limits",
+    "shopify://store/limits",
+    {
+      description: "Resource limits for the Shopify store including max product variants, max product options, location limit, and redirect limit status. Use this to validate operations against store constraints.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const limits = await getStoreLimits();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/limits",
+              mimeType: "application/json",
+              text: JSON.stringify(limits, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store limits", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/limits",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store limits",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
       }
-    ]))
-  };
-};
-
-// node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage, refs) {
+    }
+  );
+  server.resource(
+    "store-features",
+    "shopify://store/features",
+    {
+      description: "Feature flags for the Shopify store including gift cards, reports, storefront, bundles eligibility, and subscriptions. Use this to determine available store capabilities.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const features = await getStoreFeatures();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/features",
+              mimeType: "application/json",
+              text: JSON.stringify(features, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store features", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/features",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store features",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-currencies",
+    "shopify://store/currencies",
+    {
+      description: "Currency configuration for the Shopify store including base currency, enabled presentment currencies, and money format patterns. Use this to understand multi-currency setup.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const currencies = await getStoreCurrencies();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/currencies",
+              mimeType: "application/json",
+              text: JSON.stringify(currencies, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store currencies", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/currencies",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store currencies",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-shipping",
+    "shopify://store/shipping",
+    {
+      description: "Shipping configuration for the Shopify store including ships-to countries and countries with configured shipping zones. Use this to understand international shipping capabilities.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const shipping = await getStoreShipping();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/shipping",
+              mimeType: "application/json",
+              text: JSON.stringify(shipping, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store shipping", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/shipping",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store shipping",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-domain",
+    "shopify://store/domain",
+    {
+      description: "Primary domain configuration for the Shopify store including hostname, URL, and SSL status. Use this to construct proper URLs and understand store identity.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const domain = await getStoreDomain();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/domain",
+              mimeType: "application/json",
+              text: JSON.stringify(domain, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store domain", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/domain",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store domain",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-taxes",
+    "shopify://store/taxes",
+    {
+      description: "Tax configuration for the Shopify store including whether taxes are included in prices and tax shipping settings. Use this to understand pricing structure for tax calculations.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const taxes = await getStoreTaxes();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/taxes",
+              mimeType: "application/json",
+              text: JSON.stringify(taxes, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store taxes", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/taxes",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store taxes",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-policies",
+    "shopify://store/policies",
+    {
+      description: "Legal policies for the Shopify store (privacy policy, terms of service, refund policy). Returns empty array if read_legal_policies scope is not available. Use this to reference store policies in customer communications.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const policies = await getStorePolicies();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/policies",
+              mimeType: "application/json",
+              text: JSON.stringify(policies, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store policies", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/policies",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store policies",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-alerts",
+    "shopify://store/alerts",
+    {
+      description: "Active admin alerts and setup requirements for the Shopify store. Use this to proactively identify issues needing merchant attention.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const alerts = await getStoreAlerts();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/alerts",
+              mimeType: "application/json",
+              text: JSON.stringify(alerts, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store alerts", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/alerts",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store alerts",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+
+// node_modules/zod-to-json-schema/dist/esm/Refs.js
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+
+// node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage(res, key, errorMessage, refs) {
   if (!refs?.errorMessages)
     return;
   if (errorMessage) {
@@ -2393,6 +3094,7 @@ function deriveDefaultAnnotations(name) {
   };
 }
 var registeredTools = /* @__PURE__ */ new Map();
+var toolEnabledState = /* @__PURE__ */ new Map();
 function validateToolName(name) {
   if (!name || name.trim() === "") {
     throw new Error("Tool name cannot be empty");
@@ -2451,7 +3153,7 @@ function wrapToolHandler(toolName, schema, handler) {
   };
 }
 function registerTool(definition, handler, options = {}) {
-  const { name, title, description, inputSchema: inputSchema72, annotations } = definition;
+  const { name, title, description, inputSchema: inputSchema82, annotations } = definition;
   try {
     if (!options.skipNameValidation) {
       validateToolName(name);
@@ -2459,8 +3161,8 @@ function registerTool(definition, handler, options = {}) {
     if (registeredTools.has(name)) {
       throw new Error(`Tool "${name}" is already registered. Tool names must be unique.`);
     }
-    const jsonSchema = convertZodToJsonSchema(inputSchema72);
-    const wrappedHandler = wrapToolHandler(name, inputSchema72, handler);
+    const jsonSchema = convertZodToJsonSchema(inputSchema82);
+    const wrappedHandler = wrapToolHandler(name, inputSchema82, handler);
     const finalAnnotations = {
       ...deriveDefaultAnnotations(name),
       ...annotations,
@@ -2472,7 +3174,7 @@ function registerTool(definition, handler, options = {}) {
       title,
       description,
       inputSchema: jsonSchema,
-      zodSchema: inputSchema72,
+      zodSchema: inputSchema82,
       handler: wrappedHandler,
       annotations: finalAnnotations
     };
@@ -2490,7 +3192,7 @@ function registerTool(definition, handler, options = {}) {
   }
 }
 function getRegisteredTools() {
-  return Array.from(registeredTools.values()).map((tool) => ({
+  return Array.from(registeredTools.values()).filter((tool) => isToolEnabled(tool.name)).map((tool) => ({
     name: tool.name,
     description: `${tool.title}: ${tool.description}`,
     inputSchema: tool.inputSchema,
@@ -2500,6 +3202,32 @@ function getRegisteredTools() {
 function getToolByName(name) {
   return registeredTools.get(name);
 }
+function getToolNames() {
+  return Array.from(registeredTools.keys());
+}
+function enableTool(name) {
+  const tool = registeredTools.get(name);
+  if (!tool) {
+    log.debug(`Cannot enable tool: ${name} not found`);
+    return false;
+  }
+  toolEnabledState.set(name, true);
+  log.debug(`Tool enabled: ${name}`);
+  return true;
+}
+function disableTool(name) {
+  const tool = registeredTools.get(name);
+  if (!tool) {
+    log.debug(`Cannot disable tool: ${name} not found`);
+    return false;
+  }
+  toolEnabledState.set(name, false);
+  log.debug(`Tool disabled: ${name}`);
+  return true;
+}
+function isToolEnabled(name) {
+  return toolEnabledState.get(name) ?? true;
+}
 function createHandlerWithContext(contextAwareHandler) {
   return async (params) => {
     const client = await getShopifyClient();
@@ -12466,143 +13194,995 @@ var handleSetCollectionMetafields = async (context, params) => {
 function registerSetCollectionMetafieldsTool() {
   registerContextAwareTool(
     {
-      name: "set-collection-metafields",
-      title: "Set Collection Metafields",
-      description: "Create or update up to 25 metafields on a collection in a single operation. Each metafield requires: namespace (grouping identifier), key (field name), value (the data), and type. Existing metafields with matching namespace+key are updated; new ones are created. Common types: single_line_text_field, multi_line_text_field, number_integer, number_decimal, boolean, json. **Typical workflow:** list-collections \u2192 set-collection-metafields (add custom data). **Prerequisites:** list-collections to obtain collection ID, optionally get-collection-metafields to check existing values. **Follow-ups:** get-collection-metafields to verify changes.",
-      inputSchema: inputSchema69,
-      outputSchema: outputSchema69,
-      // AI Agent Optimization (Story 5.5)
-      category: "collection",
+      name: "set-collection-metafields",
+      title: "Set Collection Metafields",
+      description: "Create or update up to 25 metafields on a collection in a single operation. Each metafield requires: namespace (grouping identifier), key (field name), value (the data), and type. Existing metafields with matching namespace+key are updated; new ones are created. Common types: single_line_text_field, multi_line_text_field, number_integer, number_decimal, boolean, json. **Typical workflow:** list-collections \u2192 set-collection-metafields (add custom data). **Prerequisites:** list-collections to obtain collection ID, optionally get-collection-metafields to check existing values. **Follow-ups:** get-collection-metafields to verify changes.",
+      inputSchema: inputSchema69,
+      outputSchema: outputSchema69,
+      // AI Agent Optimization (Story 5.5)
+      category: "collection",
+      relationships: {
+        relatedTools: [
+          "list-collections",
+          "get-collection-metafields",
+          "delete-collection-metafields"
+        ],
+        prerequisites: ["list-collections"],
+        followUps: ["get-collection-metafields"]
+      },
+      // MCP Tool Annotations (Epic 9.5 - MCP Best Practices) - AC-10.6.6
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleSetCollectionMetafields
+  );
+}
+
+// src/tools/submit-redirect-import.ts
+import { z as z72 } from "zod";
+var inputSchema70 = z72.object({
+  id: z72.string().min(1).describe(
+    'Import ID from import-redirects tool (GID format, e.g., "gid://shopify/UrlRedirectImport/123"). This is required to submit the import job for processing.'
+  )
+});
+var outputSchema70 = z72.object({
+  id: z72.string().describe("Job GID for tracking the import operation"),
+  done: z72.boolean().describe("Whether the job has completed. May be false if still processing.")
+});
+var handleSubmitRedirectImport = async (context, params) => {
+  log.debug(`Submitting redirect import on shop: ${context.shopDomain}, id: ${params.id}`);
+  if (!params.id || params.id.trim() === "") {
+    throw new ToolError(
+      "Import ID is required.",
+      "Use import-redirects first to create an import job and get its ID."
+    );
+  }
+  try {
+    const job = await submitRedirectImport(params.id);
+    log.debug(`Redirect import job submitted: ${job.id}, done: ${job.done}`);
+    return job;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("not found")) {
+      throw new ToolError(
+        `Import not found (ID: ${params.id})`,
+        "Verify the import ID is correct. Use import-redirects to create a new import if needed."
+      );
+    }
+    if (error instanceof Error && error.message.includes("already submitted")) {
+      throw new ToolError(
+        "This import has already been submitted.",
+        "Each import can only be submitted once. Create a new import with import-redirects if needed."
+      );
+    }
+    throw error;
+  }
+};
+function registerSubmitRedirectImportTool() {
+  registerContextAwareTool(
+    {
+      name: "submit-redirect-import",
+      title: "Submit Redirect Import",
+      description: `Submit a redirect import job for processing. This is the second step in a two-step import workflow. Requires an import ID from the import-redirects tool. The import runs asynchronously in Shopify's background. The job may not be complete when the response returns - check the "done" field to see if processing has finished. **Typical workflow:** import-redirects (create & preview) \u2192 submit-redirect-import (execute). **Prerequisites:** import-redirects to create the import job and get its ID. **Note:** Each import can only be submitted once.`,
+      inputSchema: inputSchema70,
+      outputSchema: outputSchema70,
+      // AI Agent Optimization (Story 5.5)
+      category: "seo",
+      relationships: {
+        relatedTools: ["import-redirects", "list-redirects"],
+        prerequisites: ["import-redirects"],
+        followUps: ["list-redirects"]
+      },
+      // MCP Tool Annotations (Epic 9.5 - MCP Best Practices) - AC-10.6.6
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    handleSubmitRedirectImport
+  );
+}
+
+// src/tools/get-store-alerts.ts
+import { z as z73 } from "zod";
+var inputSchema71 = z73.object({});
+var outputSchema71 = z73.object({
+  alerts: z73.array(
+    z73.object({
+      action: z73.object({
+        title: z73.string().describe('The text for the button in the alert (e.g., "Add credit card")'),
+        url: z73.string().describe("The target URL that the button links to")
+      }).describe("Action to resolve the alert"),
+      description: z73.string().describe("Human-readable alert description")
+    })
+  ).describe("Array of active admin alerts"),
+  setupRequired: z73.boolean().describe("Whether store setup is incomplete")
+});
+async function handleGetStoreAlerts(context, _params) {
+  log.debug(`Getting store alerts for shop: ${context.shopDomain}`);
+  return await getStoreAlerts();
+}
+function registerGetStoreAlertsTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-alerts",
+      title: "Get Store Alerts",
+      description: "Get active admin alerts and setup requirements for the connected Shopify store. **Prerequisites:** None. **Use this** to proactively identify issues needing merchant attention.",
+      inputSchema: inputSchema71,
+      outputSchema: outputSchema71,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "list-low-inventory"],
+        followUps: []
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreAlerts
+  );
+}
+
+// src/tools/get-store-currencies.ts
+import { z as z74 } from "zod";
+var inputSchema72 = z74.object({});
+var outputSchema72 = z74.object({
+  currencyCode: z74.string().describe("Base currency code (e.g., USD)"),
+  enabledPresentmentCurrencies: z74.array(z74.string()).describe("Enabled multi-currency codes"),
+  currencyFormats: z74.object({
+    moneyFormat: z74.string().describe("Money format pattern (e.g., ${{amount}})"),
+    moneyWithCurrencyFormat: z74.string().describe("Money with currency format (e.g., ${{amount}} USD)")
+  }).describe("Currency format patterns")
+});
+async function handleGetStoreCurrencies(context, _params) {
+  log.debug(`Getting store currencies for shop: ${context.shopDomain}`);
+  return await getStoreCurrencies();
+}
+function registerGetStoreCurrenciesTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-currencies",
+      title: "Get Store Currencies",
+      description: "Get currency configuration for the connected Shopify store including base currency, enabled presentment currencies, and money format patterns. **Prerequisites:** None. **Use this** to understand multi-currency setup.",
+      inputSchema: inputSchema72,
+      outputSchema: outputSchema72,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-limits"],
+        followUps: ["list-markets", "list-products"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreCurrencies
+  );
+}
+
+// src/tools/get-store-domain.ts
+import { z as z75 } from "zod";
+var inputSchema73 = z75.object({});
+var outputSchema73 = z75.object({
+  primaryDomain: z75.object({
+    host: z75.string().describe('Domain hostname (e.g., "mystore.com")'),
+    url: z75.string().describe('Full domain URL (e.g., "https://mystore.com")'),
+    sslEnabled: z75.boolean().describe("Whether SSL is enabled")
+  })
+});
+async function handleGetStoreDomain(context, _params) {
+  log.debug(`Getting store domain for shop: ${context.shopDomain}`);
+  return await getStoreDomain();
+}
+function registerGetStoreDomainTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-domain",
+      title: "Get Store Domain",
+      description: "Get primary domain configuration for the connected Shopify store including hostname, URL, and SSL status. **Prerequisites:** None. **Use this** to construct proper URLs and understand store identity.",
+      inputSchema: inputSchema73,
+      outputSchema: outputSchema73,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-shipping"],
+        followUps: ["create-redirect"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreDomain
+  );
+}
+
+// src/tools/get-store-features.ts
+import { z as z76 } from "zod";
+var inputSchema74 = z76.object({});
+var outputSchema74 = z76.object({
+  giftCards: z76.boolean().describe("Gift cards enabled"),
+  reports: z76.boolean().describe("Reports enabled"),
+  storefront: z76.boolean().describe("Storefront enabled"),
+  bundles: z76.object({
+    eligibleForBundles: z76.boolean().describe("Whether store is eligible for bundles")
+  }).describe("Bundles feature configuration"),
+  sellsSubscriptions: z76.boolean().describe("Subscriptions enabled")
+});
+async function handleGetStoreFeatures(context, _params) {
+  log.debug(`Getting store features for shop: ${context.shopDomain}`);
+  return await getStoreFeatures();
+}
+function registerGetStoreFeaturesTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-features",
+      title: "Get Store Features",
+      description: "Get feature flags for the connected Shopify store including gift cards, reports, storefront, bundles eligibility, and subscriptions. **Prerequisites:** None. **Use this** to determine available store capabilities.",
+      inputSchema: inputSchema74,
+      outputSchema: outputSchema74,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-limits"],
+        followUps: ["list-products", "list-collections"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreFeatures
+  );
+}
+
+// src/tools/get-store-info.ts
+import { z as z77 } from "zod";
+var inputSchema75 = z77.object({});
+var outputSchema75 = z77.object({
+  name: z77.string().describe("Store name"),
+  domain: z77.string().describe("Store domain (without .myshopify.com)"),
+  myshopifyDomain: z77.string().describe("Full myshopify.com domain"),
+  plan: z77.object({
+    displayName: z77.string().describe("Current plan name"),
+    partnerDevelopment: z77.boolean().describe("Whether partner development store")
+  }).describe("Store plan details"),
+  currencyCode: z77.string().describe("Store currency code (e.g., USD, EUR)"),
+  timezone: z77.string().describe("Store IANA timezone"),
+  contactEmail: z77.string().describe("Store contact email")
+});
+async function handleGetStoreInfo(context, _params) {
+  log.debug(`Getting store info for shop: ${context.shopDomain}`);
+  return await getStoreInfo();
+}
+function registerGetStoreInfoTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-info",
+      title: "Get Store Info",
+      description: "Get basic information about the connected Shopify store including name, domain, plan, currency, timezone, and contact email. **Prerequisites:** None. **Use this** to understand store context before performing operations.",
+      inputSchema: inputSchema75,
+      outputSchema: outputSchema75,
+      category: "store",
+      relationships: {
+        relatedTools: [],
+        followUps: ["list-products", "list-collections"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreInfo
+  );
+}
+
+// src/tools/get-store-limits.ts
+import { z as z78 } from "zod";
+var inputSchema76 = z78.object({});
+var outputSchema76 = z78.object({
+  maxProductVariants: z78.number().describe("Maximum variants per product"),
+  maxProductOptions: z78.number().describe("Maximum product options"),
+  locationLimit: z78.number().describe("Maximum locations"),
+  redirectLimitReached: z78.boolean().describe("Whether redirect limit is reached")
+});
+async function handleGetStoreLimits(context, _params) {
+  log.debug(`Getting store limits for shop: ${context.shopDomain}`);
+  return await getStoreLimits();
+}
+function registerGetStoreLimitsTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-limits",
+      title: "Get Store Limits",
+      description: "Get resource limits for the connected Shopify store including max product variants, max product options, location limit, and redirect limit status. **Prerequisites:** None. **Use this** to validate operations against store constraints.",
+      inputSchema: inputSchema76,
+      outputSchema: outputSchema76,
+      category: "store",
       relationships: {
-        relatedTools: [
-          "list-collections",
-          "get-collection-metafields",
-          "delete-collection-metafields"
-        ],
-        prerequisites: ["list-collections"],
-        followUps: ["get-collection-metafields"]
+        relatedTools: ["get-store-info", "get-store-features"],
+        followUps: ["list-products", "create-product"]
       },
-      // MCP Tool Annotations (Epic 9.5 - MCP Best Practices) - AC-10.6.6
       annotations: {
-        readOnlyHint: false,
+        readOnlyHint: true,
         destructiveHint: false,
         idempotentHint: true,
         openWorldHint: true
       }
     },
-    handleSetCollectionMetafields
+    handleGetStoreLimits
   );
 }
 
-// src/tools/submit-redirect-import.ts
-import { z as z72 } from "zod";
-var inputSchema70 = z72.object({
-  id: z72.string().min(1).describe(
-    'Import ID from import-redirects tool (GID format, e.g., "gid://shopify/UrlRedirectImport/123"). This is required to submit the import job for processing.'
-  )
+// src/tools/get-store-policies.ts
+import { z as z79 } from "zod";
+var inputSchema77 = z79.object({});
+var outputSchema77 = z79.object({
+  shopPolicies: z79.array(
+    z79.object({
+      title: z79.string().describe('Policy title (e.g., "Privacy Policy")'),
+      type: z79.string().describe('Policy type (e.g., "PRIVACY_POLICY")'),
+      url: z79.string().describe("Full URL to the policy page")
+    })
+  ).describe("Array of store policy items (empty if scope unavailable)")
 });
-var outputSchema70 = z72.object({
-  id: z72.string().describe("Job GID for tracking the import operation"),
-  done: z72.boolean().describe("Whether the job has completed. May be false if still processing.")
+async function handleGetStorePolicies(context, _params) {
+  log.debug(`Getting store policies for shop: ${context.shopDomain}`);
+  return await getStorePolicies();
+}
+function registerGetStorePoliciesTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-policies",
+      title: "Get Store Policies",
+      description: "Get legal policies for the connected Shopify store (privacy policy, terms of service, refund policy). Returns empty array if read_legal_policies scope is not available. **Prerequisites:** None. **Use this** to reference store policies in customer communications.",
+      inputSchema: inputSchema77,
+      outputSchema: outputSchema77,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-domain"],
+        followUps: []
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStorePolicies
+  );
+}
+
+// src/tools/get-store-shipping.ts
+import { z as z80 } from "zod";
+var inputSchema78 = z80.object({});
+var outputSchema78 = z80.object({
+  shipsToCountries: z80.array(z80.string()).describe("Countries the store ships to"),
+  countriesInShippingZones: z80.object({
+    countryCodes: z80.array(z80.string()).describe("Countries with configured shipping zones")
+  })
 });
-var handleSubmitRedirectImport = async (context, params) => {
-  log.debug(`Submitting redirect import on shop: ${context.shopDomain}, id: ${params.id}`);
-  if (!params.id || params.id.trim() === "") {
+async function handleGetStoreShipping(context, _params) {
+  log.debug(`Getting store shipping for shop: ${context.shopDomain}`);
+  return await getStoreShipping();
+}
+function registerGetStoreShippingTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-shipping",
+      title: "Get Store Shipping",
+      description: "Get shipping configuration for the connected Shopify store including ships-to countries and countries with configured shipping zones. **Prerequisites:** None. **Use this** to understand international shipping capabilities.",
+      inputSchema: inputSchema78,
+      outputSchema: outputSchema78,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-domain", "list-markets"],
+        followUps: ["get-store-domain"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreShipping
+  );
+}
+
+// src/tools/get-store-taxes.ts
+import { z as z81 } from "zod";
+var inputSchema79 = z81.object({});
+var outputSchema79 = z81.object({
+  taxesIncluded: z81.boolean().describe("Whether taxes are included in product prices"),
+  taxShipping: z81.boolean().describe("Whether shipping is taxed")
+});
+async function handleGetStoreTaxes(context, _params) {
+  log.debug(`Getting store taxes for shop: ${context.shopDomain}`);
+  return await getStoreTaxes();
+}
+function registerGetStoreTaxesTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-taxes",
+      title: "Get Store Taxes",
+      description: "Get tax configuration for the connected Shopify store including whether taxes are included in prices and tax shipping settings. **Prerequisites:** None. **Use this** to understand pricing structure for tax calculations.",
+      inputSchema: inputSchema79,
+      outputSchema: outputSchema79,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-currencies"],
+        followUps: []
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreTaxes
+  );
+}
+
+// src/tools/list-modules.ts
+import { z as z83 } from "zod";
+
+// src/tools/modules/registry.ts
+var CORE_MODULE = {
+  name: "core",
+  description: "Essential product and inventory management tools. Includes product CRUD, variants, basic images, inventory operations, and store info. Always loaded at startup.",
+  alwaysLoaded: true,
+  dependencies: [],
+  tools: [
+    // Products (7)
+    "create-product",
+    "get-product",
+    "update-product",
+    "delete-product",
+    "list-products",
+    "update-product-variant",
+    "add-product-image",
+    // Inventory (4)
+    "get-inventory",
+    "update-inventory",
+    "list-low-inventory",
+    "get-bulk-inventory",
+    // Store Info (2)
+    "get-store-info",
+    "get-store-limits",
+    // Meta Tools (2) - Added by this story
+    "list-modules",
+    "load-module"
+  ]
+};
+var STORE_CONTEXT_MODULE = {
+  name: "store-context",
+  description: "Extended store configuration and context tools. Includes features, currencies, shipping countries, domain, taxes, policies, and alerts. Use for comprehensive store insights.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    "get-store-features",
+    "get-store-currencies",
+    "get-store-shipping",
+    "get-store-domain",
+    "get-store-taxes",
+    "get-store-policies",
+    "get-store-alerts"
+  ]
+};
+var COLLECTIONS_MODULE = {
+  name: "collections",
+  description: "Product collection management tools. Includes collection CRUD, adding/removing products, and collection metafields. Use for organizing products and SEO.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    // CRUD (7)
+    "list-collections",
+    "get-collection",
+    "create-collection",
+    "update-collection",
+    "delete-collection",
+    "add-products-to-collection",
+    "remove-products-from-collection",
+    // Metafields (3)
+    "get-collection-metafields",
+    "set-collection-metafields",
+    "delete-collection-metafields"
+  ]
+};
+var PRODUCT_EXTENSIONS_MODULE = {
+  name: "product-extensions",
+  description: "Extended product management tools. Includes product metafields, advanced image operations (update, delete, reorder), and URL redirects for SEO.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    // Metafields (3)
+    "get-product-metafields",
+    "set-product-metafields",
+    "delete-product-metafields",
+    // Images (3)
+    "update-product-image",
+    "delete-product-image",
+    "reorder-product-images",
+    // Redirects (3)
+    "create-redirect",
+    "list-redirects",
+    "delete-redirect"
+  ]
+};
+var CONTENT_MODULE = {
+  name: "content",
+  description: "Content management tools for pages, blogs, and articles. Includes CRUD operations and metafields for all content types. Use for content marketing and SEO.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    // Pages (8)
+    "list-pages",
+    "get-page",
+    "create-page",
+    "update-page",
+    "delete-page",
+    "get-page-metafields",
+    "set-page-metafields",
+    "delete-page-metafields",
+    // Blogs (7)
+    "list-blogs",
+    "create-blog",
+    "update-blog",
+    "delete-blog",
+    "get-blog-metafields",
+    "set-blog-metafields",
+    "delete-blog-metafields",
+    // Articles (7)
+    "list-articles",
+    "create-article",
+    "update-article",
+    "delete-article",
+    "get-article-metafields",
+    "set-article-metafields",
+    "delete-article-metafields"
+  ]
+};
+var INTERNATIONAL_MODULE = {
+  name: "international",
+  description: "International commerce and localization tools. Includes markets management, web presence configuration, and shop locale translations. Use for multi-region and multi-language stores.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    // Markets (5)
+    "list-markets",
+    "get-market",
+    "create-market",
+    "update-market",
+    "delete-market",
+    // Web Presence (4)
+    "list-web-presences",
+    "create-web-presence",
+    "update-web-presence",
+    "delete-web-presence",
+    // Translations (5)
+    "list-shop-locales",
+    "enable-shop-locale",
+    "disable-shop-locale",
+    "register-translations",
+    "remove-translations"
+  ]
+};
+var ADVANCED_REDIRECTS_MODULE = {
+  name: "advanced-redirects",
+  description: "Bulk URL redirect operations for large-scale SEO management. Includes bulk delete, delete by search, and import capabilities. Requires product-extensions module.",
+  alwaysLoaded: false,
+  dependencies: ["product-extensions"],
+  tools: [
+    "bulk-delete-redirects",
+    "bulk-delete-redirects-by-search",
+    "import-redirects",
+    "submit-redirect-import"
+  ]
+};
+var MODULE_DEFINITIONS = [
+  CORE_MODULE,
+  STORE_CONTEXT_MODULE,
+  COLLECTIONS_MODULE,
+  PRODUCT_EXTENSIONS_MODULE,
+  CONTENT_MODULE,
+  INTERNATIONAL_MODULE,
+  ADVANCED_REDIRECTS_MODULE
+];
+var registry = null;
+function initializeRegistry() {
+  const modules = /* @__PURE__ */ new Map();
+  const loadedModules = /* @__PURE__ */ new Set();
+  const toolModuleMap = /* @__PURE__ */ new Map();
+  for (const module of MODULE_DEFINITIONS) {
+    modules.set(module.name, module);
+    if (module.alwaysLoaded) {
+      loadedModules.add(module.name);
+    }
+    for (const toolName of module.tools) {
+      toolModuleMap.set(toolName, module.name);
+    }
+  }
+  registry = {
+    modules,
+    loadedModules,
+    toolModuleMap
+  };
+  log.debug(
+    `Module registry initialized: ${modules.size} modules, ${toolModuleMap.size} tools mapped`
+  );
+  return registry;
+}
+function getRegistry() {
+  if (!registry) {
+    return initializeRegistry();
+  }
+  return registry;
+}
+function getModule(name) {
+  return getRegistry().modules.get(name);
+}
+function isModuleLoaded(name) {
+  return getRegistry().loadedModules.has(name);
+}
+function getModuleForTool(toolName) {
+  return getRegistry().toolModuleMap.get(toolName);
+}
+function getLoadedModules() {
+  return Array.from(getRegistry().loadedModules);
+}
+function markModuleLoaded(name) {
+  getRegistry().loadedModules.add(name);
+  log.debug(`Module marked as loaded: ${name}`);
+}
+function getToolsForModule(moduleName) {
+  const module = getModule(moduleName);
+  return module ? module.tools : [];
+}
+
+// src/tools/modules/loading.ts
+async function loadModule(moduleName) {
+  log.debug(`Loading module: ${moduleName}`);
+  const module = getModule(moduleName);
+  if (!module) {
+    const availableModules = Array.from(getRegistry().modules.keys()).join(", ");
     throw new ToolError(
-      "Import ID is required.",
-      "Use import-redirects first to create an import job and get its ID."
+      `Module '${moduleName}' not found. Available modules: ${availableModules}`,
+      `Use list-modules to see available modules. Valid options: ${availableModules}`
     );
   }
-  try {
-    const job = await submitRedirectImport(params.id);
-    log.debug(`Redirect import job submitted: ${job.id}, done: ${job.done}`);
-    return job;
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("not found")) {
-      throw new ToolError(
-        `Import not found (ID: ${params.id})`,
-        "Verify the import ID is correct. Use import-redirects to create a new import if needed."
-      );
+  if (isModuleLoaded(moduleName)) {
+    log.debug(`Module already loaded: ${moduleName}`);
+    return {
+      success: true,
+      moduleName,
+      toolsLoaded: 0,
+      tools: [],
+      dependenciesLoaded: []
+    };
+  }
+  const dependenciesLoaded = [];
+  const allLoadedTools = [];
+  for (const depName of module.dependencies) {
+    if (!isModuleLoaded(depName)) {
+      log.debug(`Loading dependency: ${depName} for ${moduleName}`);
+      const depResult = await loadModule(depName);
+      if (depResult.success && depResult.toolsLoaded > 0) {
+        dependenciesLoaded.push(depName);
+        allLoadedTools.push(...depResult.tools);
+        if (depResult.dependenciesLoaded.length > 0) {
+          dependenciesLoaded.push(...depResult.dependenciesLoaded);
+        }
+      }
     }
-    if (error instanceof Error && error.message.includes("already submitted")) {
-      throw new ToolError(
-        "This import has already been submitted.",
-        "Each import can only be submitted once. Create a new import with import-redirects if needed."
-      );
+  }
+  markModuleLoaded(moduleName);
+  for (const toolName of module.tools) {
+    enableTool(toolName);
+  }
+  const result = {
+    success: true,
+    moduleName,
+    toolsLoaded: module.tools.length,
+    tools: [...module.tools],
+    dependenciesLoaded
+  };
+  log.debug(
+    `Module loaded: ${moduleName} (${result.toolsLoaded} tools, ${dependenciesLoaded.length} dependencies)`
+  );
+  return result;
+}
+async function loadModules(moduleNames) {
+  const results = [];
+  for (const moduleName of moduleNames) {
+    try {
+      const result = await loadModule(moduleName);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        success: false,
+        moduleName,
+        toolsLoaded: 0,
+        tools: [],
+        dependenciesLoaded: [],
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
     }
-    throw error;
   }
-};
-function registerSubmitRedirectImportTool() {
+  return results;
+}
+function getModuleStatus() {
+  const registry2 = getRegistry();
+  const modules = Array.from(registry2.modules.values()).map((module) => ({
+    name: module.name,
+    description: module.description,
+    toolCount: module.tools.length,
+    loaded: registry2.loadedModules.has(module.name),
+    dependencies: module.dependencies,
+    tools: module.tools
+  }));
+  let totalTools = 0;
+  let loadedTools = 0;
+  for (const module of modules) {
+    totalTools += module.toolCount;
+    if (module.loaded) {
+      loadedTools += module.toolCount;
+    }
+  }
+  return {
+    modules,
+    summary: {
+      totalModules: modules.length,
+      loadedModules: getLoadedModules().length,
+      totalTools,
+      loadedTools
+    }
+  };
+}
+
+// src/tools/modules/types.ts
+import { z as z82 } from "zod";
+var ToolModuleSchema = z82.object({
+  /** Unique module identifier (kebab-case) */
+  name: z82.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, {
+    message: "Module name must be kebab-case"
+  }),
+  /** Human-readable description for AI discovery */
+  description: z82.string().min(10, {
+    message: "Description must be at least 10 characters"
+  }),
+  /** Whether this module is loaded at server startup */
+  alwaysLoaded: z82.boolean().default(false),
+  /** Module names that must be loaded before this module */
+  dependencies: z82.array(z82.string()).default([]),
+  /** Tool names belonging to this module */
+  tools: z82.array(z82.string())
+});
+var LOADABLE_MODULE_NAMES = [
+  "store-context",
+  "collections",
+  "product-extensions",
+  "content",
+  "international",
+  "advanced-redirects"
+];
+var ALL_MODULE_NAMES = ["core", ...LOADABLE_MODULE_NAMES];
+var ModuleInfoSchema = z82.object({
+  name: z82.string(),
+  description: z82.string(),
+  toolCount: z82.number().int().nonnegative(),
+  loaded: z82.boolean(),
+  dependencies: z82.array(z82.string()),
+  tools: z82.array(z82.string())
+});
+var ModuleSummarySchema = z82.object({
+  totalModules: z82.number().int().nonnegative(),
+  loadedModules: z82.number().int().nonnegative(),
+  totalTools: z82.number().int().nonnegative(),
+  loadedTools: z82.number().int().nonnegative()
+});
+var ListModulesResponseSchema = z82.object({
+  modules: z82.array(ModuleInfoSchema),
+  summary: ModuleSummarySchema
+});
+var ModuleLoadResultSchema = z82.object({
+  success: z82.boolean(),
+  moduleName: z82.string(),
+  toolsLoaded: z82.number().int().nonnegative(),
+  tools: z82.array(z82.string()),
+  dependenciesLoaded: z82.array(z82.string()),
+  error: z82.string().optional()
+});
+
+// src/tools/list-modules.ts
+var inputSchema80 = z83.object({});
+async function handleListModules(_context, _params) {
+  log.debug("Listing available modules");
+  const status = getModuleStatus();
+  log.debug(
+    `Modules listed: ${status.summary.loadedModules}/${status.summary.totalModules} loaded, ${status.summary.loadedTools}/${status.summary.totalTools} tools available`
+  );
+  return status;
+}
+function registerListModulesTool() {
   registerContextAwareTool(
     {
-      name: "submit-redirect-import",
-      title: "Submit Redirect Import",
-      description: `Submit a redirect import job for processing. This is the second step in a two-step import workflow. Requires an import ID from the import-redirects tool. The import runs asynchronously in Shopify's background. The job may not be complete when the response returns - check the "done" field to see if processing has finished. **Typical workflow:** import-redirects (create & preview) \u2192 submit-redirect-import (execute). **Prerequisites:** import-redirects to create the import job and get its ID. **Note:** Each import can only be submitted once.`,
-      inputSchema: inputSchema70,
-      outputSchema: outputSchema70,
-      // AI Agent Optimization (Story 5.5)
-      category: "seo",
+      name: "list-modules",
+      title: "List Available Modules",
+      description: "List all available tool modules and their loading status. Shows module names, descriptions, tool counts, dependencies, and whether each module is loaded. Use this to discover which modules can be loaded to extend functionality. **Note:** The core module is always loaded with essential product and inventory tools.",
+      inputSchema: inputSchema80,
+      outputSchema: ListModulesResponseSchema,
+      category: "store",
       relationships: {
-        relatedTools: ["import-redirects", "list-redirects"],
-        prerequisites: ["import-redirects"],
-        followUps: ["list-redirects"]
+        relatedTools: ["load-module"],
+        followUps: ["load-module"]
       },
-      // MCP Tool Annotations (Epic 9.5 - MCP Best Practices) - AC-10.6.6
       annotations: {
-        readOnlyHint: false,
+        readOnlyHint: true,
         destructiveHint: false,
-        idempotentHint: false,
-        openWorldHint: true
+        idempotentHint: true,
+        // Does NOT call Shopify API - internal state only
+        openWorldHint: false
       }
     },
-    handleSubmitRedirectImport
+    handleListModules
   );
 }
 
-// src/tools/get-store-info.ts
-import { z as z73 } from "zod";
-var inputSchema71 = z73.object({});
-var outputSchema71 = z73.object({
-  name: z73.string().describe("Store name"),
-  domain: z73.string().describe("Store domain (without .myshopify.com)"),
-  myshopifyDomain: z73.string().describe("Full myshopify.com domain"),
-  plan: z73.object({
-    displayName: z73.string().describe("Current plan name"),
-    partnerDevelopment: z73.boolean().describe("Whether partner development store")
-  }).describe("Store plan details"),
-  currencyCode: z73.string().describe("Store currency code (e.g., USD, EUR)"),
-  timezone: z73.string().describe("Store IANA timezone"),
-  contactEmail: z73.string().describe("Store contact email")
+// src/tools/load-module.ts
+import { z as z84 } from "zod";
+var inputSchema81 = z84.object({
+  module: z84.enum(LOADABLE_MODULE_NAMES).describe(
+    "Name of the module to load. Options: store-context, collections, product-extensions, content, international, advanced-redirects"
+  )
 });
-async function handleGetStoreInfo(context, _params) {
-  log.debug(`Getting store info for shop: ${context.shopDomain}`);
-  return await getStoreInfo();
+async function handleLoadModule(_context, params) {
+  log.debug(`Loading module: ${params.module}`);
+  const result = await loadModule(params.module);
+  if (result.success) {
+    if (result.toolsLoaded > 0) {
+      log.debug(
+        `Module ${params.module} loaded: ${result.toolsLoaded} tools, ${result.dependenciesLoaded.length} dependencies`
+      );
+    } else {
+      log.debug(`Module ${params.module} was already loaded`);
+    }
+  }
+  return result;
 }
-function registerGetStoreInfoTool() {
+function registerLoadModuleTool() {
   registerContextAwareTool(
     {
-      name: "get-store-info",
-      title: "Get Store Info",
-      description: "Get basic information about the connected Shopify store including name, domain, plan, currency, timezone, and contact email. **Prerequisites:** None. **Use this** to understand store context before performing operations.",
-      inputSchema: inputSchema71,
-      outputSchema: outputSchema71,
+      name: "load-module",
+      title: "Load Tool Module",
+      description: "Load a tool module to enable additional tools for a specific domain. Dependencies are automatically loaded. Use list-modules to see available modules. **Available modules:** store-context (store configuration), collections (product organization), product-extensions (metafields, images, redirects), content (pages, blogs, articles), international (markets, translations), advanced-redirects (bulk operations). **Note:** Once loaded, modules remain available for the session.",
+      inputSchema: inputSchema81,
+      outputSchema: ModuleLoadResultSchema,
       category: "store",
       relationships: {
-        relatedTools: [],
-        followUps: ["list-products", "list-collections"]
+        prerequisites: ["list-modules"],
+        relatedTools: ["list-modules"]
       },
       annotations: {
-        readOnlyHint: true,
+        // Not read-only: changes internal tool availability state
+        readOnlyHint: false,
         destructiveHint: false,
+        // Idempotent: loading same module twice returns success
         idempotentHint: true,
-        openWorldHint: true
+        // Does NOT call Shopify API - internal state only
+        openWorldHint: false
       }
     },
-    handleGetStoreInfo
+    handleLoadModule
   );
 }
 
+// src/tools/modules/presets.ts
+import { z as z85 } from "zod";
+var RolePresetSchema = z85.object({
+  description: z85.string(),
+  modules: z85.array(z85.string())
+});
+var ROLE_PRESETS = {
+  "inventory-manager": {
+    description: "Stock management and inventory operations",
+    modules: ["core"]
+  },
+  "product-manager": {
+    description: "Full product catalog management",
+    modules: ["core", "store-context", "collections", "product-extensions"]
+  },
+  "content-manager": {
+    description: "Pages, blogs, and content marketing",
+    modules: ["core", "content"]
+  },
+  "seo-specialist": {
+    description: "SEO optimization and URL management",
+    modules: ["core", "collections", "product-extensions", "advanced-redirects"]
+  },
+  "international-manager": {
+    description: "Multi-market and translation management",
+    modules: ["core", "store-context", "international", "collections"]
+  },
+  "full-access": {
+    description: "All tools for store administrators",
+    modules: [
+      "core",
+      "store-context",
+      "collections",
+      "product-extensions",
+      "content",
+      "international",
+      "advanced-redirects"
+    ]
+  }
+};
+var VALID_ROLE_NAMES = Object.keys(ROLE_PRESETS);
+function isValidRoleName(name) {
+  return name in ROLE_PRESETS;
+}
+function getPresetModules(role) {
+  return [...ROLE_PRESETS[role].modules];
+}
+
+// src/tools/suggestions.ts
+var TOOL_SUGGESTIONS = {
+  // Product tools → suggest product-extensions and collections
+  "create-product": [
+    { name: "product-extensions", reason: "Add metafields, manage images" },
+    { name: "collections", reason: "Organize in collections" }
+  ],
+  "get-product": [{ name: "product-extensions", reason: "View metafields, images" }],
+  "update-product": [
+    { name: "product-extensions", reason: "Update metafields" },
+    { name: "collections", reason: "Manage collection membership" }
+  ],
+  "list-products": [{ name: "collections", reason: "Categorize and filter by collection" }],
+  "delete-product": [
+    { name: "product-extensions", reason: "Check redirects, clean up metafields" }
+  ],
+  "update-product-variant": [{ name: "product-extensions", reason: "Manage variant metafields" }],
+  "add-product-image": [{ name: "product-extensions", reason: "Reorder images, update alt text" }],
+  // Inventory tools → suggest store-context for location info
+  "get-inventory": [{ name: "store-context", reason: "Location information" }],
+  "update-inventory": [{ name: "store-context", reason: "Location details" }],
+  "list-low-inventory": [{ name: "store-context", reason: "Location context" }],
+  "get-bulk-inventory": [{ name: "store-context", reason: "Location information" }],
+  // Store info tools → suggest store-context for full configuration
+  "get-store-info": [{ name: "store-context", reason: "Full store configuration" }],
+  "get-store-limits": [{ name: "store-context", reason: "Additional store details" }]
+};
+function getSuggestionsForTool(toolName) {
+  const suggestions = TOOL_SUGGESTIONS[toolName];
+  if (!suggestions || suggestions.length === 0) {
+    return null;
+  }
+  const unloadedSuggestions = suggestions.filter((s) => !isModuleLoaded(s.name));
+  if (unloadedSuggestions.length === 0) {
+    return null;
+  }
+  return {
+    modules: unloadedSuggestions,
+    hint: "Use load-module to enable these tools"
+  };
+}
+
 // src/tools/index.ts
 function setupToolHandlers(server) {
   server.server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -12638,8 +14218,42 @@ Suggestion: Use tools/list to see available tools. ${toolList}`
         isError: true
       };
     }
+    if (!isToolEnabled(name)) {
+      const moduleName = getModuleForTool(name);
+      const suggestion = moduleName ? `Load the '${moduleName}' module first: use load-module with module: "${moduleName}"` : "This tool is currently disabled. Use list-modules to see available modules.";
+      log.debug(`Tool "${name}" is disabled, suggesting module: ${moduleName || "unknown"}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Tool "${name}" is not currently loaded.
+
+Suggestion: ${suggestion}`
+          }
+        ],
+        isError: true
+      };
+    }
     try {
       const response = await tool.handler(params ?? {});
+      const config = getConfig();
+      if (isLazyLoadingEnabled(config) && !response.isError) {
+        const suggestions = getSuggestionsForTool(name);
+        if (suggestions) {
+          const suggestionText = `
+---
+\u{1F4A1} **Related modules available:**
+${suggestions.modules.map((m) => `- **${m.name}**: ${m.reason}`).join("\n")}
+
+_${suggestions.hint}_`;
+          if (Array.isArray(response.content)) {
+            response.content.push({
+              type: "text",
+              text: suggestionText
+            });
+          }
+        }
+      }
       return response;
     } catch (error) {
       log.error(`Unexpected error in tool ${name}:`, error instanceof Error ? error : void 0);
@@ -12659,6 +14273,7 @@ Suggestion: Please try again or contact support if the issue persists.`
 }
 function registerAllTools(server) {
   setupToolHandlers(server);
+  initializeRegistry();
   registerAddProductImageTool();
   registerCreateProductTool();
   registerDeleteProductTool();
@@ -12730,8 +14345,77 @@ function registerAllTools(server) {
   registerImportRedirectsTool();
   registerSubmitRedirectImportTool();
   registerGetStoreInfoTool();
-  const toolCount = getRegisteredTools().length;
-  log.debug(`Tool registration complete: ${toolCount} tools registered`);
+  registerGetStoreLimitsTool();
+  registerGetStoreFeaturesTool();
+  registerGetStoreCurrenciesTool();
+  registerGetStoreShippingTool();
+  registerGetStoreDomainTool();
+  registerGetStoreTaxesTool();
+  registerGetStorePoliciesTool();
+  registerGetStoreAlertsTool();
+  registerListModulesTool();
+  registerLoadModuleTool();
+  const totalToolCount = getToolNames().length;
+  const config = getConfig();
+  if (isLazyLoadingEnabled(config)) {
+    applyLazyLoading();
+    const roleResult = applyRolePreset(config);
+    const enabledCount = getRegisteredTools().length;
+    if (roleResult.applied) {
+      log.info(
+        `Role preset '${roleResult.role}' applied: ${enabledCount} tools active (${roleResult.modulesLoaded.length} modules loaded)`
+      );
+    } else {
+      log.info(
+        `Lazy loading enabled: ${enabledCount} core tools active, ${totalToolCount - enabledCount} tools available via modules`
+      );
+    }
+  } else {
+    log.info(`Lazy loading disabled (legacy mode): ${totalToolCount} tools registered`);
+  }
+}
+function applyLazyLoading() {
+  const coreTools = new Set(getToolsForModule("core"));
+  const allToolNames = getToolNames();
+  let disabledCount = 0;
+  for (const toolName of allToolNames) {
+    if (!coreTools.has(toolName)) {
+      disableTool(toolName);
+      disabledCount++;
+    }
+  }
+  log.debug(`Lazy loading: disabled ${disabledCount} non-core tools`);
+}
+function applyRolePreset(config) {
+  const role = getConfiguredRole(config);
+  if (!role) {
+    return { applied: false, modulesLoaded: [] };
+  }
+  if (!isValidRoleName(role)) {
+    log.warn(
+      `Invalid role preset '${role}'. Valid roles: inventory-manager, product-manager, content-manager, seo-specialist, international-manager, full-access`
+    );
+    return {
+      applied: false,
+      modulesLoaded: [],
+      warning: `Invalid role '${role}' - continuing with core tools only`
+    };
+  }
+  const presetModules = getPresetModules(role);
+  const modulesToLoad = presetModules.filter((m) => m !== "core");
+  if (modulesToLoad.length === 0) {
+    log.debug(`Role preset '${role}' requires only core module`);
+    return { applied: true, role, modulesLoaded: [] };
+  }
+  loadModules(modulesToLoad).then((results) => {
+    const successful = results.filter((r) => r.success).map((r) => r.moduleName);
+    const failed = results.filter((r) => !r.success).map((r) => r.moduleName);
+    if (failed.length > 0) {
+      log.warn(`Role preset '${role}': failed to load modules: ${failed.join(", ")}`);
+    }
+    log.debug(`Role preset '${role}': loaded modules: ${successful.join(", ")}`);
+  });
+  return { applied: true, role, modulesLoaded: modulesToLoad };
 }
 
 // src/transports/stdio.ts