greenpick 0.6.2__tar.gz → 0.7.0__tar.gz

{greenpick-0.6.2/src/greenpick.egg-info → greenpick-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.6.2
+Version: 0.7.0
 Summary: Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs.
 Author-email: "Data Science Advisers, LLC" <info@datascienceadvisers.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT" />
   <img src="https://img.shields.io/badge/tests-passing-brightgreen" alt="Tests: passing" />
   <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python 3.11+" />
-  <img src="https://img.shields.io/badge/MCP%20tools-19-0ea5e9" alt="MCP tools: 19" />
+  <img src="https://img.shields.io/badge/MCP%20tools-20-0ea5e9" alt="MCP tools: 20" />
 </p>
 
 A **design-time sustainability co-pilot** that runs as an MCP server inside your vibe-coding
@@ -52,7 +52,7 @@ environment (Cursor / Claude Code / Kiro). Ask it where to deploy, when to run a
 right-size — and it answers with an honest **carbon + cost + latency** tradeoff, in-editor, in
 seconds. (It responds when you ask; auto-nudging on infra-code changes is on the roadmap.)
 
-> **Status: working — 19 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
+> **Status: working — 20 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
 > IESO — no key needed), cross-cloud cost
 > parity (Vantage-refreshed), per-axis R/Y/G ratings, carbon-aware scheduling + day-ahead forecast,
 > GPU-training **and LLM-inference** carbon, right-sizing, serving-pattern and data-locality/residency
@@ -143,7 +143,7 @@ See `docs/user-questions-backlog.md`.
 
 ## MCP tools
 
-19 tools, grouped by what you're trying to do.
+20 tools, grouped by what you're trying to do.
 
 ### Pick a region
 
@@ -176,6 +176,7 @@ See `docs/user-questions-backlog.md`.
 |------|--------------|
 | `greener_instance_family` | A greener same-size family in the same region via perf-per-watt (newer generation / ARM Graviton-class does the same work on less energy). |
 | `rightsizing_check` | Right-sizing (the #1 FinOps win) with a carbon twin: if you're over-provisioned, a smaller size cuts **both** cost and carbon → the right-sized target with monthly $ and kg CO₂ saving. |
+| `serverless_check` | For a mostly idle or spiky service: an always-on server vs. paying per request (AWS Lambda, Cloud Run). Monthly cost of each, the break-even request count, and estimated carbon (serverless as a lower bound). |
 | `offhours_check` | For dev/test/staging that doesn't need to run 24/7: the monthly $ and kg CO2 saved by running it only N hours a week. Compute only, directional. |
 | `data_locality_egress_check` | Warn when running compute away from where your data lives backfires: directional egress $ + coarse transfer carbon, and whether a greener-region move is still a net win. |
 | `migration_payoff` | Does moving the **data** to the compute's region pay off? Payback in months, one-off vs monthly egress and transfer carbon, net over 12 months. Egress only. |
@@ -226,6 +227,8 @@ flow-traced consumption. Cost is a ballpark, not a quote. Latency is a geographi
 
 ## Quick start
 
+<a href="https://mcprush.com/bithug01/greenpick-mcp"><img src="https://mcprush.com/badge/greenpick-mcp/card.svg" width="220" alt="GreenPick MCP server on mcprush" /></a>
+
 ```bash
 # Python 3.11+
 pip install greenpick          # from PyPI

{greenpick-0.6.2 → greenpick-0.7.0}/README.md

@@ -14,7 +14,7 @@
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT" />
   <img src="https://img.shields.io/badge/tests-passing-brightgreen" alt="Tests: passing" />
   <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python 3.11+" />
-  <img src="https://img.shields.io/badge/MCP%20tools-19-0ea5e9" alt="MCP tools: 19" />
+  <img src="https://img.shields.io/badge/MCP%20tools-20-0ea5e9" alt="MCP tools: 20" />
 </p>
 
 A **design-time sustainability co-pilot** that runs as an MCP server inside your vibe-coding
@@ -22,7 +22,7 @@ environment (Cursor / Claude Code / Kiro). Ask it where to deploy, when to run a
 right-size — and it answers with an honest **carbon + cost + latency** tradeoff, in-editor, in
 seconds. (It responds when you ask; auto-nudging on infra-code changes is on the roadmap.)
 
-> **Status: working — 19 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
+> **Status: working — 20 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
 > IESO — no key needed), cross-cloud cost
 > parity (Vantage-refreshed), per-axis R/Y/G ratings, carbon-aware scheduling + day-ahead forecast,
 > GPU-training **and LLM-inference** carbon, right-sizing, serving-pattern and data-locality/residency
@@ -113,7 +113,7 @@ See `docs/user-questions-backlog.md`.
 
 ## MCP tools
 
-19 tools, grouped by what you're trying to do.
+20 tools, grouped by what you're trying to do.
 
 ### Pick a region
 
@@ -146,6 +146,7 @@ See `docs/user-questions-backlog.md`.
 |------|--------------|
 | `greener_instance_family` | A greener same-size family in the same region via perf-per-watt (newer generation / ARM Graviton-class does the same work on less energy). |
 | `rightsizing_check` | Right-sizing (the #1 FinOps win) with a carbon twin: if you're over-provisioned, a smaller size cuts **both** cost and carbon → the right-sized target with monthly $ and kg CO₂ saving. |
+| `serverless_check` | For a mostly idle or spiky service: an always-on server vs. paying per request (AWS Lambda, Cloud Run). Monthly cost of each, the break-even request count, and estimated carbon (serverless as a lower bound). |
 | `offhours_check` | For dev/test/staging that doesn't need to run 24/7: the monthly $ and kg CO2 saved by running it only N hours a week. Compute only, directional. |
 | `data_locality_egress_check` | Warn when running compute away from where your data lives backfires: directional egress $ + coarse transfer carbon, and whether a greener-region move is still a net win. |
 | `migration_payoff` | Does moving the **data** to the compute's region pay off? Payback in months, one-off vs monthly egress and transfer carbon, net over 12 months. Egress only. |
@@ -196,6 +197,8 @@ flow-traced consumption. Cost is a ballpark, not a quote. Latency is a geographi
 
 ## Quick start
 
+<a href="https://mcprush.com/bithug01/greenpick-mcp"><img src="https://mcprush.com/badge/greenpick-mcp/card.svg" width="220" alt="GreenPick MCP server on mcprush" /></a>
+
 ```bash
 # Python 3.11+
 pip install greenpick          # from PyPI

{greenpick-0.6.2 → greenpick-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "greenpick"
-version = "0.6.2"
+version = "0.7.0"
 description = "Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs."
 readme = "README.md"
 requires-python = ">=3.11"

{greenpick-0.6.2 → greenpick-0.7.0}/src/greenpick/__init__.py

@@ -4,7 +4,7 @@ Greener cloud-region choices with honest carbon + cost + latency tradeoffs,
 delivered inside the vibe-coding loop. Directional guidance, not audited accounting.
 """
 
-__version__ = "0.6.2"
+__version__ = "0.7.0"
 
 # httpx logs every request URL at INFO, and our live sources pass their API key / token as a URL
 # query parameter — so at the default log level the secret would land in the MCP client's logs.

greenpick-0.7.0/src/greenpick/data/power.json

@@ -0,0 +1,21 @@
+{
+  "_comment": "Simple, documented power model for the carbon ESTIMATE. Turns a workload (vCPU, RAM) into average watts, then kWh/month. These are deliberately rough published-style coefficients; this is an estimate, not a measurement. PUE is the datacenter overhead multiplier.",
+  "watts_per_vcpu": 3.5,
+  "watts_per_gb_ram": 0.4,
+  "pue_default": 1.2,
+  "_sources": "Coefficients are order-of-magnitude figures consistent with public cloud power-model literature (e.g. Cloud Carbon Footprint methodology). Replace with cited values before any non-directional use.",
+  "_utilization_comment": "Used only when a caller gives a CPU utilisation. Per-vCPU power scales from an idle minimum to a full-load maximum: watts = min + utilisation x (max - min) (the Cloud Carbon Footprint / Etsy Cloud Jewels method). Without a utilisation GreenPick keeps the flat watts_per_vcpu above, which equals the AWS full-load figure, so it is a conservative (high) estimate. RAM watts do not change with load.",
+  "min_watts_per_vcpu": {
+    "aws": 0.74,
+    "gcp": 0.71,
+    "azure": 0.78
+  },
+  "max_watts_per_vcpu": {
+    "aws": 3.5,
+    "gcp": 4.26,
+    "azure": 3.76
+  },
+  "serverless_assumed_utilization": 0.5,
+  "serverless_mb_per_vcpu": 1792,
+  "_utilization_sources": "Cloud Carbon Footprint methodology, average min/max watts per vCPU by provider from SPECpower (https://www.cloudcarbonfootprint.org/docs/methodology/), checked 2026-11-10. Serverless: CCF's Lambda approach (1,792 MB = 1 vCPU; 50% average utilisation for hyperscale servers)."
+}

greenpick-0.7.0/src/greenpick/data/pricing.json

@@ -0,0 +1,65 @@
+{
+  "_comment": "DATED, STATIC pricing ballpark for v1. Deterministic — the LLM must never invent these. Figures are rough on-demand approximations for a general-purpose vCPU+RAM service and per-GB internet egress; refresh periodically and update _as_of. NOT a quote.",
+  "_as_of": "2026-10-12",
+  "_units": {
+    "compute": "USD per vCPU-hour and USD per GB-RAM-hour",
+    "egress": "USD per GB to internet"
+  },
+  "_egress_comment": "Egress is NOT one price — it's a tier ladder by WHERE the bytes cross. We price the locality tier (same-region / cross-region / cross-cloud+internet) as a LOW-HIGH RANGE because region-pair rates vary. Per-GB, USD, DIRECTIONAL list prices as of _as_of; excludes free-tier allowances, committed-use/negotiated discounts, and NAT/load-balancer processing fees. Not a quote. Keys: internet rate stays per-provider (differs most); same-region & cross-region tiers are broadly consistent across AWS/GCP/Azure so we use one shared range.",
+  "_egress_tiers_usd_per_gb": {
+    "same_region": {
+      "low": 0.0,
+      "high": 0.01,
+      "note": "Same region: free within an AZ over private IP; ~$0.01/GB each way if it crosses AZs."
+    },
+    "cross_region_same_cloud": {
+      "low": 0.01,
+      "high": 0.02,
+      "note": "Inter-region within one cloud: most pairs ~$0.01-0.02/GB; a few source regions/continent pairs run higher."
+    },
+    "cross_cloud": {
+      "low": 0.085,
+      "high": 0.12,
+      "note": "Leaving the cloud to another provider or the public internet: the expensive tier; GCP Premium ~$0.12, AWS ~$0.09, Azure ~$0.087 at entry bands."
+    }
+  },
+  "_egress_sources": "AWS/GCP/Azure published data-transfer pricing pages + corroborating 2026 guides (usage.ai, nops.io, egresscost.com, redresscompliance, bacancy, tatacommunications). Rounded to ranges; verify against the provider pricing page for a specific region pair.",
+  "aws": {
+    "compute_usd_per_vcpu_hour": 0.0469,
+    "compute_usd_per_gb_ram_hour": 0.0039,
+    "egress_usd_per_gb": 0.09
+  },
+  "gcp": {
+    "compute_usd_per_vcpu_hour": 0.0438,
+    "compute_usd_per_gb_ram_hour": 0.0037,
+    "egress_usd_per_gb": 0.085
+  },
+  "azure": {
+    "compute_usd_per_vcpu_hour": 0.0472,
+    "compute_usd_per_gb_ram_hour": 0.0039,
+    "egress_usd_per_gb": 0.087
+  },
+  "_source": "Compute coefficients for [aws+azure+gcp] derived from Vantage live data using ONE matched method: general-purpose 4GB/vCPU families (AWS m5/m6i, GCP n2-standard, Azure D-series v5), on-demand Linux, mean $/vCPU across regions, 25% split to RAM. Egress remains static. Apples-to-apples DIRECTIONAL comparison, not a quote.",
+  "_serverless_usd": {
+    "_as_of": "2026-11-10",
+    "_comment": "On-demand list prices for request-driven serverless compute, before free tiers and discounts. DIRECTIONAL, not a quote. Azure Functions prices are not bundled (the public page renders prices client-side and could not be verified).",
+    "aws": {
+      "product": "AWS Lambda (event functions, x86, first tier)",
+      "usd_per_gb_second": 1.66667e-05,
+      "usd_per_million_requests": 0.2,
+      "free_requests": 1000000,
+      "free_gb_seconds": 400000,
+      "source": "https://aws.amazon.com/lambda/pricing/"
+    },
+    "gcp": {
+      "product": "Cloud Run (request-based billing, tier 1)",
+      "usd_per_vcpu_second": 2.4e-05,
+      "usd_per_gib_second": 2.5e-06,
+      "usd_per_million_requests": 0.4,
+      "free_requests": 2000000,
+      "free_vcpu_seconds": 180000,
+      "free_gib_seconds": 360000,
+      "source": "https://cloud.google.com/run/pricing"
+    }
+  }
+}

{greenpick-0.6.2 → greenpick-0.7.0}/src/greenpick/server.py

@@ -1,4 +1,4 @@
-"""MCP server: exposes GreenPick's 19 tools over FastMCP.
+"""MCP server: exposes GreenPick's 20 tools over FastMCP.
 
 Thin layer — parse/validate inputs, call services, return JSON-friendly dicts. All math
 lives in services/; this file only wires tools to them.
@@ -26,10 +26,11 @@ from .services import (
     carbon_service, recommender, scheduling_service, instance_service, locality_service,
     training_service, forecast_service, serving_service, metric_scaffold_service,
     rightsizing_service, inference_service, offhours_service, typical_ranking_service,
-    justification_service, migration_service,
+    justification_service, migration_service, serverless_service,
 )
 from .models import ServingHub
 from .services.data_hint import with_hint
+from .services.sources import with_sources
 from .data.typical_repository import typical_context
 
 # Sent to every MCP client at connect. Agents learn a server from its tool list, not its README, and
@@ -40,7 +41,8 @@ GreenPick advises on cloud infrastructure decisions BEFORE you deploy, weighing
 latency together. Strongest uses, in order:
 1. Right-sizing (rightsizing_check): an over-provisioned instance cut to a standard, buyable size \
 saves money and carbon in the same move. Lead with the monthly dollar saving. For dev, test or other \
-environments that don't need to run 24/7, offhours_check shows what switching them off saves.
+environments that don't need to run 24/7, offhours_check shows what switching them off saves. For a \
+mostly idle or spiky service, serverless_check compares an always-on server with paying per request.
 2. Scheduling deferrable jobs: cleanest_hours_to_run (one-off), cleanest_time_of_day (recurring), \
 carbon_forecast (EU day-ahead).
 3. GPU training and LLM inference footprints: estimate_training_carbon (gpu_hours is the TOTAL across \
@@ -54,7 +56,8 @@ for a pull request, use region_move_justification.
 Every carbon figure carries source and quality fields. Report 'typical', 'mock', 'cached' or \
 'historical' values as such, never as live readings — including figures derived from them, such as a kg CO2 saving. \
 When a result includes live_data_hint, pass it on: it says why the data isn't live and how to turn \
-live data on. If a call fails or output is missing, say so rather than describing \
+live data on. Results with carbon or cost figures include verify_at: the public page behind each \
+figure, for anyone who wants to check it. If a call fails or output is missing, say so rather than describing \
 what the tool would return. GreenPick estimates; it does not measure running systems or report model \
 accuracy. Use explain_methodology_and_limits when asked how a number was produced.\
 """
@@ -146,13 +149,19 @@ async def estimate_workload_carbon(
     vcpu: float,
     ram_gb: float,
     hours_per_month: float = 730,
+    avg_cpu_utilization: Optional[float] = None,
 ) -> dict:
     """Rough kgCO2/month for a workload running in a region. An ESTIMATE (documented power
-    model x grid intensity), not a measurement."""
+    model x grid intensity), not a measurement. Without avg_cpu_utilization it assumes the CPU is
+    fully busy (a conservative, high figure). Pass the observed average CPU utilisation as a fraction
+    (0.1 for 10%) for a more realistic figure: an idle server draws far less than a busy one."""
+    err = _fraction_error("avg_cpu_utilization", avg_cpu_utilization, allow_zero=True)
+    if err:
+        return {"provider": provider, "region": region, "error": err}
     reading = await carbon_service.carbon_now(_repo, provider, region)  # type: ignore[arg-type]
     wl = Workload(vcpu=vcpu, ram_gb=ram_gb, hours_per_month=hours_per_month)
     kg = carbon_service.estimate_kg_co2_per_month(wl, reading)
-    return with_hint({
+    out = {
         "provider": provider,
         "region": region,
         "estimated_kg_co2_per_month": kg,
@@ -160,7 +169,15 @@ async def estimate_workload_carbon(
         "carbon_source": reading.source,
         "carbon_quality": reading.quality,
         "note": "Estimate only: documented power model x grid intensity. Not a measurement.",
-    })
+    }
+    if avg_cpu_utilization is not None:
+        out["estimated_kg_co2_per_month_at_full_load"] = kg
+        out["estimated_kg_co2_per_month"] = carbon_service.estimate_kg_co2_per_month_at(
+            wl, reading, avg_cpu_utilization)
+        out["avg_cpu_utilization"] = avg_cpu_utilization
+        out["note"] = ("Estimate only. CPU power follows the utilisation you gave (Cloud Carbon Footprint "
+                       "min/max watts per vCPU); RAM power does not change with load. Not a measurement.")
+    return with_hint(out)
 
 
 @mcp.tool(annotations=LIVE_DATA_TOOL)
@@ -271,6 +288,37 @@ async def rightsizing_check(
     return with_hint(advice.model_dump())
 
 
+@mcp.tool(annotations=LIVE_DATA_TOOL)
+async def serverless_check(
+    provider: str,
+    region: str,
+    vcpu: float,
+    ram_gb: float,
+    avg_cpu_utilization: float,
+    monthly_requests: float,
+    avg_duration_ms: float,
+    function_memory_gb: float = 1.0,
+) -> dict:
+    """Would serverless change the math? Compares an always-on server (its size and observed average CPU
+    utilisation as a fraction, 0.05 for 5%) with a request-driven serverless platform (AWS Lambda or
+    Google Cloud Run) for the same traffic: monthly requests, average duration per request in ms, and the
+    function's memory in GB. Returns the monthly cost of each, the request count where they break even,
+    and estimated carbon for each. Lead with the dollar figure. Serverless carbon is a LOWER BOUND
+    (platform overhead isn't published); cost is list price before free tiers. Azure serverless cost is
+    not priced (carbon only). Ask the user for traffic figures rather than assuming them."""
+    err = _fraction_error("avg_cpu_utilization", avg_cpu_utilization, allow_zero=True)
+    if err:
+        return {"provider": provider, "region": region, "error": err}
+    if monthly_requests < 0 or avg_duration_ms <= 0 or not 0.125 <= function_memory_gb <= 10.24:
+        return {"provider": provider, "region": region,
+                "error": "monthly_requests must be >= 0, avg_duration_ms > 0, and function_memory_gb "
+                         "between 0.125 and 10.24 (Lambda's range)."}
+    return with_hint(await serverless_service.serverless_check(
+        _repo, provider, region, vcpu, ram_gb, avg_cpu_utilization,
+        monthly_requests, avg_duration_ms, function_memory_gb,
+    ))
+
+
 @mcp.tool(annotations=LIVE_DATA_TOOL)
 async def offhours_check(
     provider: str,
@@ -308,9 +356,9 @@ def greenest_regions_on_average(
     norm rather than a single hour; use region_carbon_now for what the grid is doing today. Carbon only
     (no cost or latency; compare_regions_tri_axis weighs all three). Offline, needs no keys. Regions
     labelled annual_average have only a yearly national figure and are not month-specific."""
-    return typical_ranking_service.rank_regions(
+    return with_sources(typical_ranking_service.rank_regions(
         month=month, whole_year=whole_year, providers=providers, regions=regions, top_n=top_n,
-    )
+    ))
 
 
 @mcp.tool(annotations=LIVE_DATA_TOOL)

greenpick-0.7.0/src/greenpick/services/carbon_service.py

@@ -0,0 +1,51 @@
+"""Carbon readings (via the repository) + a workload CO2 ESTIMATE.
+
+The estimate turns a workload into average watts (power model) -> kWh/month ->
+multiply by grid intensity. Clearly an estimate, not a measurement.
+"""
+from __future__ import annotations
+
+from ..models import CarbonReading, Workload, Provider
+from ..data.repository import CarbonRepository
+from ..data.static_data import power_model
+
+
+async def carbon_now(repo: CarbonRepository, provider: Provider, region: str) -> CarbonReading:
+    return await repo.carbon_now(provider, region)
+
+
+def workload_kwh_per_month(workload: Workload) -> float:
+    pm = power_model()
+    watts = workload.vcpu * pm["watts_per_vcpu"] + workload.ram_gb * pm["watts_per_gb_ram"]
+    watts *= pm["pue_default"]
+    kwh = watts / 1000.0 * workload.hours_per_month
+    return kwh
+
+
+def estimate_kg_co2_per_month(workload: Workload, reading: CarbonReading) -> float:
+    kwh = workload_kwh_per_month(workload)
+    grams = kwh * reading.g_co2_per_kwh
+    return round(grams / 1000.0, 2)
+
+
+def watts_per_vcpu_at(provider: str, cpu_utilization: float) -> float:
+    """Average watts per vCPU at a given CPU utilisation (0..1): idle minimum plus the load share of
+    the gap to full load (Cloud Carbon Footprint method). Unknown providers use the AWS range."""
+    pm = power_model()
+    lo = pm["min_watts_per_vcpu"].get(provider, pm["min_watts_per_vcpu"]["aws"])
+    hi = pm["max_watts_per_vcpu"].get(provider, pm["max_watts_per_vcpu"]["aws"])
+    u = max(0.0, min(1.0, cpu_utilization))
+    return lo + u * (hi - lo)
+
+
+def workload_kwh_per_month_at(workload: Workload, provider: str, cpu_utilization: float) -> float:
+    """Like workload_kwh_per_month, but CPU power follows utilisation instead of assuming full load.
+    RAM power is unchanged (memory draws roughly the same whether busy or not)."""
+    pm = power_model()
+    watts = workload.vcpu * watts_per_vcpu_at(provider, cpu_utilization) + workload.ram_gb * pm["watts_per_gb_ram"]
+    return watts * pm["pue_default"] / 1000.0 * workload.hours_per_month
+
+
+def estimate_kg_co2_per_month_at(workload: Workload, reading: CarbonReading, cpu_utilization: float) -> float:
+    kwh = workload_kwh_per_month_at(workload, reading.provider, cpu_utilization)
+    return round(kwh * reading.g_co2_per_kwh / 1000.0, 2)

{greenpick-0.6.2 → greenpick-0.7.0}/src/greenpick/services/data_hint.py

@@ -180,8 +180,10 @@ def build_hint(result: dict) -> Optional[str]:
 
 
 def with_hint(result: dict) -> dict:
-    """Add `live_data_hint` to a tool result that uses fallback data; leave others unchanged."""
+    """Add `live_data_hint` to a tool result that uses fallback data, and `verify_at` (where to check
+    its carbon and cost figures) to any result that has them. Existing fields are left unchanged."""
+    from .sources import with_sources
     hint = build_hint(result)
     if hint:
         result["live_data_hint"] = hint
-    return result
+    return with_sources(result)

{greenpick-0.6.2 → greenpick-0.7.0}/src/greenpick/services/justification_service.py

@@ -122,7 +122,11 @@ async def region_move_justification(
     if net_kg is not None:
         cost_part = (f" and about ${egress_low:,.0f}-${egress_high:,.0f} a month in egress"
                      if egress_low is not None else "")
-        if net_kg > 0:
+        if kg_saving <= 0:
+            parts.append(
+                f"The data stays in {from_provider}/{from_region} (~{monthly_cross_boundary_gb:,.0f} GB a "
+                f"month crossing), which adds about {transfer_kg:.1f} kg CO2{cost_part} on top.")
+        elif net_kg > 0:
             parts.append(
                 f"The data stays in {from_provider}/{from_region} (~{monthly_cross_boundary_gb:,.0f} GB a "
                 f"month crossing), which adds about {transfer_kg:.1f} kg CO2{cost_part}, "

greenpick-0.7.0/src/greenpick/services/serverless_service.py

@@ -0,0 +1,144 @@
+"""Would serverless change the math? An always-on server vs. paying only for the time code runs.
+
+A mostly idle service on an always-on server pays (and draws power) around the clock, even when it is
+doing nothing. A request-driven serverless platform (AWS Lambda, Google Cloud Run) charges, and keeps
+hardware busy, only while requests run. Which is cheaper depends on how much traffic there is: low or
+spiky traffic favours serverless, steady high traffic favours a server. This compares the two on cost
+and on estimated carbon, and gives the monthly request count where they break even on cost.
+
+Directional on both axes. The server side uses the utilisation-aware power model (Cloud Carbon
+Footprint min/max watts per vCPU). The serverless side counts only the compute time requests run, at
+the CCF Lambda assumptions (1,792 MB of memory = 1 vCPU, 50% average utilisation), so it is a LOWER
+BOUND: platform overhead such as warm instances and control planes is not published and is not
+included. Prices are dated on-demand list prices, before free tiers and discounts.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from ..data.repository import CarbonRepository
+from ..data.static_data import power_model, pricing
+from ..models import Workload
+from . import carbon_service, cost_service
+
+HOURS_PER_MONTH = 730
+
+
+def _serverless_cost(provider: str, requests: float, active_seconds: float, memory_gb: float,
+                     vcpu_equiv: float) -> tuple[Optional[float], Optional[float]]:
+    """(cost, cost per million requests) for a month, before free tiers; (None, None) if unpriced."""
+    p = (pricing().get("_serverless_usd") or {}).get(provider)
+    if not p:
+        return None, None
+    if provider == "aws":
+        per_req_compute = (active_seconds / requests if requests else 0) * memory_gb * p["usd_per_gb_second"]
+    else:   # gcp, Cloud Run request-based: vCPU-seconds + GiB-seconds while requests run
+        per_req_compute = ((active_seconds / requests if requests else 0)
+                           * (vcpu_equiv * p["usd_per_vcpu_second"] + memory_gb * p["usd_per_gib_second"]))
+    per_req = per_req_compute + p["usd_per_million_requests"] / 1e6
+    return round(per_req * requests, 2), per_req * 1e6
+
+
+async def serverless_check(
+    repo: CarbonRepository,
+    provider: str,
+    region: str,
+    vcpu: float,
+    ram_gb: float,
+    avg_cpu_utilization: float,
+    monthly_requests: float,
+    avg_duration_ms: float,
+    function_memory_gb: float = 1.0,
+) -> dict:
+    pm = power_model()
+    reading = await carbon_service.carbon_now(repo, provider, region)   # type: ignore[arg-type]
+
+    # Always-on server: the bill for every hour, and power that follows its real utilisation.
+    vm = Workload(vcpu=vcpu, ram_gb=ram_gb, hours_per_month=HOURS_PER_MONTH)
+    vm_cost = cost_service.estimate_monthly_cost_usd(provider, vm)      # type: ignore[arg-type]
+    vm_kg = carbon_service.estimate_kg_co2_per_month_at(vm, reading, avg_cpu_utilization)
+    vm_kg_full = carbon_service.estimate_kg_co2_per_month(vm, reading)
+
+    # Serverless: only the time requests run, with CPU allocated in proportion to memory.
+    active_seconds = monthly_requests * avg_duration_ms / 1000.0
+    active_hours = active_seconds / 3600.0
+    vcpu_equiv = min(6.0, function_memory_gb * 1024 / pm["serverless_mb_per_vcpu"])
+    sl = Workload(vcpu=max(vcpu_equiv, 1e-6), ram_gb=function_memory_gb, hours_per_month=max(active_hours, 1e-9))
+    sl_kg = (carbon_service.estimate_kg_co2_per_month_at(sl, reading, pm["serverless_assumed_utilization"])
+             if active_hours > 0 else 0.0)
+    sl_cost, per_million = _serverless_cost(provider, monthly_requests, active_seconds, function_memory_gb, vcpu_equiv)
+
+    breakeven = None
+    if vm_cost is not None and per_million:
+        breakeven = round(vm_cost / per_million * 1e6)
+    cost_saving = round(vm_cost - sl_cost, 2) if vm_cost is not None and sl_cost is not None else None
+    cost_pct = round(cost_saving / vm_cost * 100, 1) if cost_saving is not None and vm_cost else None
+    kg_saving = round(vm_kg - sl_kg, 2)
+    carbon_pct = round(kg_saving / vm_kg * 100, 1) if vm_kg > 0 else None
+
+    # Does this traffic fit inside the provider's monthly free tier? Then the real bill could be $0.
+    free = (pricing().get("_serverless_usd") or {}).get(provider) or {}
+    in_free_tier = None
+    if free:
+        req_ok = monthly_requests <= free.get("free_requests", 0)
+        if provider == "aws":
+            use_ok = active_seconds * function_memory_gb <= free.get("free_gb_seconds", 0)
+        else:
+            use_ok = (active_seconds * vcpu_equiv <= free.get("free_vcpu_seconds", 0)
+                      and active_seconds * function_memory_gb <= free.get("free_gib_seconds", 0))
+        in_free_tier = bool(req_ok and use_ok)
+
+    if cost_saving is None:
+        cost_txt = ("Serverless cost isn't priced for this provider in GreenPick (check the provider's pricing "
+                    "page); the comparison below is carbon only.")
+        verdict = "carbon_only"
+    elif cost_saving > 0:
+        cost_txt = (f"Serverless would cost about ${sl_cost:,.2f} a month against ${vm_cost:,.2f} for the always-on "
+                    f"server: about ${cost_saving:,.0f} a month less ({cost_pct:.0f}%).")
+        verdict = "serverless_cheaper"
+    else:
+        cost_txt = (f"Serverless would cost about ${sl_cost:,.2f} a month against ${vm_cost:,.2f} for the always-on "
+                    f"server: about ${-cost_saving:,.0f} a month MORE. At this traffic a server is the cheaper choice.")
+        verdict = "server_cheaper"
+    free_txt = (" This traffic fits within the provider's monthly free tier, so the actual serverless bill "
+                "could be $0." if in_free_tier else "")
+    be_txt = (f" They break even at about {breakeven:,} requests a month at this duration and memory; above that, "
+              "the server wins on cost." if breakeven else "")
+    summary = (f"{cost_txt}{free_txt}{be_txt} Estimated carbon: about {sl_kg:.2f} kg CO2 a month serverless (a lower bound) "
+               f"against {vm_kg:.2f} kg for the server at {avg_cpu_utilization * 100:.0f}% CPU use "
+               f"({reading.quality} grid data).")
+
+    return {
+        "summary": summary,
+        "verdict": verdict,
+        "provider": provider,
+        "region": region,
+        "server": {"vcpu": vcpu, "ram_gb": ram_gb, "avg_cpu_utilization": avg_cpu_utilization,
+                   "hours_per_month": HOURS_PER_MONTH},
+        "serverless": {"monthly_requests": monthly_requests, "avg_duration_ms": avg_duration_ms,
+                       "function_memory_gb": function_memory_gb, "vcpu_equivalent": round(vcpu_equiv, 2),
+                       "billed_hours_per_month": round(active_hours, 1)},
+        "server_cost_usd_per_month": vm_cost,
+        "serverless_cost_usd_per_month": sl_cost,
+        "monthly_usd_saving": cost_saving,
+        "cost_saving_pct": cost_pct,
+        "breakeven_monthly_requests": breakeven,
+        "within_free_tier": in_free_tier,
+        "server_kg_co2_per_month": vm_kg,
+        "server_kg_co2_per_month_at_full_load": vm_kg_full,
+        "serverless_kg_co2_per_month_lower_bound": sl_kg,
+        "monthly_kg_co2_saving": kg_saving,
+        "carbon_saving_pct": carbon_pct,
+        "carbon_source": reading.source,
+        "carbon_quality": reading.quality,
+        "limitations": (
+            "Directional. Serverless bills each request's full duration, including time spent waiting on a "
+            "database or another service, while a server handles many requests at once, so I/O-heavy services "
+            "favour a server more than these figures suggest. Serverless cost is on-demand list price before free tiers (AWS gives 1M requests and "
+            "400,000 GB-seconds a month free; Cloud Run 2M requests and some vCPU/GiB-seconds), and excludes "
+            "API gateway, data transfer and provisioned-concurrency charges. Serverless carbon counts only the "
+            "time requests run and leaves out platform overhead such as warm instances, so it is a lower bound. "
+            "The server side assumes on-demand pricing; reserved capacity and savings plans change the cost. "
+            "Cold starts, request time limits and concurrency limits can rule serverless out regardless of price. "
+            "Power follows Cloud Carbon Footprint's min/max watts per vCPU."),
+    }

greenpick-0.7.0/src/greenpick/services/sources.py

@@ -0,0 +1,109 @@
+"""Where to check a number: the primary source behind each figure GreenPick reports.
+
+GreenPick's estimates are directional, and its results say so. "Go and verify" is only useful if
+it says WHERE, so every result that contains a carbon figure or a dollar figure also gets a short
+`verify_at` list: which kind of figure, what it is based on, and the public page to check it against.
+
+Kept deliberately small and stable: top-level pages that publish the data (grid operators, the
+cloud providers' own pricing pages), not deep links that move. Additive only: it never changes or
+removes an existing field.
+"""
+from __future__ import annotations
+
+from typing import Any, Iterator
+
+# Carbon: the base source name (after stripping "typical_") -> (what it is, where to check it).
+_CARBON = {
+    "eia": ("US grid data from EIA-930 (hourly generation by fuel)",
+            "https://www.eia.gov/electricity/gridmonitor/"),
+    "entsoe": ("EU grid data from the ENTSO-E Transparency Platform (generation by fuel)",
+               "https://transparency.entsoe.eu/"),
+    "hq": ("Québec grid data from Hydro-Québec open data", "https://donnees.hydroquebec.com/"),
+    "ieso": ("Ontario grid data from IESO", "https://www.ieso.ca/en/Power-Data"),
+    "ember_annual": ("Yearly national grid intensity from Ember, via Our World in Data",
+                     "https://ourworldindata.org/grapher/carbon-intensity-electricity"),
+    "electricitymaps": ("Grid data from Electricity Maps", "https://www.electricitymaps.com/"),
+}
+
+# Cost: provider -> (compute price page, data-transfer price page).
+_PRICING = {
+    "aws": ("https://aws.amazon.com/ec2/pricing/on-demand/",
+            "https://aws.amazon.com/ec2/pricing/on-demand/"),
+    "gcp": ("https://cloud.google.com/compute/vm-instance-pricing",
+            "https://cloud.google.com/vpc/network-pricing"),
+    "azure": ("https://azure.microsoft.com/en-us/pricing/details/virtual-machines/linux/",
+              "https://azure.microsoft.com/en-us/pricing/details/bandwidth/"),
+}
+_PROVIDER_NAME = {"aws": "AWS", "gcp": "Google Cloud", "azure": "Azure"}
+_SERVERLESS = {"aws": ("AWS Lambda", "https://aws.amazon.com/lambda/pricing/"),
+               "gcp": ("Cloud Run", "https://cloud.google.com/run/pricing"),
+               "azure": ("Azure Functions", "https://azure.microsoft.com/en-us/pricing/details/functions/")}
+
+_SOURCE_KEYS = ("source", "carbon_source", "transfer_carbon_source",
+                "from_carbon_source", "to_carbon_source")
+_PROVIDER_KEYS = ("provider", "compute_provider", "data_provider", "from_provider", "to_provider")
+_LOCATION_KEYS = ("recommended_region", "compute_location", "data_location", "from", "to")
+
+
+def _walk(obj: Any) -> Iterator[tuple[str, Any]]:
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            yield k, v
+            yield from _walk(v)
+    elif isinstance(obj, list):
+        for v in obj:
+            yield from _walk(v)
+
+
+def verify_at(result: dict) -> list[dict]:
+    """The primary sources behind the carbon and cost figures in a tool result (may be empty)."""
+    carbon: set[str] = set()
+    providers: set[str] = set()
+    has_cost = has_egress = has_serverless = False
+    for key, value in _walk(result):
+        if key in _SOURCE_KEYS and isinstance(value, str):
+            base = value[len("typical_"):] if value.startswith("typical_") else value
+            if base in _CARBON:
+                carbon.add(base)
+        elif key in _PROVIDER_KEYS and value in _PRICING:
+            providers.add(value)
+        elif key in _LOCATION_KEYS and isinstance(value, str) and "/" in value:
+            prov = value.split("/", 1)[0]
+            if prov in _PRICING:
+                providers.add(prov)
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            if "usd" not in key:
+                continue
+            if "serverless" in key:
+                has_serverless = True
+            elif "egress" in key:
+                has_egress = True
+            elif "cost" in key or "saving" in key:      # compute cost or a saving on it
+                has_cost = True
+
+    out: list[dict] = []
+    for base in sorted(carbon):
+        what, url = _CARBON[base]
+        out.append({"figure": "grid carbon intensity", "based_on": what, "url": url})
+    for prov in sorted(providers):
+        compute_url, transfer_url = _PRICING[prov]
+        name = _PROVIDER_NAME[prov]
+        if has_cost:
+            out.append({"figure": "compute cost", "based_on": f"{name} on-demand list prices (dated)",
+                        "url": compute_url})
+        if has_serverless:
+            product, url = _SERVERLESS[prov]
+            out.append({"figure": "serverless cost", "based_on": f"{product} list prices (dated)", "url": url})
+        if has_egress:
+            out.append({"figure": "data-transfer (egress) cost",
+                        "based_on": f"{name} data-transfer prices (dated)", "url": transfer_url})
+    return out
+
+
+def with_sources(result: dict) -> dict:
+    """Add `verify_at` to a result that contains carbon or cost figures; leave others unchanged."""
+    if isinstance(result, dict) and "error" not in result:
+        links = verify_at(result)
+        if links:
+            result["verify_at"] = links
+    return result

{greenpick-0.6.2 → greenpick-0.7.0/src/greenpick.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.6.2
+Version: 0.7.0
 Summary: Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs.
 Author-email: "Data Science Advisers, LLC" <info@datascienceadvisers.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT" />
   <img src="https://img.shields.io/badge/tests-passing-brightgreen" alt="Tests: passing" />
   <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python 3.11+" />
-  <img src="https://img.shields.io/badge/MCP%20tools-19-0ea5e9" alt="MCP tools: 19" />
+  <img src="https://img.shields.io/badge/MCP%20tools-20-0ea5e9" alt="MCP tools: 20" />
 </p>
 
 A **design-time sustainability co-pilot** that runs as an MCP server inside your vibe-coding
@@ -52,7 +52,7 @@ environment (Cursor / Claude Code / Kiro). Ask it where to deploy, when to run a
 right-size — and it answers with an honest **carbon + cost + latency** tradeoff, in-editor, in
 seconds. (It responds when you ask; auto-nudging on infra-code changes is on the roadmap.)
 
-> **Status: working — 19 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
+> **Status: working — 20 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
 > IESO — no key needed), cross-cloud cost
 > parity (Vantage-refreshed), per-axis R/Y/G ratings, carbon-aware scheduling + day-ahead forecast,
 > GPU-training **and LLM-inference** carbon, right-sizing, serving-pattern and data-locality/residency
@@ -143,7 +143,7 @@ See `docs/user-questions-backlog.md`.
 
 ## MCP tools
 
-19 tools, grouped by what you're trying to do.
+20 tools, grouped by what you're trying to do.
 
 ### Pick a region
 
@@ -176,6 +176,7 @@ See `docs/user-questions-backlog.md`.
 |------|--------------|
 | `greener_instance_family` | A greener same-size family in the same region via perf-per-watt (newer generation / ARM Graviton-class does the same work on less energy). |
 | `rightsizing_check` | Right-sizing (the #1 FinOps win) with a carbon twin: if you're over-provisioned, a smaller size cuts **both** cost and carbon → the right-sized target with monthly $ and kg CO₂ saving. |
+| `serverless_check` | For a mostly idle or spiky service: an always-on server vs. paying per request (AWS Lambda, Cloud Run). Monthly cost of each, the break-even request count, and estimated carbon (serverless as a lower bound). |
 | `offhours_check` | For dev/test/staging that doesn't need to run 24/7: the monthly $ and kg CO2 saved by running it only N hours a week. Compute only, directional. |
 | `data_locality_egress_check` | Warn when running compute away from where your data lives backfires: directional egress $ + coarse transfer carbon, and whether a greener-region move is still a net win. |
 | `migration_payoff` | Does moving the **data** to the compute's region pay off? Payback in months, one-off vs monthly egress and transfer carbon, net over 12 months. Egress only. |
@@ -226,6 +227,8 @@ flow-traced consumption. Cost is a ballpark, not a quote. Latency is a geographi
 
 ## Quick start
 
+<a href="https://mcprush.com/bithug01/greenpick-mcp"><img src="https://mcprush.com/badge/greenpick-mcp/card.svg" width="220" alt="GreenPick MCP server on mcprush" /></a>
+
 ```bash
 # Python 3.11+
 pip install greenpick          # from PyPI

{greenpick-0.6.2 → greenpick-0.7.0}/src/greenpick.egg-info/SOURCES.txt

@@ -50,7 +50,9 @@ src/greenpick/services/recommender.py
 src/greenpick/services/residency_service.py
 src/greenpick/services/rightsizing_service.py
 src/greenpick/services/scheduling_service.py
+src/greenpick/services/serverless_service.py
 src/greenpick/services/serving_service.py
+src/greenpick/services/sources.py
 src/greenpick/services/training_service.py
 src/greenpick/services/typical_ranking_service.py
 tests/test_services.py

{greenpick-0.6.2 → greenpick-0.7.0}/tests/test_services.py

@@ -1284,7 +1284,7 @@ def test_server_sends_instructions_that_lead_with_rightsizing():
     assert "mock" in text and "TOTAL" in text and "data_locality_egress_check" in text
     # Every tool named in the instructions actually exists.
     import re, asyncio
-    named = set(re.findall(r"\b[a-z]+(?:_[a-z]+)+\b", text)) - {"wall_clock_hours", "gpu_hours", "residency_note", "live_data_hint"}
+    named = set(re.findall(r"\b[a-z]+(?:_[a-z]+)+\b", text)) - {"wall_clock_hours", "gpu_hours", "residency_note", "live_data_hint", "verify_at"}
     registered = {t.name for t in asyncio.run(server.mcp.list_tools())}
     assert named <= registered, named - registered
 
@@ -1802,7 +1802,7 @@ def test_every_tool_declares_all_four_annotation_hints():
     import asyncio
     from greenpick import server
     tools = asyncio.run(server.mcp.list_tools())
-    assert len(tools) == 19
+    assert len(tools) == 20
     for t in tools:
         a = t.annotations
         assert a is not None, t.name
@@ -2033,3 +2033,126 @@ async def test_rightsizing_fraction_still_works_and_ram_is_checked(monkeypatch):
 async def test_training_rejects_percentage_utilization():
     r = await _tool("estimate_training_carbon")(gpu="a100", gpu_count=8, gpu_hours=40, utilization=60)
     assert "error" in r and "Did you mean 0.6?" in r["error"]
+
+
+# --- 0.6.3: verify_at says where to check each carbon and cost figure (additive only) ---
+def test_verify_at_maps_sources_and_costs():
+    from greenpick.services.sources import verify_at
+    r = {"carbon_source": "typical_eia", "provider": "aws", "cost_now_usd_per_month": 10.0}
+    figs = {(v["figure"], v["url"]) for v in verify_at(r)}
+    assert ("grid carbon intensity", "https://www.eia.gov/electricity/gridmonitor/") in figs
+    assert ("compute cost", "https://aws.amazon.com/ec2/pricing/on-demand/") in figs
+    eg = verify_at({"data_location": "gcp/us-east4", "est_monthly_egress_usd_low": 1.0, "transfer_carbon_source": "ember_annual"})
+    assert {v["figure"] for v in eg} == {"data-transfer (egress) cost", "grid carbon intensity"}
+    assert verify_at({"provider": "aws", "net_over_horizon_usd_low": 3.0}) == []   # not a compute cost
+    assert verify_at({"note": "nothing to check"}) == []
+
+
+@pytest.mark.asyncio
+async def test_tools_add_verify_at_but_not_on_errors(monkeypatch):
+    from greenpick import server
+    monkeypatch.setattr(server, "_repo", TypicalCarbonRepository())
+    r = await _tool("rightsizing_check")(provider="aws", region="us-east-1", vcpu=8, ram_gb=32, cpu_utilization=0.15)
+    assert {v["figure"] for v in r["verify_at"]} == {"grid carbon intensity", "compute cost"}
+    rank = _tool("greenest_regions_on_average")(month=7, regions=["us-west-2", "ap-northeast-1"])
+    assert any("ourworldindata" in v["url"] for v in rank["verify_at"])
+    bad = await _tool("rightsizing_check")(provider="aws", region="us-east-1", vcpu=8, ram_gb=32, cpu_utilization=15)
+    assert "error" in bad and "verify_at" not in bad
+
+
+# --- The notebook starter prompt (docs/using-from-a-notebook.md) relies on these fields. ---
+# Testers and workshop attendees run that prompt against whatever version pip installs, so a
+# release must never rename or drop them.
+@pytest.mark.asyncio
+async def test_fields_the_notebook_prompt_relies_on(monkeypatch):
+    from greenpick import server
+    monkeypatch.setattr(server, "_repo", TypicalCarbonRepository())
+    now = await _tool("region_carbon_now")(provider="aws", region="us-east-1")
+    assert {"source", "quality", "live_data_hint"} <= set(now)
+    eg = await _tool("data_locality_egress_check")(compute_provider="aws", compute_region="eu-north-1",
+                                                   data_provider="aws", data_region="us-east-1",
+                                                   monthly_cross_boundary_gb=100)
+    assert next(iter(eg)) == "summary" and eg["summary"].startswith("NO NET VERDICT")
+    assert {"residency_note", "limitations"} <= set(eg)
+    mp = await _tool("migration_payoff")("aws", "us-east-1", "aws", "eu-north-1", 2000, 300)
+    assert next(iter(mp)) == "summary" and "net_over_horizon_usd_low" in mp and "net_over_horizon_usd_high" in mp
+    pr = await _tool("region_move_justification")("aws", "us-east-1", "aws", "eu-north-1", 4, 16)
+    assert next(iter(pr)) == "summary" and pr["pr_text"]
+    off = await _tool("offhours_check")(provider="aws", region="us-east-1", vcpu=4, ram_gb=16, hours_per_week_on=50)
+    assert {"monthly_usd_saving", "limitations"} <= set(off)
+    assert "error" in await _tool("offhours_check")(provider="aws", region="us-east-1", vcpu=4, ram_gb=16, hours_per_week_on=200)
+    assert "error" in await _tool("rightsizing_check")(provider="aws", region="us-east-1", vcpu=8, ram_gb=32, cpu_utilization=15)
+
+
+@pytest.mark.asyncio
+async def test_reverse_pr_text_does_not_repeat_backfire():
+    from greenpick.services import justification_service as js
+    r = await js.region_move_justification(MockCarbonRepository(), "aws", "eu-north-1", "aws", "us-east-1",
+                                           4, 16, monthly_cross_boundary_gb=100)
+    assert "would RAISE" in r["pr_text"] and "backfires" not in r["pr_text"]
+    assert "unless the data moves too" not in r["pr_text"] and "on top." in r["pr_text"]
+
+
+# --- 0.7.0: utilisation-aware power and serverless_check ---
+def test_utilisation_power_spans_min_to_max_and_full_load_matches_flat_model():
+    from greenpick.services import carbon_service as cs
+    from greenpick.models import CarbonReading
+    assert cs.watts_per_vcpu_at("aws", 0) == 0.74 and cs.watts_per_vcpu_at("aws", 1) == 3.5
+    assert abs(cs.watts_per_vcpu_at("gcp", 0.5) - (0.71 + 0.5 * (4.26 - 0.71))) < 1e-9
+    wl = Workload(vcpu=4, ram_gb=16, hours_per_month=730)
+    rd = CarbonReading(region="us-east-1", provider="aws", g_co2_per_kwh=400, source="mock",
+                       timestamp="2026-11-10T00:00:00Z", quality="mock")
+    assert cs.estimate_kg_co2_per_month_at(wl, rd, 1.0) == cs.estimate_kg_co2_per_month(wl, rd)
+    assert cs.estimate_kg_co2_per_month_at(wl, rd, 0.05) < cs.estimate_kg_co2_per_month(wl, rd) / 2
+
+
+@pytest.mark.asyncio
+async def test_estimate_workload_carbon_utilisation_is_optional_and_additive(monkeypatch):
+    from greenpick import server
+    monkeypatch.setattr(server, "_repo", TypicalCarbonRepository())
+    plain = await _tool("estimate_workload_carbon")(provider="aws", region="us-east-1", vcpu=4, ram_gb=16)
+    assert "avg_cpu_utilization" not in plain and "estimated_kg_co2_per_month_at_full_load" not in plain
+    low = await _tool("estimate_workload_carbon")(provider="aws", region="us-east-1", vcpu=4, ram_gb=16,
+                                                 avg_cpu_utilization=0.05)
+    assert low["estimated_kg_co2_per_month_at_full_load"] == plain["estimated_kg_co2_per_month"]
+    assert low["estimated_kg_co2_per_month"] < plain["estimated_kg_co2_per_month"]
+    bad = await _tool("estimate_workload_carbon")(provider="aws", region="us-east-1", vcpu=4, ram_gb=16,
+                                                 avg_cpu_utilization=5)
+    assert "Did you mean 0.05?" in bad["error"]
+
+
+@pytest.mark.asyncio
+async def test_serverless_check_quiet_vs_busy_and_breakeven(monkeypatch):
+    from greenpick import server
+    monkeypatch.setattr(server, "_repo", TypicalCarbonRepository())
+    t = _tool("serverless_check")
+    quiet = await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.05,
+                    monthly_requests=1_000_000, avg_duration_ms=100, function_memory_gb=0.5)
+    assert next(iter(quiet)) == "summary" and quiet["verdict"] == "serverless_cheaper"
+    assert quiet["within_free_tier"] is True and "free tier" in quiet["summary"]
+    busy = await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.6,
+                   monthly_requests=100_000_000, avg_duration_ms=100, function_memory_gb=0.5)
+    assert busy["verdict"] == "server_cheaper" and busy["monthly_usd_saving"] < 0
+    # The break-even request count is where serverless cost meets the server's.
+    be = quiet["breakeven_monthly_requests"]
+    at_be = await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.05,
+                    monthly_requests=be, avg_duration_ms=100, function_memory_gb=0.5)
+    assert abs(at_be["serverless_cost_usd_per_month"] - at_be["server_cost_usd_per_month"]) < 0.05
+    assert {v["figure"] for v in quiet["verify_at"]} >= {"compute cost", "serverless cost"}
+    run = await t(provider="gcp", region="us-central1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.05,
+                  monthly_requests=1_000_000, avg_duration_ms=100, function_memory_gb=0.5)
+    assert run["serverless_cost_usd_per_month"] is not None
+
+
+@pytest.mark.asyncio
+async def test_serverless_check_azure_is_carbon_only_and_inputs_validated():
+    t = _tool("serverless_check")
+    az = await t(provider="azure", region="eastus", vcpu=2, ram_gb=4, avg_cpu_utilization=0.05,
+                 monthly_requests=1_000_000, avg_duration_ms=100)
+    assert az["verdict"] == "carbon_only" and az["serverless_cost_usd_per_month"] is None
+    assert "error" in await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=5,
+                              monthly_requests=1000, avg_duration_ms=100)
+    assert "error" in await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.1,
+                              monthly_requests=1000, avg_duration_ms=0)
+    assert "error" in await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.1,
+                              monthly_requests=1000, avg_duration_ms=100, function_memory_gb=64)

greenpick-0.6.2/src/greenpick/data/power.json

@@ -1,7 +0,0 @@
-{
-  "_comment": "Simple, documented power model for the carbon ESTIMATE. Turns a workload (vCPU, RAM) into average watts, then kWh/month. These are deliberately rough published-style coefficients; this is an estimate, not a measurement. PUE is the datacenter overhead multiplier.",
-  "watts_per_vcpu": 3.5,
-  "watts_per_gb_ram": 0.4,
-  "pue_default": 1.2,
-  "_sources": "Coefficients are order-of-magnitude figures consistent with public cloud power-model literature (e.g. Cloud Carbon Footprint methodology). Replace with cited values before any non-directional use."
-}

greenpick-0.6.2/src/greenpick/data/pricing.json

@@ -1,31 +0,0 @@
-{
-  "_comment": "DATED, STATIC pricing ballpark for v1. Deterministic \u2014 the LLM must never invent these. Figures are rough on-demand approximations for a general-purpose vCPU+RAM service and per-GB internet egress; refresh periodically and update _as_of. NOT a quote.",
-  "_as_of": "2026-10-12",
-  "_units": {
-    "compute": "USD per vCPU-hour and USD per GB-RAM-hour",
-    "egress": "USD per GB to internet"
-  },
-  "_egress_comment": "Egress is NOT one price — it's a tier ladder by WHERE the bytes cross. We price the locality tier (same-region / cross-region / cross-cloud+internet) as a LOW-HIGH RANGE because region-pair rates vary. Per-GB, USD, DIRECTIONAL list prices as of _as_of; excludes free-tier allowances, committed-use/negotiated discounts, and NAT/load-balancer processing fees. Not a quote. Keys: internet rate stays per-provider (differs most); same-region & cross-region tiers are broadly consistent across AWS/GCP/Azure so we use one shared range.",
-  "_egress_tiers_usd_per_gb": {
-    "same_region": { "low": 0.0, "high": 0.01, "note": "Same region: free within an AZ over private IP; ~$0.01/GB each way if it crosses AZs." },
-    "cross_region_same_cloud": { "low": 0.01, "high": 0.02, "note": "Inter-region within one cloud: most pairs ~$0.01-0.02/GB; a few source regions/continent pairs run higher." },
-    "cross_cloud": { "low": 0.085, "high": 0.12, "note": "Leaving the cloud to another provider or the public internet: the expensive tier; GCP Premium ~$0.12, AWS ~$0.09, Azure ~$0.087 at entry bands." }
-  },
-  "_egress_sources": "AWS/GCP/Azure published data-transfer pricing pages + corroborating 2026 guides (usage.ai, nops.io, egresscost.com, redresscompliance, bacancy, tatacommunications). Rounded to ranges; verify against the provider pricing page for a specific region pair.",
-  "aws": {
-    "compute_usd_per_vcpu_hour": 0.0469,
-    "compute_usd_per_gb_ram_hour": 0.0039,
-    "egress_usd_per_gb": 0.09
-  },
-  "gcp": {
-    "compute_usd_per_vcpu_hour": 0.0438,
-    "compute_usd_per_gb_ram_hour": 0.0037,
-    "egress_usd_per_gb": 0.085
-  },
-  "azure": {
-    "compute_usd_per_vcpu_hour": 0.0472,
-    "compute_usd_per_gb_ram_hour": 0.0039,
-    "egress_usd_per_gb": 0.087
-  },
-  "_source": "Compute coefficients for [aws+azure+gcp] derived from Vantage live data using ONE matched method: general-purpose 4GB/vCPU families (AWS m5/m6i, GCP n2-standard, Azure D-series v5), on-demand Linux, mean $/vCPU across regions, 25% split to RAM. Egress remains static. Apples-to-apples DIRECTIONAL comparison, not a quote."
-}

greenpick-0.6.2/src/greenpick/services/carbon_service.py

@@ -1,28 +0,0 @@
-"""Carbon readings (via the repository) + a workload CO2 ESTIMATE.
-
-The estimate turns a workload into average watts (power model) -> kWh/month ->
-multiply by grid intensity. Clearly an estimate, not a measurement.
-"""
-from __future__ import annotations
-
-from ..models import CarbonReading, Workload, Provider
-from ..data.repository import CarbonRepository
-from ..data.static_data import power_model
-
-
-async def carbon_now(repo: CarbonRepository, provider: Provider, region: str) -> CarbonReading:
-    return await repo.carbon_now(provider, region)
-
-
-def workload_kwh_per_month(workload: Workload) -> float:
-    pm = power_model()
-    watts = workload.vcpu * pm["watts_per_vcpu"] + workload.ram_gb * pm["watts_per_gb_ram"]
-    watts *= pm["pue_default"]
-    kwh = watts / 1000.0 * workload.hours_per_month
-    return kwh
-
-
-def estimate_kg_co2_per_month(workload: Workload, reading: CarbonReading) -> float:
-    kwh = workload_kwh_per_month(workload)
-    grams = kwh * reading.g_co2_per_kwh
-    return round(grams / 1000.0, 2)