@@ -31,8 +31,9 @@
     with_pagination,
 )
 from ..utilities.sql_utils import convert_response_if_needed
+from ..utilities.time_utils import monthly_period_note
 from dataclasses import replace
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from fastmcp import Context
 from typing import Any, Callable, Dict, List, Optional, Union
 
@@ -401,6 +402,53 @@ async def get_dimension_values(
         return await handle_aws_error(ctx, e, 'getDimensionValues', 'Cost Explorer')
 
 
+def _forecast_period_note(
+    start_date: str,
+    end_date: str,
+    granularity: str,
+    response: Dict[str, Any],
+    measure: str,
+) -> Dict[str, str]:
+    """Say when a MONTHLY forecast covers a wider period than the one requested.
+
+    With MONTHLY granularity Cost Explorer widens the request to whole calendar months:
+    the start moves back to the 1st and the end forward to the next 1st. A first month
+    that starts before today (UTC, as Cost Explorer dates are) holds that month's actual
+    values to date as well as the forecast, and so does Total.
+
+    Args:
+        start_date: Requested start date (YYYY-MM-DD)
+        end_date: Requested end date (YYYY-MM-DD, exclusive)
+        granularity: Requested granularity; only MONTHLY is widened
+        response: GetCostForecast or GetUsageForecast response
+        measure: What the forecast measures ('costs' or 'usage'), used in the note
+
+    Returns:
+        ``{'period_note': ...}`` when the returned periods differ from the request,
+        otherwise an empty dict.
+    """
+    periods = response.get('ForecastResultsByTime') or []
+    if granularity != 'MONTHLY' or not periods:
+        return {}
+    covered_start = (periods[0].get('TimePeriod') or {}).get('Start')
+    covered_end = (periods[-1].get('TimePeriod') or {}).get('End')
+    if not covered_start or not covered_end:
+        return {}
+    if (covered_start, covered_end) == (start_date, end_date):
+        return {}
+    note = (
+        f'Cost Explorer returned whole calendar months: the result covers {covered_start} '
+        f'to {covered_end} (end exclusive), not the requested {start_date} to {end_date}.'
+    )
+    if covered_start < datetime.now(timezone.utc).strftime('%Y-%m-%d'):
+        note += (
+            f' The first period and Total include actual {measure} from {covered_start} to'
+            ' date, not only the forecast.'
+        )
+    note += ' For part of a month, use DAILY granularity and sum the days.'
+    return {'period_note': note}
+
+
 async def get_cost_forecast(
     ctx: Context,
     ce_client,
@@ -467,6 +515,8 @@ async def get_cost_forecast(
         # Make API call
         await ctx.info('Calling getCostForecast API')
         response = ce_client.get_cost_forecast(**request_params)
+        period_note = _forecast_period_note(start_date, end_date, granularity, response, 'costs')
+        response = {**period_note, **response}
 
         # Forecast responses can be large with DAILY granularity over months —
         # offload through the SQL gate so callers get a queryable table.
@@ -478,6 +528,7 @@ async def get_cost_forecast(
             granularity=granularity,
             start_date=start_date,
             end_date=end_date,
+            **period_note,
         )
 
         return format_response('success', table_response)
@@ -552,6 +603,8 @@ async def get_usage_forecast(
         # Make API call
         await ctx.info('Calling getUsageForecast API')
         response = ce_client.get_usage_forecast(**request_params)
+        period_note = _forecast_period_note(start_date, end_date, granularity, response, 'usage')
+        response = {**period_note, **response}
 
         table_response = await convert_response_if_needed(
             ctx,
@@ -561,6 +614,7 @@ async def get_usage_forecast(
             granularity=granularity,
             start_date=start_date,
             end_date=end_date,
+            **period_note,
         )
 
         return format_response('success', table_response)
@@ -762,8 +816,19 @@ async def get_savings_plans_utilization(
             request_params['Filter'] = filters
 
         response = ce_client.get_savings_plans_utilization(**request_params)
+        # MONTHLY entries are labelled with their whole calendar month even where the figures
+        # cover only part of it (the requested start or end falls inside the month).
+        period_note = monthly_period_note(
+            start,
+            end,
+            [
+                entry.get('TimePeriod')
+                for entry in response.get('SavingsPlansUtilizationsByTime') or []
+            ],
+            granularity,
+        )
 
-        return format_response('success', response)
+        return format_response('success', {**period_note, **response})
 
     except Exception as e:
         # Use shared error handling
 
@@ -182,7 +182,7 @@ def _with_example_dates(description: str) -> str:
    Optional: start_date, end_date, filter, prediction_interval_level, billing_view_arn
    Example 1 (default window): {"operation": "getCostForecast", "metric": "UNBLENDED_COST", "granularity": "MONTHLY"}
    Example 2 (next three months): {"operation": "getCostForecast", "metric": "UNBLENDED_COST", "granularity": "MONTHLY", "start_date": "__NEXT_MONTH_START__", "end_date": "__FOUR_MONTHS_AHEAD_START__"}
-   Notes: `metric` must be ALL CAPS and one of UNBLENDED_COST, BLENDED_COST, AMORTIZED_COST, NET_UNBLENDED_COST, NET_AMORTIZED_COST (not the getCostAndUsage spelling `UnblendedCost`). `start_date` defaults to tomorrow and `end_date` to 90 days after `start_date`; a `start_date` you pass must be today or later. The horizon is up to 3 months (DAILY) or 18 months (MONTHLY). HOURLY is not supported. In `filter`, LINKED_ACCOUNT values must be 12-digit account IDs (not account names), and RESOURCE_ID is not allowed.
+   Notes: `metric` must be ALL CAPS and one of UNBLENDED_COST, BLENDED_COST, AMORTIZED_COST, NET_UNBLENDED_COST, NET_AMORTIZED_COST (not the getCostAndUsage spelling `UnblendedCost`). `start_date` defaults to tomorrow and `end_date` to 90 days after `start_date`; a `start_date` you pass must be today or later. The horizon is up to 3 months (DAILY) or 18 months (MONTHLY). HOURLY is not supported. With MONTHLY granularity each period is a whole calendar month: Cost Explorer moves a `start_date` that isn't a 1st back to the 1st, and an `end_date` that isn't a 1st forward to the next 1st. So a MONTHLY forecast that starts this month on any day but the 1st (as the default start, tomorrow, does unless tomorrow is a 1st) returns the whole current month, and that period and `Total` include its actual costs to date. The response's `period_note` says when the period was widened. For part of a month, such as the rest of this month, use DAILY and sum the days. In `filter`, LINKED_ACCOUNT values must be 12-digit account IDs (not account names), and RESOURCE_ID is not allowed.
    Returns: Cost forecast for specified time period and granularity
 
 5. getUsageForecast - Future usage projections
@@ -191,7 +191,7 @@ def _with_example_dates(description: str) -> str:
    Example 1: {"operation": "getUsageForecast", "metric": "USAGE_QUANTITY", "granularity": "MONTHLY", "start_date": "__NEXT_MONTH_START__", "end_date": "__FOUR_MONTHS_AHEAD_START__", "filter": "{\\"Dimensions\\": {\\"Key\\": \\"USAGE_TYPE_GROUP\\", \\"Values\\": [\\"EC2: Running Hours\\"]}}"}
    Example 2: {"operation": "getUsageForecast", "metric": "USAGE_QUANTITY", "granularity": "MONTHLY", "filter": "{\\"And\\": [{\\"Dimensions\\": {\\"Key\\": \\"SERVICE\\", \\"Values\\": [\\"Amazon Elastic Compute Cloud - Compute\\"]}}, {\\"Dimensions\\": {\\"Key\\": \\"USAGE_TYPE\\", \\"Values\\": [\\"BoxUsage:p4de.24xlarge\\"]}}]}"}
    Example 3: {"operation": "getUsageForecast", "metric": "USAGE_QUANTITY", "granularity": "MONTHLY", "filter": "{\\"Dimensions\\": {\\"Key\\": \\"USAGE_TYPE\\", \\"Values\\": [\\"BoxUsage:p4de.24xlarge\\", \\"Reservation:p4de.24xlarge\\", \\"UnusedBox:p4de.24xlarge\\"]}}", "group_by": "[{\\"Type\\": \\"DIMENSION\\", \\"Key\\": \\"REGION\\"}]"}
-   Notes: Valid values for metric is: USAGE_QUANTITY, NORMALIZED_USAGE_AMOUNT. Valid values for granularity is: DAILY, MONTHLY. Filter is REQUIRED and must specify USAGE_TYPE or USAGE_TYPE_GROUP to define what usage units to forecast. Dates default and are limited as for getCostForecast.
+   Notes: Valid values for metric is: USAGE_QUANTITY, NORMALIZED_USAGE_AMOUNT. Valid values for granularity is: DAILY, MONTHLY. Filter is REQUIRED and must specify USAGE_TYPE or USAGE_TYPE_GROUP to define what usage units to forecast. Dates default and are limited as for getCostForecast, and MONTHLY periods are whole calendar months as described there.
    Returns: Usage forecast for specified time period and granularity
 
 6. getTagsOrValues - Available cost allocation tags or values
@@ -212,7 +212,7 @@ def _with_example_dates(description: str) -> str:
    Required: operation="getSavingsPlansUtilization", start_date, end_date
    Optional: granularity, filter
    Example: {"operation": "getSavingsPlansUtilization", "granularity": "MONTHLY"}
-   Notes: Supports only DAILY and MONTHLY granularity. start_date must be within the last 13 months, and end_date is exclusive and may be today. Data for the most recent 2-3 days (counting today) is not processed yet: a start_date in those days returns a DataUnavailableException, and a window that reaches into them silently leaves them out; a start_date at least 3 days before today is usually past that delay. A DataUnavailableException here means there is no Savings Plans data for THIS window and filter (the window is too recent, no plan was active in it, or a filter value such as an unknown SAVINGS_PLANS_TYPE matches nothing) — report that no data is available for that window (not zero) and do NOT resend the identical request; correct an unknown filter value, and query an earlier window only if the question allows it.
+   Notes: Supports only DAILY and MONTHLY granularity. With MONTHLY granularity each entry's TimePeriod is its whole calendar month (the current month's entry ends at the first day without data instead), but the figures (and Total) cover only the requested days: a start_date or end_date inside a month makes that month's entry partial though it is labelled with the whole month. The response's `period_note` says when this happened; report those months as partial. start_date must be within the last 13 months, and end_date is exclusive and may be today. Data for the most recent 2-3 days (counting today) is not processed yet: a start_date in those days returns a DataUnavailableException, and a window that reaches into them silently leaves them out; a start_date at least 3 days before today is usually past that delay. A DataUnavailableException here means there is no Savings Plans data for THIS window and filter (the window is too recent, no plan was active in it, or a filter value such as an unknown SAVINGS_PLANS_TYPE matches nothing) — report that no data is available for that window (not zero) and do NOT resend the identical request; correct an unknown filter value, and query an earlier window only if the question allows it.
    Returns: Savings Plans utilization for the specified time period
 
 DIMENSION REFERENCE:
 
@@ -29,6 +29,7 @@
     whole_query_in_one_page,
     with_pagination,
 )
+from ..utilities.time_utils import monthly_period_note
 from fastmcp import Context, FastMCP
 from typing import Any, Dict, List, Optional
 
@@ -99,6 +100,21 @@
 least 3 days before today is usually past that delay; query an earlier window only if
 the question allows it.
 
+RESPONSE PERIODS (both operations; dates are YYYY-MM-DD, end exclusive):
+- `requested_time_period` echoes the start_date/end_date that were sent.
+- get_reservation_utilization with MONTHLY granularity labels each entry's `time_period`
+  with its whole calendar month (the current month's entry ends at the first day without
+  data instead), but the figures cover only the requested days. A
+  2026-01-24 to 2026-03-10 request returns a first entry labelled 2026-01-01 to 2026-02-01
+  holding only 2026-01-24 onward, and a last entry labelled 2026-03-01 to 2026-04-01
+  holding only the days before 2026-03-10. `period_note` says when this happened and the
+  range the figures cover. Report those months as partial, not as whole months; `total`
+  also covers only that range.
+- With group_by, get_reservation_utilization returns one entry labelled with the requested
+  period.
+- get_reservation_coverage entries are not snapped: the first starts at the requested start
+  and the last ends at the requested end.
+
 SCOPING LARGE QUERIES: a grouped or DAILY query over a wide window or many
 subscriptions can exceed the tool result size cap and return a ToolResultOversized
 error. Scope such queries with `filter` (e.g. one SERVICE or one SUBSCRIPTION_ID),
@@ -381,6 +397,7 @@ async def get_reservation_coverage(
         # Format the response for better readability
         formatted_response: Dict[str, Any] = {
             'coverages_by_time': [],
+            'requested_time_period': {'start': start, 'end': end},
         }
 
         # Format total coverage if present
@@ -539,8 +556,17 @@ async def get_reservation_utilization(
         )
 
         # Format the response for better readability
+        # MONTHLY entries are labelled with their whole calendar month even where the figures
+        # cover only part of it (the requested start or end falls inside the month).
         formatted_response: Dict[str, Any] = {
             'utilizations_by_time': [],
+            'requested_time_period': {'start': start, 'end': end},
+            **monthly_period_note(
+                start,
+                end,
+                [entry.get('TimePeriod') for entry in all_utilizations],
+                None if group_by else granularity,
+            ),
         }
 
         # Format total utilization if present
 
@@ -30,6 +30,7 @@
     with_pagination,
 )
 from ..utilities.logging_utils import get_context_logger
+from ..utilities.time_utils import monthly_period_note
 from fastmcp import Context, FastMCP
 from typing import Any, Dict, Optional
 
@@ -69,8 +70,9 @@
   yet: yesterday is usually still missing, so excluding only today is not enough. A
   start_date inside those days returns a DataUnavailableException, which the service
   sends without a message. A window that only reaches into those days succeeds but
-  silently leaves them out, so the last entry can end before end_date. A start_date at
-  least 3 days before today is usually past that delay.
+  silently leaves them out, so the last DAILY entry can end before end_date (MONTHLY
+  labels: see RESPONSE PERIODS). A start_date at least 3 days before today is usually
+  past that delay.
 - A DataUnavailableException means there is no data for THIS window and filter: the
   window is too recent, no plan was active in it, or a filter value matches nothing
   (an unknown SAVINGS_PLANS_TYPE, for example, returns this error, not a
@@ -121,9 +123,13 @@
 
 RESPONSE PERIODS (all three operations):
 - `requested_time_period` echoes the start_date/end_date that were sent.
-- MONTHLY utilization labels each entry with its calendar month: a 2026-08-17 start
-  returns a first entry whose TimePeriod starts 2026-08-01, but its figures cover
-  only 2026-08-17 onward. Report that month as starting at the requested start.
+- MONTHLY utilization labels each entry's TimePeriod with its whole calendar month (the
+  current month's entry ends at the first day without data instead), but the figures
+  cover only the requested days. A 2026-08-17 to 2026-09-10 request returns
+  a first entry labelled 2026-08-01 to 2026-09-01 holding only 2026-08-17 onward, and a
+  last entry labelled 2026-09-01 to 2026-10-01 holding only the days before 2026-09-10.
+  `period_note` says when this happened and the range the figures cover. Report those
+  months as partial, not as whole months; `total` also covers only that range.
 - MONTHLY coverage entries start at the requested start; they are not snapped.
 - Utilization details returns `time_period`: the requested start, and an end the API
   may move earlier to the first day without complete data. Report that period.
@@ -377,9 +383,15 @@ async def get_savings_plans_utilization(
         formatted_response: Dict[str, Any] = {
             'savings_plans_utilizations': utilizations_by_time,
             # The API has no top-level period. A MONTHLY entry's TimePeriod is labelled with its
-            # calendar month even when the requested start falls later in that month.
+            # whole calendar month even when the requested start or end falls inside that month.
             'requested_time_period': {'start': start, 'end': end},
             'granularity': granularity,
+            **monthly_period_note(
+                start,
+                end,
+                [entry.get('TimePeriod') for entry in utilizations_by_time],
+                granularity,
+            ),
         }
 
         if total is not None: