@burdenoff/mcp-libs 2026.627.2 → 2026.627.4

package/dist/modules/ecoimpacthub/index.cjs

@@ -0,0 +1,2042 @@
+'use strict';
+
+var zod = require('zod');
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+
+// src/modules/ecoimpacthub/tools/sites.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// src/core/result.ts
+function jsonResult(data, structured) {
+  const result = {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+  return result;
+}
+function errorResult(message, hint) {
+  const text = hint ? `${message}
+
+Hint: ${hint}` : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/core/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 63;
+function assertSafeName(name, kind) {
+  if (name.length > MAX_TOOL_NAME_LENGTH) {
+    throw new McpInternalError(
+      `Tool name '${name}' exceeds ${MAX_TOOL_NAME_LENGTH} characters (some MCP clients truncate at 64).`
+    );
+  }
+  return name;
+}
+function mcpToolName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpToolName: productName is required");
+  }
+  const name = [productName, ...parts].filter(Boolean).join("_");
+  return assertSafeName(name);
+}
+function mcpResourceUri(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpResourceUri: productName is required");
+  }
+  return `${productName}://${parts.filter(Boolean).join("/")}`;
+}
+function mcpPromptName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpPromptName: productName is required");
+  }
+  return [productName, ...parts].filter(Boolean).join("-");
+}
+
+// src/modules/ecoimpacthub/operations.ts
+var SITE_FIELDS = `
+  id name code description type status region country latitude longitude
+  areaHectares workspaceId createdAt updatedAt
+`;
+var SENSOR_FIELDS = `
+  id name siteId kind status unit hardwareId installedAt lastReadingAt
+  workspaceId createdAt updatedAt
+`;
+var THRESHOLD_FIELDS = `
+  id siteId parameter direction severity minValue maxValue limitValue unit
+  isActive workspaceId createdAt updatedAt
+`;
+var MEASUREMENT_FIELDS = `
+  id siteId sensorId parameter value unit recordedAt source isBreach notes
+  workspaceId createdAt updatedAt
+`;
+var SPECIES_FIELDS = `
+  id commonName scientificName taxonGroup conservationStatus isPriority
+  description workspaceId createdAt updatedAt
+`;
+var OBSERVATION_FIELDS = `
+  id speciesId siteId observerId observedAt method count latitude longitude
+  notes evidence { id } workspaceId createdAt updatedAt
+`;
+var RESTORATION_ACTIVITY_FIELDS = `
+  id projectId type summary details performedAt quantity unit workspaceId
+  createdAt updatedAt
+`;
+var HABITAT_PROJECT_FIELDS = `
+  id name description siteId managerId status targetHectares budgetAmount
+  currency startDate endDate completedAt workspaceId createdAt updatedAt
+`;
+var EMISSION_FACTOR_FIELDS = `
+  id name scope activityUnit factorKgco2e source validYear isActive
+  workspaceId createdAt updatedAt
+`;
+var CARBON_ENTRY_FIELDS = `
+  id category scope activityValue activityUnit co2eKg factorId siteId
+  periodStart status notes workspaceId createdAt updatedAt
+`;
+var REDUCTION_TARGET_FIELDS = `
+  id name metric description baselineValue baselineYear targetValue targetYear
+  unit status workspaceId createdAt updatedAt
+`;
+var REPORT_LINE_ITEM_FIELDS = `
+  id reportId label category value unit carbonEntryId workspaceId
+  createdAt updatedAt
+`;
+var REPORT_FIELDS = `
+  id title summary framework status periodStart periodEnd publishedAt
+  file { id } workspaceId createdAt updatedAt
+  lineItems { ${REPORT_LINE_ITEM_FIELDS} }
+`;
+var GET_SITE = `
+  query EcoGetSite($id: ID!) {
+    ecoSite(id: $id) {
+      ${SITE_FIELDS}
+      sensors { id name kind status unit }
+      thresholds { id parameter direction severity isActive }
+    }
+  }
+`;
+var LIST_SITES = `
+  query EcoListSites(
+    $status: EcoSiteStatus
+    $type: EcoSiteType
+    $pagination: PaginationInput
+  ) {
+    ecoListSites(status: $status, type: $type, pagination: $pagination) {
+      items { ${SITE_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_SITE = `
+  mutation EcoCreateSite($input: EcoCreateSiteInput!) {
+    ecoCreateSite(input: $input) {
+      ${SITE_FIELDS}
+    }
+  }
+`;
+var UPDATE_SITE = `
+  mutation EcoUpdateSite($id: ID!, $input: EcoUpdateSiteInput!) {
+    ecoUpdateSite(id: $id, input: $input) {
+      ${SITE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_SITE = `
+  mutation EcoArchiveSite($id: ID!) {
+    ecoArchiveSite(id: $id)
+  }
+`;
+var LIST_SENSORS = `
+  query EcoListSensors($siteId: ID, $kind: EcoSensorKind, $status: EcoSensorStatus) {
+    ecoListSensors(siteId: $siteId, kind: $kind, status: $status) {
+      ${SENSOR_FIELDS}
+      site { id name }
+    }
+  }
+`;
+var CREATE_SENSOR = `
+  mutation EcoCreateSensor($input: EcoCreateSensorInput!) {
+    ecoCreateSensor(input: $input) {
+      ${SENSOR_FIELDS}
+    }
+  }
+`;
+var SET_SENSOR_STATUS = `
+  mutation EcoSetSensorStatus($id: ID!, $status: EcoSensorStatus!) {
+    ecoSetSensorStatus(id: $id, status: $status) {
+      ${SENSOR_FIELDS}
+    }
+  }
+`;
+var LIST_THRESHOLDS = `
+  query EcoListThresholds($siteId: ID) {
+    ecoListThresholds(siteId: $siteId) {
+      ${THRESHOLD_FIELDS}
+    }
+  }
+`;
+var CREATE_THRESHOLD = `
+  mutation EcoCreateThreshold($input: EcoCreateThresholdInput!) {
+    ecoCreateThreshold(input: $input) {
+      ${THRESHOLD_FIELDS}
+    }
+  }
+`;
+var SET_THRESHOLD_ACTIVE = `
+  mutation EcoSetThresholdActive($id: ID!, $isActive: Boolean!) {
+    ecoSetThresholdActive(id: $id, isActive: $isActive) {
+      ${THRESHOLD_FIELDS}
+    }
+  }
+`;
+var LIST_MEASUREMENTS = `
+  query EcoListMeasurements(
+    $siteId: ID
+    $sensorId: ID
+    $parameter: String
+    $breachesOnly: Boolean
+    $pagination: PaginationInput
+  ) {
+    ecoListMeasurements(
+      siteId: $siteId
+      sensorId: $sensorId
+      parameter: $parameter
+      breachesOnly: $breachesOnly
+      pagination: $pagination
+    ) {
+      items { ${MEASUREMENT_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var RECORD_MEASUREMENT = `
+  mutation EcoRecordMeasurement($input: EcoRecordMeasurementInput!) {
+    ecoRecordMeasurement(input: $input) {
+      ${MEASUREMENT_FIELDS}
+    }
+  }
+`;
+var GET_SPECIES = `
+  query EcoGetSpecies($id: ID!) {
+    ecoSpecies(id: $id) {
+      ${SPECIES_FIELDS}
+      observations { id observedAt method count siteId }
+    }
+  }
+`;
+var LIST_SPECIES = `
+  query EcoListSpecies(
+    $taxonGroup: EcoTaxonGroup
+    $conservationStatus: EcoConservationStatus
+    $priorityOnly: Boolean
+    $pagination: PaginationInput
+  ) {
+    ecoListSpecies(
+      taxonGroup: $taxonGroup
+      conservationStatus: $conservationStatus
+      priorityOnly: $priorityOnly
+      pagination: $pagination
+    ) {
+      items { ${SPECIES_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_SPECIES = `
+  mutation EcoCreateSpecies($input: EcoCreateSpeciesInput!) {
+    ecoCreateSpecies(input: $input) {
+      ${SPECIES_FIELDS}
+    }
+  }
+`;
+var UPDATE_SPECIES = `
+  mutation EcoUpdateSpecies($id: ID!, $input: EcoUpdateSpeciesInput!) {
+    ecoUpdateSpecies(id: $id, input: $input) {
+      ${SPECIES_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_SPECIES = `
+  mutation EcoArchiveSpecies($id: ID!) {
+    ecoArchiveSpecies(id: $id)
+  }
+`;
+var LIST_OBSERVATIONS = `
+  query EcoListObservations(
+    $speciesId: ID
+    $siteId: ID
+    $pagination: PaginationInput
+  ) {
+    ecoListObservations(speciesId: $speciesId, siteId: $siteId, pagination: $pagination) {
+      items {
+        ${OBSERVATION_FIELDS}
+        species { id commonName }
+      }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var RECORD_OBSERVATION = `
+  mutation EcoRecordObservation($input: EcoRecordObservationInput!) {
+    ecoRecordObservation(input: $input) {
+      ${OBSERVATION_FIELDS}
+    }
+  }
+`;
+var GET_HABITAT_PROJECT = `
+  query EcoGetHabitatProject($id: ID!) {
+    ecoHabitatProject(id: $id) {
+      ${HABITAT_PROJECT_FIELDS}
+      activities { ${RESTORATION_ACTIVITY_FIELDS} }
+    }
+  }
+`;
+var LIST_HABITAT_PROJECTS = `
+  query EcoListHabitatProjects($status: EcoHabitatProjectStatus) {
+    ecoListHabitatProjects(status: $status) {
+      ${HABITAT_PROJECT_FIELDS}
+    }
+  }
+`;
+var CREATE_HABITAT_PROJECT = `
+  mutation EcoCreateHabitatProject($input: EcoCreateHabitatProjectInput!) {
+    ecoCreateHabitatProject(input: $input) {
+      ${HABITAT_PROJECT_FIELDS}
+    }
+  }
+`;
+var TRANSITION_HABITAT_PROJECT = `
+  mutation EcoTransitionHabitatProject($id: ID!, $status: EcoHabitatProjectStatus!) {
+    ecoTransitionHabitatProject(id: $id, status: $status) {
+      ${HABITAT_PROJECT_FIELDS}
+      activities { ${RESTORATION_ACTIVITY_FIELDS} }
+    }
+  }
+`;
+var LOG_RESTORATION_ACTIVITY = `
+  mutation EcoLogRestorationActivity($input: EcoLogRestorationActivityInput!) {
+    ecoLogRestorationActivity(input: $input) {
+      ${RESTORATION_ACTIVITY_FIELDS}
+    }
+  }
+`;
+var LIST_CARBON_ENTRIES = `
+  query EcoListCarbonEntries(
+    $scope: EcoEmissionScope
+    $siteId: ID
+    $status: EcoCarbonEntryStatus
+    $pagination: PaginationInput
+  ) {
+    ecoListCarbonEntries(
+      scope: $scope
+      siteId: $siteId
+      status: $status
+      pagination: $pagination
+    ) {
+      items {
+        ${CARBON_ENTRY_FIELDS}
+        factor { id name factorKgco2e }
+      }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CARBON_TOTAL_KG = `
+  query EcoCarbonTotalKg($scope: EcoEmissionScope, $siteId: ID) {
+    ecoCarbonTotalKg(scope: $scope, siteId: $siteId)
+  }
+`;
+var RECORD_CARBON_ENTRY = `
+  mutation EcoRecordCarbonEntry($input: EcoRecordCarbonEntryInput!) {
+    ecoRecordCarbonEntry(input: $input) {
+      ${CARBON_ENTRY_FIELDS}
+      factor { id name factorKgco2e }
+    }
+  }
+`;
+var VERIFY_CARBON_ENTRY = `
+  mutation EcoVerifyCarbonEntry($id: ID!) {
+    ecoVerifyCarbonEntry(id: $id) {
+      ${CARBON_ENTRY_FIELDS}
+    }
+  }
+`;
+var LIST_EMISSION_FACTORS = `
+  query EcoListEmissionFactors($scope: EcoEmissionScope, $activeOnly: Boolean) {
+    ecoListEmissionFactors(scope: $scope, activeOnly: $activeOnly) {
+      ${EMISSION_FACTOR_FIELDS}
+    }
+  }
+`;
+var CREATE_EMISSION_FACTOR = `
+  mutation EcoCreateEmissionFactor($input: EcoCreateEmissionFactorInput!) {
+    ecoCreateEmissionFactor(input: $input) {
+      ${EMISSION_FACTOR_FIELDS}
+    }
+  }
+`;
+var LIST_REDUCTION_TARGETS = `
+  query EcoListReductionTargets($status: EcoReductionTargetStatus) {
+    ecoListReductionTargets(status: $status) {
+      ${REDUCTION_TARGET_FIELDS}
+    }
+  }
+`;
+var CREATE_REDUCTION_TARGET = `
+  mutation EcoCreateReductionTarget($input: EcoCreateReductionTargetInput!) {
+    ecoCreateReductionTarget(input: $input) {
+      ${REDUCTION_TARGET_FIELDS}
+    }
+  }
+`;
+var SET_REDUCTION_TARGET_STATUS = `
+  mutation EcoSetReductionTargetStatus($id: ID!, $status: EcoReductionTargetStatus!) {
+    ecoSetReductionTargetStatus(id: $id, status: $status) {
+      ${REDUCTION_TARGET_FIELDS}
+    }
+  }
+`;
+var GET_REPORT = `
+  query EcoGetReport($id: ID!) {
+    ecoReport(id: $id) {
+      ${REPORT_FIELDS}
+    }
+  }
+`;
+var LIST_REPORTS = `
+  query EcoListReports($status: EcoReportStatus, $pagination: PaginationInput) {
+    ecoListReports(status: $status, pagination: $pagination) {
+      items { ${REPORT_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_REPORT = `
+  mutation EcoCreateReport($input: EcoCreateReportInput!) {
+    ecoCreateReport(input: $input) {
+      ${REPORT_FIELDS}
+    }
+  }
+`;
+var ADD_REPORT_LINE_ITEM = `
+  mutation EcoAddReportLineItem($input: EcoAddReportLineItemInput!) {
+    ecoAddReportLineItem(input: $input) {
+      ${REPORT_LINE_ITEM_FIELDS}
+    }
+  }
+`;
+var PUBLISH_REPORT = `
+  mutation EcoPublishReport($id: ID!, $fileId: ID) {
+    ecoPublishReport(id: $id, fileId: $fileId) {
+      ${REPORT_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query EcoHealth {
+    ecoHealth
+  }
+`;
+var SiteStatusEnum = zod.z.enum(["ACTIVE", "ARCHIVED", "MONITORING_PAUSED"]).describe("Lifecycle/monitoring status of an environmental site");
+var SiteTypeEnum = zod.z.enum([
+  "AIRSHED",
+  "COASTAL",
+  "FACILITY",
+  "FARM",
+  "FOREST",
+  "OTHER",
+  "PROTECTED_AREA",
+  "WATERSHED",
+  "WETLAND"
+]).describe("Classification of an environmental site");
+var SensorKindEnum = zod.z.enum([
+  "ACOUSTIC",
+  "AIR_QUALITY",
+  "CAMERA_TRAP",
+  "ENERGY_METER",
+  "FLOW",
+  "MANUAL",
+  "SOIL",
+  "WATER_QUALITY",
+  "WEATHER"
+]).describe("Kind of monitoring sensor");
+var SensorStatusEnum = zod.z.enum(["DEGRADED", "MAINTENANCE", "OFFLINE", "ONLINE", "RETIRED"]).describe("Operational status of a sensor");
+var ThresholdDirectionEnum = zod.z.enum(["ABOVE", "BELOW", "OUTSIDE_RANGE"]).describe("Direction a measurement must drift to breach a threshold");
+var ThresholdSeverityEnum = zod.z.enum(["CRITICAL", "INFO", "WARNING"]).describe("Severity classification of an alert threshold");
+var MeasurementSourceEnum = zod.z.enum(["CALCULATED", "IMPORT", "MANUAL", "SATELLITE", "SENSOR"]).describe("Provenance of a measurement value");
+var ConservationStatusEnum = zod.z.enum([
+  "CRITICALLY_ENDANGERED",
+  "DATA_DEFICIENT",
+  "ENDANGERED",
+  "EXTINCT_IN_WILD",
+  "LEAST_CONCERN",
+  "NEAR_THREATENED",
+  "NOT_EVALUATED",
+  "VULNERABLE"
+]).describe("IUCN-style conservation status of a species");
+var TaxonGroupEnum = zod.z.enum(["AMPHIBIAN", "BIRD", "FISH", "FUNGI", "INSECT", "MAMMAL", "OTHER", "PLANT", "REPTILE"]).describe("Broad taxonomic group of a species");
+var ObservationMethodEnum = zod.z.enum([
+  "ACOUSTIC",
+  "CAMERA_TRAP",
+  "COMMUNITY_REPORT",
+  "DIRECT_SIGHTING",
+  "EDNA",
+  "TELEMETRY",
+  "TRACKS_SIGNS"
+]).describe("Method by which a species observation was recorded");
+var HabitatProjectStatusEnum = zod.z.enum(["CANCELLED", "COMPLETED", "IN_PROGRESS", "MONITORING", "ON_HOLD", "PLANNED"]).describe("Lifecycle status of a habitat restoration project");
+var RestorationActivityTypeEnum = zod.z.enum([
+  "COMMUNITY_ENGAGEMENT",
+  "INVASIVE_REMOVAL",
+  "PLANTING",
+  "REWILDING",
+  "SOIL_REMEDIATION",
+  "SURVEY",
+  "WATER_MANAGEMENT"
+]).describe("Type of restoration activity logged against a habitat project");
+var EmissionScopeEnum = zod.z.enum(["SCOPE_1", "SCOPE_2", "SCOPE_3"]).describe("GHG Protocol emission scope");
+var CarbonEntryStatusEnum = zod.z.enum(["ADJUSTED", "DRAFT", "RECORDED", "VERIFIED"]).describe("Lifecycle status of a carbon-ledger entry");
+var ReductionTargetStatusEnum = zod.z.enum(["ACHIEVED", "ACTIVE", "MISSED", "PROPOSED", "RETIRED"]).describe("Status of an emissions-reduction target");
+var ReportFrameworkEnum = zod.z.enum(["CDP", "CUSTOM", "GHG_PROTOCOL", "GRI", "SASB", "TCFD"]).describe("Sustainability-reporting framework");
+var ReportStatusEnum = zod.z.enum(["ARCHIVED", "DRAFT", "IN_REVIEW", "PUBLISHED"]).describe("Lifecycle status of a sustainability report");
+function buildPagination(args) {
+  const pagination = {};
+  if (args.limit !== void 0) pagination.limit = args.limit;
+  if (args.offset !== void 0) pagination.offset = args.offset;
+  if (args.cursor !== void 0) pagination.cursor = args.cursor;
+  return Object.keys(pagination).length > 0 ? pagination : void 0;
+}
+var paginationInputShape = {
+  limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+  offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+  cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+};
+
+// src/modules/ecoimpacthub/tools/sites.ts
+function registerSiteTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sites_get")),
+    {
+      title: "Get Site",
+      description: "Fetch a single monitored environmental site by ID, including its sensors and alert thresholds.",
+      inputSchema: { id: zod.z.string().describe("Site ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SITE, { id });
+        if (!data.ecoSite) return errorResult(`Site ${id} not found`);
+        return jsonResult(data.ecoSite);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub sites_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get site: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sites_list")),
+    {
+      title: "List Sites",
+      description: "List monitored sites in the bound workspace with optional status/type filters and cursor pagination.",
+      inputSchema: {
+        status: SiteStatusEnum.optional().describe("Filter by monitoring status"),
+        type: SiteTypeEnum.optional().describe("Filter by site type"),
+        ...paginationInputShape
+      }
+    },
+    async ({ status, type, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SITES, {
+          status,
+          type,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.ecoListSites);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub sites_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list sites: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sites_create")),
+    {
+      title: "Create Site",
+      description: "Register a new monitored environmental site (facility, forest, watershed, etc.).",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Site display name"),
+        type: SiteTypeEnum.optional().describe("Site type (default FACILITY)"),
+        status: SiteStatusEnum.optional().describe("Initial status (default ACTIVE)"),
+        code: zod.z.string().optional().describe("Short site code"),
+        description: zod.z.string().optional().describe("Site description"),
+        region: zod.z.string().optional().describe("Region / sub-national area"),
+        country: zod.z.string().optional().describe("Country"),
+        latitude: zod.z.number().optional().describe("Latitude (decimal degrees)"),
+        longitude: zod.z.number().optional().describe("Longitude (decimal degrees)"),
+        areaHectares: zod.z.number().optional().describe("Site area in hectares")
+      }
+    },
+    async ({
+      name,
+      type,
+      status,
+      code,
+      description,
+      region,
+      country,
+      latitude,
+      longitude,
+      areaHectares
+    }) => {
+      try {
+        const input = { name };
+        if (type !== void 0) input.type = type;
+        if (status !== void 0) input.status = status;
+        if (code !== void 0) input.code = code;
+        if (description !== void 0) input.description = description;
+        if (region !== void 0) input.region = region;
+        if (country !== void 0) input.country = country;
+        if (latitude !== void 0) input.latitude = latitude;
+        if (longitude !== void 0) input.longitude = longitude;
+        if (areaHectares !== void 0) input.areaHectares = areaHectares;
+        const data = await ctx.gql.workspace.request(CREATE_SITE, { input });
+        return jsonResult(data.ecoCreateSite);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub sites_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create site: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sites_update")),
+    {
+      title: "Update Site",
+      description: "Update a monitored site. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Site ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        type: SiteTypeEnum.optional().describe("Updated site type"),
+        status: SiteStatusEnum.optional().describe("Updated monitoring status"),
+        code: zod.z.string().optional().describe("Updated site code"),
+        description: zod.z.string().optional().describe("Updated description"),
+        region: zod.z.string().optional().describe("Updated region"),
+        country: zod.z.string().optional().describe("Updated country"),
+        latitude: zod.z.number().optional().describe("Updated latitude"),
+        longitude: zod.z.number().optional().describe("Updated longitude"),
+        areaHectares: zod.z.number().optional().describe("Updated area in hectares")
+      }
+    },
+    async ({
+      id,
+      name,
+      type,
+      status,
+      code,
+      description,
+      region,
+      country,
+      latitude,
+      longitude,
+      areaHectares
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (type !== void 0) input.type = type;
+        if (status !== void 0) input.status = status;
+        if (code !== void 0) input.code = code;
+        if (description !== void 0) input.description = description;
+        if (region !== void 0) input.region = region;
+        if (country !== void 0) input.country = country;
+        if (latitude !== void 0) input.latitude = latitude;
+        if (longitude !== void 0) input.longitude = longitude;
+        if (areaHectares !== void 0) input.areaHectares = areaHectares;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable site field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_SITE, { id, input });
+        return jsonResult(data.ecoUpdateSite);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub sites_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update site: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sites_archive")),
+    {
+      title: "Archive Site",
+      description: "Archive a monitored site (soft delete). Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Site ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_SITE,
+          {
+            id
+          }
+        );
+        return jsonResult({ ok: data.ecoArchiveSite, id });
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub sites_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive site: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerSensorTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sensors_list")),
+    {
+      title: "List Sensors",
+      description: "List monitoring sensors, optionally filtered by site, kind, and/or operational status.",
+      inputSchema: {
+        siteId: zod.z.string().optional().describe("Filter by site ID"),
+        kind: SensorKindEnum.optional().describe("Filter by sensor kind"),
+        status: SensorStatusEnum.optional().describe("Filter by operational status")
+      }
+    },
+    async ({ siteId, kind, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SENSORS, { siteId, kind, status });
+        return jsonResult(data.ecoListSensors);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub sensors_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list sensors: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sensors_create")),
+    {
+      title: "Create Sensor",
+      description: "Provision a new sensor on a site. `kind` defaults to MANUAL and `status` to ONLINE.",
+      inputSchema: {
+        siteId: zod.z.string().min(1).describe("Owning site ID"),
+        name: zod.z.string().min(1).describe("Sensor display name"),
+        kind: SensorKindEnum.optional().describe("Sensor kind (default MANUAL)"),
+        status: SensorStatusEnum.optional().describe("Initial status (default ONLINE)"),
+        unit: zod.z.string().optional().describe("Default measurement unit"),
+        hardwareId: zod.z.string().optional().describe("Physical hardware identifier"),
+        installedAt: zod.z.string().optional().describe("Installation timestamp (ISO-8601 DateTime)")
+      }
+    },
+    async ({ siteId, name, kind, status, unit, hardwareId, installedAt }) => {
+      try {
+        const input = { siteId, name };
+        if (kind !== void 0) input.kind = kind;
+        if (status !== void 0) input.status = status;
+        if (unit !== void 0) input.unit = unit;
+        if (hardwareId !== void 0) input.hardwareId = hardwareId;
+        if (installedAt !== void 0) input.installedAt = installedAt;
+        const data = await ctx.gql.workspace.request(CREATE_SENSOR, { input });
+        return jsonResult(data.ecoCreateSensor);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub sensors_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create sensor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sensors_set_status")),
+    {
+      title: "Set Sensor Status",
+      description: "Update a sensor's operational status (e.g. flag it OFFLINE / MAINTENANCE / DEGRADED).",
+      inputSchema: {
+        id: zod.z.string().describe("Sensor ID"),
+        status: SensorStatusEnum.describe("New operational status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SET_SENSOR_STATUS, { id, status });
+        return jsonResult(data.ecoSetSensorStatus);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub sensors_set_status failed", { error: String(error) });
+        return errorResult(
+          `Failed to set sensor status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerThresholdTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "thresholds_list")),
+    {
+      title: "List Alert Thresholds",
+      description: "List alert thresholds, optionally filtered by site.",
+      inputSchema: {
+        siteId: zod.z.string().optional().describe("Filter by site ID")
+      }
+    },
+    async ({ siteId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_THRESHOLDS, { siteId });
+        return jsonResult(data.ecoListThresholds);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub thresholds_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list thresholds: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "thresholds_create")),
+    {
+      title: "Create Alert Threshold",
+      description: "Create an alert threshold for a site + parameter. `direction` defaults to ABOVE and `severity` to WARNING. Provide min/max for OUTSIDE_RANGE or limitValue for ABOVE/BELOW.",
+      inputSchema: {
+        siteId: zod.z.string().min(1).describe("Owning site ID"),
+        parameter: zod.z.string().min(1).describe('Monitored parameter (e.g. "pm2_5", "ph", "turbidity")'),
+        unit: zod.z.string().min(1).describe("Unit of the threshold value"),
+        direction: ThresholdDirectionEnum.optional().describe("Breach direction (default ABOVE)"),
+        severity: ThresholdSeverityEnum.optional().describe("Alert severity (default WARNING)"),
+        limitValue: zod.z.number().optional().describe("Single limit value (ABOVE/BELOW)"),
+        minValue: zod.z.number().optional().describe("Lower bound (OUTSIDE_RANGE)"),
+        maxValue: zod.z.number().optional().describe("Upper bound (OUTSIDE_RANGE)")
+      }
+    },
+    async ({ siteId, parameter, unit, direction, severity, limitValue, minValue, maxValue }) => {
+      try {
+        const input = { siteId, parameter, unit };
+        if (direction !== void 0) input.direction = direction;
+        if (severity !== void 0) input.severity = severity;
+        if (limitValue !== void 0) input.limitValue = limitValue;
+        if (minValue !== void 0) input.minValue = minValue;
+        if (maxValue !== void 0) input.maxValue = maxValue;
+        const data = await ctx.gql.workspace.request(CREATE_THRESHOLD, { input });
+        return jsonResult(data.ecoCreateThreshold);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub thresholds_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create threshold: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "thresholds_set_active")),
+    {
+      title: "Set Threshold Active",
+      description: "Enable or disable an alert threshold.",
+      inputSchema: {
+        id: zod.z.string().describe("Threshold ID"),
+        isActive: zod.z.boolean().describe("Whether the threshold should be active")
+      }
+    },
+    async ({ id, isActive }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SET_THRESHOLD_ACTIVE, { id, isActive });
+        return jsonResult(data.ecoSetThresholdActive);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub thresholds_set_active failed", { error: String(error) });
+        return errorResult(
+          `Failed to set threshold active state: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMeasurementTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "measurements_list")),
+    {
+      title: "List Measurements",
+      description: "List telemetry measurements with optional site/sensor/parameter filters, a breaches-only flag, and cursor pagination.",
+      inputSchema: {
+        siteId: zod.z.string().optional().describe("Filter by site ID"),
+        sensorId: zod.z.string().optional().describe("Filter by sensor ID"),
+        parameter: zod.z.string().optional().describe("Filter by measured parameter"),
+        breachesOnly: zod.z.boolean().optional().describe("Only return measurements flagged as breaches"),
+        ...paginationInputShape
+      }
+    },
+    async ({ siteId, sensorId, parameter, breachesOnly, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MEASUREMENTS, {
+          siteId,
+          sensorId,
+          parameter,
+          breachesOnly,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.ecoListMeasurements);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub measurements_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list measurements: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "measurements_record")),
+    {
+      title: "Record Measurement",
+      description: "Record a measurement for a site + parameter; the value is evaluated against active thresholds and flagged as a breach when out of range. `source` defaults to SENSOR.",
+      inputSchema: {
+        siteId: zod.z.string().min(1).describe("Site the measurement belongs to"),
+        parameter: zod.z.string().min(1).describe('Measured parameter (e.g. "pm2_5", "ph")'),
+        value: zod.z.number().describe("Measured value"),
+        unit: zod.z.string().min(1).describe("Unit of the value"),
+        recordedAt: zod.z.string().describe("When the measurement was taken (ISO-8601 DateTime)"),
+        source: MeasurementSourceEnum.optional().describe("Provenance (default SENSOR)"),
+        sensorId: zod.z.string().optional().describe("Source sensor ID (if from a sensor)"),
+        notes: zod.z.string().optional().describe("Free-text notes")
+      }
+    },
+    async ({ siteId, parameter, value, unit, recordedAt, source, sensorId, notes }) => {
+      try {
+        const input = { siteId, parameter, value, unit, recordedAt };
+        if (source !== void 0) input.source = source;
+        if (sensorId !== void 0) input.sensorId = sensorId;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(RECORD_MEASUREMENT, { input });
+        return jsonResult(data.ecoRecordMeasurement);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub measurements_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record measurement: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerSpeciesTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "species_get")),
+    {
+      title: "Get Species",
+      description: "Fetch a single catalogued species by ID, including its observations.",
+      inputSchema: { id: zod.z.string().describe("Species ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SPECIES, { id });
+        if (!data.ecoSpecies) return errorResult(`Species ${id} not found`);
+        return jsonResult(data.ecoSpecies);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub species_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get species: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "species_list")),
+    {
+      title: "List Species",
+      description: "List catalogued species with optional taxon-group/conservation-status/priority filters and cursor pagination.",
+      inputSchema: {
+        taxonGroup: TaxonGroupEnum.optional().describe("Filter by taxonomic group"),
+        conservationStatus: ConservationStatusEnum.optional().describe(
+          "Filter by conservation status"
+        ),
+        priorityOnly: zod.z.boolean().optional().describe("Only priority species"),
+        ...paginationInputShape
+      }
+    },
+    async ({ taxonGroup, conservationStatus, priorityOnly, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SPECIES, {
+          taxonGroup,
+          conservationStatus,
+          priorityOnly,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.ecoListSpecies);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub species_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list species: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "species_create")),
+    {
+      title: "Create Species",
+      description: "Add a species to the biodiversity catalog. `taxonGroup` defaults to OTHER and `conservationStatus` to NOT_EVALUATED.",
+      inputSchema: {
+        commonName: zod.z.string().min(1).describe("Common (vernacular) name"),
+        scientificName: zod.z.string().optional().describe("Binomial scientific name"),
+        taxonGroup: TaxonGroupEnum.optional().describe("Taxonomic group (default OTHER)"),
+        conservationStatus: ConservationStatusEnum.optional().describe(
+          "Conservation status (default NOT_EVALUATED)"
+        ),
+        isPriority: zod.z.boolean().optional().describe("Flag as a priority species (default false)"),
+        description: zod.z.string().optional().describe("Species description / notes")
+      }
+    },
+    async ({
+      commonName,
+      scientificName,
+      taxonGroup,
+      conservationStatus,
+      isPriority,
+      description
+    }) => {
+      try {
+        const input = { commonName };
+        if (scientificName !== void 0) input.scientificName = scientificName;
+        if (taxonGroup !== void 0) input.taxonGroup = taxonGroup;
+        if (conservationStatus !== void 0) input.conservationStatus = conservationStatus;
+        if (isPriority !== void 0) input.isPriority = isPriority;
+        if (description !== void 0) input.description = description;
+        const data = await ctx.gql.workspace.request(CREATE_SPECIES, { input });
+        return jsonResult(data.ecoCreateSpecies);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub species_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create species: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "species_update")),
+    {
+      title: "Update Species",
+      description: "Update a catalogued species. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Species ID"),
+        commonName: zod.z.string().optional().describe("Updated common name"),
+        scientificName: zod.z.string().optional().describe("Updated scientific name"),
+        taxonGroup: TaxonGroupEnum.optional().describe("Updated taxonomic group"),
+        conservationStatus: ConservationStatusEnum.optional().describe(
+          "Updated conservation status"
+        ),
+        isPriority: zod.z.boolean().optional().describe("Updated priority flag"),
+        description: zod.z.string().optional().describe("Updated description")
+      }
+    },
+    async ({
+      id,
+      commonName,
+      scientificName,
+      taxonGroup,
+      conservationStatus,
+      isPriority,
+      description
+    }) => {
+      try {
+        const input = {};
+        if (commonName !== void 0) input.commonName = commonName;
+        if (scientificName !== void 0) input.scientificName = scientificName;
+        if (taxonGroup !== void 0) input.taxonGroup = taxonGroup;
+        if (conservationStatus !== void 0) input.conservationStatus = conservationStatus;
+        if (isPriority !== void 0) input.isPriority = isPriority;
+        if (description !== void 0) input.description = description;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable species field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_SPECIES, { id, input });
+        return jsonResult(data.ecoUpdateSpecies);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub species_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update species: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "species_archive")),
+    {
+      title: "Archive Species",
+      description: "Archive a species (soft delete). Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Species ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_SPECIES,
+          { id }
+        );
+        return jsonResult({ ok: data.ecoArchiveSpecies, id });
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub species_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive species: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerObservationTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "observations_list")),
+    {
+      title: "List Observations",
+      description: "List species observations with optional species/site filters and cursor pagination.",
+      inputSchema: {
+        speciesId: zod.z.string().optional().describe("Filter by species ID"),
+        siteId: zod.z.string().optional().describe("Filter by site ID"),
+        ...paginationInputShape
+      }
+    },
+    async ({ speciesId, siteId, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_OBSERVATIONS, {
+          speciesId,
+          siteId,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.ecoListObservations);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub observations_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list observations: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "observations_record")),
+    {
+      title: "Record Observation",
+      description: "Record a species observation. `count` defaults to 1 and `method` to DIRECT_SIGHTING. Attach a wspace-files File via `evidenceFileId` for photo/audio evidence.",
+      inputSchema: {
+        speciesId: zod.z.string().min(1).describe("Observed species ID"),
+        observedAt: zod.z.string().describe("When the observation was made (ISO-8601 DateTime)"),
+        siteId: zod.z.string().optional().describe("Site where it was observed"),
+        method: ObservationMethodEnum.optional().describe(
+          "Observation method (default DIRECT_SIGHTING)"
+        ),
+        count: zod.z.number().int().optional().describe("Number of individuals (default 1)"),
+        latitude: zod.z.number().optional().describe("Latitude (decimal degrees)"),
+        longitude: zod.z.number().optional().describe("Longitude (decimal degrees)"),
+        evidenceFileId: zod.z.string().optional().describe("wspace-files File ID for photo/audio evidence"),
+        notes: zod.z.string().optional().describe("Free-text notes")
+      }
+    },
+    async ({
+      speciesId,
+      observedAt,
+      siteId,
+      method,
+      count,
+      latitude,
+      longitude,
+      evidenceFileId,
+      notes
+    }) => {
+      try {
+        const input = { speciesId, observedAt };
+        if (siteId !== void 0) input.siteId = siteId;
+        if (method !== void 0) input.method = method;
+        if (count !== void 0) input.count = count;
+        if (latitude !== void 0) input.latitude = latitude;
+        if (longitude !== void 0) input.longitude = longitude;
+        if (evidenceFileId !== void 0) input.evidenceFileId = evidenceFileId;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(RECORD_OBSERVATION, { input });
+        return jsonResult(data.ecoRecordObservation);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub observations_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record observation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerHabitatTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "habitat_projects_get")),
+    {
+      title: "Get Habitat Project",
+      description: "Fetch a single habitat restoration project by ID, including its logged restoration activities.",
+      inputSchema: { id: zod.z.string().describe("Habitat project ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_HABITAT_PROJECT, { id });
+        if (!data.ecoHabitatProject) return errorResult(`Habitat project ${id} not found`);
+        return jsonResult(data.ecoHabitatProject);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub habitat_projects_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get habitat project: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "habitat_projects_list")),
+    {
+      title: "List Habitat Projects",
+      description: "List habitat restoration projects, optionally filtered by status.",
+      inputSchema: {
+        status: HabitatProjectStatusEnum.optional().describe("Filter by project status")
+      }
+    },
+    async ({ status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_HABITAT_PROJECTS, { status });
+        return jsonResult(data.ecoListHabitatProjects);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub habitat_projects_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list habitat projects: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "habitat_projects_create")),
+    {
+      title: "Create Habitat Project",
+      description: "Create a habitat restoration project (target area, budget, timeline, manager).",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Project name"),
+        description: zod.z.string().optional().describe("Project description"),
+        siteId: zod.z.string().optional().describe("Associated site ID"),
+        managerId: zod.z.string().optional().describe("Project manager user ID"),
+        targetHectares: zod.z.number().optional().describe("Target restoration area in hectares"),
+        budgetAmount: zod.z.number().optional().describe("Budget amount"),
+        currency: zod.z.string().optional().describe("Budget currency code"),
+        startDate: zod.z.string().optional().describe("Planned start (ISO-8601 DateTime)"),
+        endDate: zod.z.string().optional().describe("Planned end (ISO-8601 DateTime)")
+      }
+    },
+    async ({
+      name,
+      description,
+      siteId,
+      managerId,
+      targetHectares,
+      budgetAmount,
+      currency,
+      startDate,
+      endDate
+    }) => {
+      try {
+        const input = { name };
+        if (description !== void 0) input.description = description;
+        if (siteId !== void 0) input.siteId = siteId;
+        if (managerId !== void 0) input.managerId = managerId;
+        if (targetHectares !== void 0) input.targetHectares = targetHectares;
+        if (budgetAmount !== void 0) input.budgetAmount = budgetAmount;
+        if (currency !== void 0) input.currency = currency;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        const data = await ctx.gql.workspace.request(CREATE_HABITAT_PROJECT, { input });
+        return jsonResult(data.ecoCreateHabitatProject);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub habitat_projects_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create habitat project: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "habitat_projects_transition")),
+    {
+      title: "Transition Habitat Project",
+      description: "Advance a habitat project through its lifecycle (validated transitions, e.g. PLANNED \u2192 IN_PROGRESS \u2192 MONITORING \u2192 COMPLETED, or ON_HOLD / CANCELLED).",
+      inputSchema: {
+        id: zod.z.string().describe("Habitat project ID"),
+        status: HabitatProjectStatusEnum.describe("Target lifecycle status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_HABITAT_PROJECT, { id, status });
+        return jsonResult(data.ecoTransitionHabitatProject);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub habitat_projects_transition failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to transition habitat project: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "habitat_projects_log_activity")),
+    {
+      title: "Log Restoration Activity",
+      description: "Log a restoration activity against a habitat project (planting, invasive removal, survey, etc.). `type` defaults to PLANTING.",
+      inputSchema: {
+        projectId: zod.z.string().min(1).describe("Owning habitat project ID"),
+        summary: zod.z.string().min(1).describe("Short activity summary"),
+        performedAt: zod.z.string().describe("When the activity was performed (ISO-8601 DateTime)"),
+        type: RestorationActivityTypeEnum.optional().describe("Activity type (default PLANTING)"),
+        quantity: zod.z.number().optional().describe("Quantity (e.g. seedlings planted, hectares cleared)"),
+        unit: zod.z.string().optional().describe("Unit of the quantity"),
+        details: zod.z.string().optional().describe("Detailed notes")
+      }
+    },
+    async ({ projectId, summary, performedAt, type, quantity, unit, details }) => {
+      try {
+        const input = { projectId, summary, performedAt };
+        if (type !== void 0) input.type = type;
+        if (quantity !== void 0) input.quantity = quantity;
+        if (unit !== void 0) input.unit = unit;
+        if (details !== void 0) input.details = details;
+        const data = await ctx.gql.workspace.request(LOG_RESTORATION_ACTIVITY, { input });
+        return jsonResult(data.ecoLogRestorationActivity);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub habitat_projects_log_activity failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to log restoration activity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCarbonTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "carbon_list_entries")),
+    {
+      title: "List Carbon Entries",
+      description: "List carbon-ledger entries with optional scope/site/status filters and cursor pagination.",
+      inputSchema: {
+        scope: EmissionScopeEnum.optional().describe("Filter by emission scope"),
+        siteId: zod.z.string().optional().describe("Filter by site ID"),
+        status: CarbonEntryStatusEnum.optional().describe("Filter by entry status"),
+        ...paginationInputShape
+      }
+    },
+    async ({ scope, siteId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CARBON_ENTRIES, {
+          scope,
+          siteId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.ecoListCarbonEntries);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub carbon_list_entries failed", { error: String(error) });
+        return errorResult(
+          `Failed to list carbon entries: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "carbon_total_kg")),
+    {
+      title: "Carbon Total (kg CO2e)",
+      description: "Total CO2e (kg) recorded in the workspace, optionally narrowed by emission scope and/or site.",
+      inputSchema: {
+        scope: EmissionScopeEnum.optional().describe("Narrow the total to a single emission scope"),
+        siteId: zod.z.string().optional().describe("Narrow the total to a single site")
+      }
+    },
+    async ({ scope, siteId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          CARBON_TOTAL_KG,
+          { scope, siteId }
+        );
+        return jsonResult({
+          totalKgCo2e: data.ecoCarbonTotalKg,
+          scope: scope ?? null,
+          siteId: siteId ?? null
+        });
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub carbon_total failed", { error: String(error) });
+        return errorResult(
+          `Failed to get carbon total: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "carbon_record_entry")),
+    {
+      title: "Record Carbon Entry",
+      description: "Record a carbon-ledger entry; CO2e is computed from the activity value and the referenced emission factor (when one is provided). `scope` defaults to SCOPE_1.",
+      inputSchema: {
+        category: zod.z.string().min(1).describe('Activity category (e.g. "electricity", "fleet-diesel")'),
+        activityValue: zod.z.number().describe("Activity quantity (e.g. kWh, litres)"),
+        activityUnit: zod.z.string().min(1).describe("Unit of the activity value"),
+        periodStart: zod.z.string().describe("Start of the activity period (ISO-8601 DateTime)"),
+        scope: EmissionScopeEnum.optional().describe("Emission scope (default SCOPE_1)"),
+        factorId: zod.z.string().optional().describe("Emission factor ID used to compute CO2e"),
+        siteId: zod.z.string().optional().describe("Associated site ID"),
+        notes: zod.z.string().optional().describe("Free-text notes")
+      }
+    },
+    async ({
+      category,
+      activityValue,
+      activityUnit,
+      periodStart,
+      scope,
+      factorId,
+      siteId,
+      notes
+    }) => {
+      try {
+        const input = {
+          category,
+          activityValue,
+          activityUnit,
+          periodStart
+        };
+        if (scope !== void 0) input.scope = scope;
+        if (factorId !== void 0) input.factorId = factorId;
+        if (siteId !== void 0) input.siteId = siteId;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(RECORD_CARBON_ENTRY, { input });
+        return jsonResult(data.ecoRecordCarbonEntry);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub carbon_record_entry failed", { error: String(error) });
+        return errorResult(
+          `Failed to record carbon entry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "carbon_verify_entry")),
+    {
+      title: "Verify Carbon Entry",
+      description: "Mark a carbon-ledger entry as VERIFIED.",
+      inputSchema: { id: zod.z.string().describe("Carbon entry ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(VERIFY_CARBON_ENTRY, { id });
+        return jsonResult(data.ecoVerifyCarbonEntry);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub carbon_verify_entry failed", { error: String(error) });
+        return errorResult(
+          `Failed to verify carbon entry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEmissionFactorTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "emission_factors_list")),
+    {
+      title: "List Emission Factors",
+      description: "List emission factors, optionally filtered by scope and/or limited to active factors.",
+      inputSchema: {
+        scope: EmissionScopeEnum.optional().describe("Filter by emission scope"),
+        activeOnly: zod.z.boolean().optional().describe("Only return active factors")
+      }
+    },
+    async ({ scope, activeOnly }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_EMISSION_FACTORS, { scope, activeOnly });
+        return jsonResult(data.ecoListEmissionFactors);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub emission_factors_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list emission factors: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "emission_factors_create")),
+    {
+      title: "Create Emission Factor",
+      description: "Create an emission factor (kg CO2e per activity unit) for use in carbon-entry calculations. `scope` defaults to SCOPE_1.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe('Factor name (e.g. "Grid electricity \u2013 IN")'),
+        activityUnit: zod.z.string().min(1).describe('Activity unit the factor applies to (e.g. "kWh")'),
+        factorKgco2e: zod.z.number().describe("Kilograms CO2e per activity unit"),
+        scope: EmissionScopeEnum.optional().describe("Emission scope (default SCOPE_1)"),
+        source: zod.z.string().optional().describe("Citation / source of the factor"),
+        validYear: zod.z.number().int().optional().describe("Year the factor is valid for")
+      }
+    },
+    async ({ name, activityUnit, factorKgco2e, scope, source, validYear }) => {
+      try {
+        const input = { name, activityUnit, factorKgco2e };
+        if (scope !== void 0) input.scope = scope;
+        if (source !== void 0) input.source = source;
+        if (validYear !== void 0) input.validYear = validYear;
+        const data = await ctx.gql.workspace.request(CREATE_EMISSION_FACTOR, { input });
+        return jsonResult(data.ecoCreateEmissionFactor);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub emission_factors_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create emission factor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTargetTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reduction_targets_list")),
+    {
+      title: "List Reduction Targets",
+      description: "List emissions/impact reduction targets, optionally filtered by status.",
+      inputSchema: {
+        status: ReductionTargetStatusEnum.optional().describe("Filter by target status")
+      }
+    },
+    async ({ status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REDUCTION_TARGETS, { status });
+        return jsonResult(data.ecoListReductionTargets);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub reduction_targets_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list reduction targets: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reduction_targets_create")),
+    {
+      title: "Create Reduction Target",
+      description: "Create an emissions/impact reduction target (baseline \u2192 target over a metric, with baseline + target years).",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Target name"),
+        metric: zod.z.string().min(1).describe('Metric being reduced (e.g. "Scope 1+2 CO2e")'),
+        baselineValue: zod.z.number().describe("Baseline metric value"),
+        baselineYear: zod.z.number().int().describe("Baseline year"),
+        targetValue: zod.z.number().describe("Target metric value"),
+        targetYear: zod.z.number().int().describe("Target year"),
+        unit: zod.z.string().min(1).describe("Unit of the metric values"),
+        description: zod.z.string().optional().describe("Target description")
+      }
+    },
+    async ({
+      name,
+      metric,
+      baselineValue,
+      baselineYear,
+      targetValue,
+      targetYear,
+      unit,
+      description
+    }) => {
+      try {
+        const input = {
+          name,
+          metric,
+          baselineValue,
+          baselineYear,
+          targetValue,
+          targetYear,
+          unit
+        };
+        if (description !== void 0) input.description = description;
+        const data = await ctx.gql.workspace.request(CREATE_REDUCTION_TARGET, { input });
+        return jsonResult(data.ecoCreateReductionTarget);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub reduction_targets_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create reduction target: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reduction_targets_set_status")),
+    {
+      title: "Set Reduction Target Status",
+      description: "Update the status of a reduction target (e.g. PROPOSED \u2192 ACTIVE \u2192 ACHIEVED / MISSED / RETIRED).",
+      inputSchema: {
+        id: zod.z.string().describe("Reduction target ID"),
+        status: ReductionTargetStatusEnum.describe("New target status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SET_REDUCTION_TARGET_STATUS, { id, status });
+        return jsonResult(data.ecoSetReductionTargetStatus);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub reduction_targets_set_status failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to set reduction target status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerReportTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reports_get")),
+    {
+      title: "Get Report",
+      description: "Fetch a single sustainability report by ID, including its line items.",
+      inputSchema: { id: zod.z.string().describe("Report ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_REPORT, { id });
+        if (!data.ecoReport) return errorResult(`Report ${id} not found`);
+        return jsonResult(data.ecoReport);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub reports_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get report: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reports_list")),
+    {
+      title: "List Reports",
+      description: "List sustainability reports, optionally filtered by status, with cursor pagination.",
+      inputSchema: {
+        status: ReportStatusEnum.optional().describe("Filter by report status"),
+        ...paginationInputShape
+      }
+    },
+    async ({ status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REPORTS, {
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.ecoListReports);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub reports_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list reports: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reports_create")),
+    {
+      title: "Create Report",
+      description: "Create a sustainability report for a reporting period. `framework` defaults to GHG_PROTOCOL.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Report title"),
+        periodStart: zod.z.string().describe("Reporting period start (ISO-8601 DateTime)"),
+        periodEnd: zod.z.string().describe("Reporting period end (ISO-8601 DateTime)"),
+        framework: ReportFrameworkEnum.optional().describe(
+          "Reporting framework (default GHG_PROTOCOL)"
+        ),
+        summary: zod.z.string().optional().describe("Report summary")
+      }
+    },
+    async ({ title, periodStart, periodEnd, framework, summary }) => {
+      try {
+        const input = { title, periodStart, periodEnd };
+        if (framework !== void 0) input.framework = framework;
+        if (summary !== void 0) input.summary = summary;
+        const data = await ctx.gql.workspace.request(CREATE_REPORT, { input });
+        return jsonResult(data.ecoCreateReport);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub reports_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create report: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reports_add_line_item")),
+    {
+      title: "Add Report Line Item",
+      description: "Add a line item to a sustainability report, optionally linked to a carbon-ledger entry.",
+      inputSchema: {
+        reportId: zod.z.string().min(1).describe("Owning report ID"),
+        label: zod.z.string().min(1).describe("Line-item label"),
+        value: zod.z.number().describe("Line-item value"),
+        unit: zod.z.string().min(1).describe("Unit of the value"),
+        category: zod.z.string().optional().describe("Line-item category"),
+        carbonEntryId: zod.z.string().optional().describe("Linked carbon-entry ID")
+      }
+    },
+    async ({ reportId, label, value, unit, category, carbonEntryId }) => {
+      try {
+        const input = { reportId, label, value, unit };
+        if (category !== void 0) input.category = category;
+        if (carbonEntryId !== void 0) input.carbonEntryId = carbonEntryId;
+        const data = await ctx.gql.workspace.request(ADD_REPORT_LINE_ITEM, { input });
+        return jsonResult(data.ecoAddReportLineItem);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub reports_add_line_item failed", { error: String(error) });
+        return errorResult(
+          `Failed to add report line item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reports_publish")),
+    {
+      title: "Publish Report",
+      description: "Publish a sustainability report, optionally attaching an exported wspace-files File as the published artifact.",
+      inputSchema: {
+        id: zod.z.string().describe("Report ID"),
+        fileId: zod.z.string().optional().describe("wspace-files File ID of the exported artifact")
+      }
+    },
+    async ({ id, fileId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_REPORT, { id, fileId });
+        return jsonResult(data.ecoPublishReport);
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub reports_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish report: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/ecoimpacthub/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "EcoImpactHub Health Check",
+      description: "Public liveness/identity probe for the EcoImpactHub subgraph (ecoHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.ecoHealth });
+      } catch (error) {
+        ctx.logger.error("ecoimpacthub health failed", { error: String(error) });
+        return errorResult(
+          `EcoImpactHub health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/ecoimpacthub/resources.ts
+function registerEcoimpacthubResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const sitesUri = track(mcpResourceUri(ctx.productName, "sites"));
+  const targetsUri = track(mcpResourceUri(ctx.productName, "targets"));
+  const carbonUri = track(mcpResourceUri(ctx.productName, "carbon"));
+  server.registerResource(
+    "ecoimpacthub-schema",
+    schemaUri,
+    {
+      title: "EcoImpactHub Domain Schema",
+      description: "Overview of the EcoImpactHub environmental-impact domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# EcoImpactHub Domain (Overview)
+
+Environmental-impact, sustainability + biodiversity monitoring platform.
+
+## Entities
+- EcoSite \u2014 a monitored environmental site (sensors, thresholds)
+- EcoSensor \u2014 monitoring hardware attached to a site
+- EcoAlertThreshold \u2014 per-site/parameter breach rule
+- EcoMeasurement \u2014 a telemetry reading (auto breach-flagged)
+- EcoSpecies \u2014 biodiversity catalog entry (observations)
+- EcoObservation \u2014 a species sighting (+ optional file evidence)
+- EcoHabitatProject (+EcoRestorationActivity) \u2014 restoration project + activity log
+- EcoCarbonEntry \u2014 a carbon-ledger entry (CO2e)
+- EcoEmissionFactor \u2014 kg CO2e per activity unit
+- EcoReductionTarget \u2014 emissions/impact reduction goal
+- EcoReport (+EcoReportLineItem) \u2014 sustainability disclosure report
+
+## Enums
+- EcoSiteStatus: ACTIVE, ARCHIVED, MONITORING_PAUSED
+- EcoSiteType: AIRSHED, COASTAL, FACILITY, FARM, FOREST, OTHER, PROTECTED_AREA, WATERSHED, WETLAND
+- EcoSensorKind: ACOUSTIC, AIR_QUALITY, CAMERA_TRAP, ENERGY_METER, FLOW, MANUAL, SOIL, WATER_QUALITY, WEATHER
+- EcoSensorStatus: DEGRADED, MAINTENANCE, OFFLINE, ONLINE, RETIRED
+- EcoThresholdDirection: ABOVE, BELOW, OUTSIDE_RANGE | EcoThresholdSeverity: CRITICAL, INFO, WARNING
+- EcoMeasurementSource: CALCULATED, IMPORT, MANUAL, SATELLITE, SENSOR
+- EcoConservationStatus: CRITICALLY_ENDANGERED, DATA_DEFICIENT, ENDANGERED, EXTINCT_IN_WILD, LEAST_CONCERN, NEAR_THREATENED, NOT_EVALUATED, VULNERABLE
+- EcoTaxonGroup: AMPHIBIAN, BIRD, FISH, FUNGI, INSECT, MAMMAL, OTHER, PLANT, REPTILE
+- EcoObservationMethod: ACOUSTIC, CAMERA_TRAP, COMMUNITY_REPORT, DIRECT_SIGHTING, EDNA, TELEMETRY, TRACKS_SIGNS
+- EcoHabitatProjectStatus: CANCELLED, COMPLETED, IN_PROGRESS, MONITORING, ON_HOLD, PLANNED
+- EcoRestorationActivityType: COMMUNITY_ENGAGEMENT, INVASIVE_REMOVAL, PLANTING, REWILDING, SOIL_REMEDIATION, SURVEY, WATER_MANAGEMENT
+- EcoEmissionScope: SCOPE_1, SCOPE_2, SCOPE_3 | EcoCarbonEntryStatus: ADJUSTED, DRAFT, RECORDED, VERIFIED
+- EcoReductionTargetStatus: ACHIEVED, ACTIVE, MISSED, PROPOSED, RETIRED
+- EcoReportFramework: CDP, CUSTOM, GHG_PROTOCOL, GRI, SASB, TCFD | EcoReportStatus: ARCHIVED, DRAFT, IN_REVIEW, PUBLISHED
+
+## Tool groups
+sites, sensors, thresholds, measurements, species, observations, habitat,
+carbon, emissions, targets, reports, health.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "ecoimpacthub-sites",
+    sitesUri,
+    {
+      title: "EcoImpactHub Site Directory",
+      description: "The first 50 monitored sites in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${sitesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SITES, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: sitesUri,
+              text: JSON.stringify(data.ecoListSites, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: sitesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "ecoimpacthub-targets",
+    targetsUri,
+    {
+      title: "EcoImpactHub Reduction Targets",
+      description: "All emissions/impact reduction targets in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${targetsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_REDUCTION_TARGETS,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: targetsUri,
+              text: JSON.stringify(data.ecoListReductionTargets, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: targetsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "ecoimpacthub-carbon",
+    carbonUri,
+    {
+      title: "EcoImpactHub Carbon Total",
+      description: "Total CO2e (kg) recorded across the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${carbonUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          CARBON_TOTAL_KG,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: carbonUri,
+              text: JSON.stringify({ totalKgCo2e: data.ecoCarbonTotalKg }, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: carbonUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerEcoimpacthubPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const siteOnboardingName = track(mcpPromptName(p, "site-onboarding"));
+  const reportingName = track(mcpPromptName(p, "sustainability-reporting"));
+  server.registerPrompt(
+    siteOnboardingName,
+    {
+      title: "Site Monitoring Onboarding",
+      description: "Guide for standing up a monitored EcoImpactHub site end to end: create the site, attach sensors, define alert thresholds, and record a first measurement.",
+      argsSchema: {
+        name: zod.z.string().optional().describe("Site name"),
+        type: zod.z.string().optional().describe("Site type")
+      }
+    },
+    ({ name, type }) => {
+      ctx.logger.debug(`Prompt ${siteOnboardingName} called`, { name, type });
+      const nameNote = name ? `Use the site name "${name}".` : "Ask the user for the site name.";
+      const typeNote = type ? `Use type ${type}.` : "Help the user pick an EcoSiteType.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me onboard a new EcoImpactHub monitored site.
+
+1. **Create Site**: Use ${p}_sites_create. ${nameNote} ${typeNote} Optionally set region/country and latitude/longitude.
+2. **Attach Sensors**: Use ${p}_sensors_create for each monitoring device \u2014 set siteId, name, kind (e.g. AIR_QUALITY, WATER_QUALITY), and unit.
+3. **Define Thresholds**: Use ${p}_thresholds_create per monitored parameter \u2014 set direction (ABOVE/BELOW/OUTSIDE_RANGE), severity, and limit/min/max values.
+4. **Record a Measurement**: Use ${p}_measurements_record to log a first reading; it is auto-evaluated against the active thresholds.
+5. **Verify**: Use ${p}_sites_get to confirm the site shows its sensors + thresholds, and ${p}_measurements_list with breachesOnly=true to spot any breaches.
+
+Show results at each step and confirm before moving on.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    reportingName,
+    {
+      title: "Sustainability Reporting",
+      description: "Workflow for compiling a sustainability disclosure: review the carbon ledger and targets, draft a report, add line items, and publish.",
+      argsSchema: {
+        framework: zod.z.string().optional().describe("Reporting framework (e.g. GHG_PROTOCOL, GRI)")
+      }
+    },
+    ({ framework }) => {
+      ctx.logger.debug(`Prompt ${reportingName} called`, { framework });
+      const frameworkNote = framework ? `Use the ${framework} framework.` : "Help the user pick an EcoReportFramework (default GHG_PROTOCOL).";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Compile an EcoImpactHub sustainability report. ${frameworkNote}
+
+1. **Carbon Ledger**: Use ${p}_carbon_total for the headline CO2e and ${p}_carbon_entries_list to review entries by scope; verify any pending entries with ${p}_carbon_entries_verify.
+2. **Emission Factors**: Use ${p}_emission_factors_list to confirm the factors backing the entries are current.
+3. **Targets**: Use ${p}_targets_list to check progress against reduction targets.
+4. **Create Report**: Use ${p}_reports_create for the reporting period (periodStart/periodEnd, framework).
+5. **Line Items**: Use ${p}_reports_add_line_item for each disclosure figure, linking carbonEntryId where applicable.
+6. **Publish**: Once reviewed, use ${p}_reports_publish (optionally attaching an exported file).
+
+Summarize totals and any targets at risk after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/ecoimpacthub/index.ts
+var ecoimpacthubModule = {
+  id: "ecoimpacthub",
+  version: "0.0.1",
+  displayName: "EcoImpactHub",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerSiteTools(server, ctx, trackTool);
+    registerSensorTools(server, ctx, trackTool);
+    registerThresholdTools(server, ctx, trackTool);
+    registerMeasurementTools(server, ctx, trackTool);
+    registerSpeciesTools(server, ctx, trackTool);
+    registerObservationTools(server, ctx, trackTool);
+    registerHabitatTools(server, ctx, trackTool);
+    registerCarbonTools(server, ctx, trackTool);
+    registerEmissionFactorTools(server, ctx, trackTool);
+    registerTargetTools(server, ctx, trackTool);
+    registerReportTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerEcoimpacthubResources(server, ctx, trackResource);
+    registerEcoimpacthubPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var ecoimpacthub_default = ecoimpacthubModule;
+
+module.exports = ecoimpacthub_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map