aimpg 0.4.2__tar.gz → 0.5.0__tar.gz

{aimpg-0.4.2 → aimpg-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aimpg
-Version: 0.4.2
+Version: 0.5.0
 Summary: Real-world energy per solved task for AI coding agents
 Project-URL: Homepage, https://github.com/kumarganduri/aimpg
 Project-URL: Issues, https://github.com/kumarganduri/aimpg/issues
@@ -90,6 +90,8 @@ Use sonnet: it solved 100% of tasks (best: 100%) at 3.1x lower cost per solved t
 
 It re-does your real past commits with each model in a locked sandbox, and **your own tests decide** what counts as solved.
 
+**Make it the team's default:** `aimpg defaults --repo .` reads that evidence and proposes the repo's default model for Claude Code; `--apply` writes it to `.claude/settings.json` (it asks first and keeps a backup). Commit it, and everyone on the repo starts with the model your own tests showed is good enough; anyone can still switch with `/model`.
+
 ### 4. Verify any efficiency claim on your own code
 Token savers, prompts, hooks, CLAUDE.md files, models, even other agents: one command reruns your real commits both ways in a locked sandbox, and your own tests judge them.
 ```bash
@@ -115,6 +117,8 @@ That's the real result on the author's Legwork repo: no saving shown, far from t
 
 Every run writes a **record** (`~/.aimpg/verify/*.record.json`) holding versions, both setups, each run's tokens, $ and outcome, and the verdict, but never code, diffs or commit messages. Repo and commits are hashed unless you add `--public`. Anyone can recheck the math and the record's consistency for free with `aimpg verify --check record.json` (it can't prove the runs happened), and rerun a public record on their own machine with `aimpg verify --rerun record.json --repo <clone>`, which first shows every command, hook and prompt the record would run and asks before running them. Private records keep only fingerprints (SHA-256) of your prompts, CLAUDE.md, settings and commands, never the text. Records also list every redone attempt and excluded commit.
 
+**Share it:** `aimpg submit <record>` publishes a stripped-down copy on the [public scoreboard](https://kumarganduri.github.io/aimpg-scoreboard) (no code, prompts, commit ids or repo name). It shows the exact file first and asks, then opens a pull request. Results only count once enough repos and people back them, and only independent reruns make the headline.
+
 Same model: the energy test decides (it must hold at every corner of the energy ranges). Different models or agents: cost per solved task decides, because model sizes are secret. A challenger that solves more than 10 points fewer tasks is never "supported". Codex runs are measured from its own logs and priced from OpenAI's published prices. Codex logs in with an OpenAI **API key** (a ChatGPT subscription login can't be used inside the sandbox); the key is written to the run's throwaway folder and deleted when the run ends. Other commands are judged on solve rate and time only.
 
 ### 5. Show the cost of each pull request
@@ -131,6 +135,13 @@ aimpg export --csv ai-energy.csv --no-subjects --no-authors
 ```
 One row per AI-assisted commit: date, repo, energy range, CO₂ range and cost. Teams can combine everyone's files. The privacy switches drop commit messages and author emails.
 
+For a standard figure, `aimpg sci --json sci.json` reports your carbon intensity in the Green Software Foundation's [SCI for AI](https://github.com/Green-Software-Foundation/sci-ai/blob/main/SPEC.md) format (Consumer SCI). It uses the spec's units: per million tokens, per AI-assisted commit (a "workflow execution" for agentic AI), and per working change. The JSON lists the boundary, every input with its source, and what's left out. Embodied hardware emissions come from Google's measured per-prompt figures; grid intensity is location-based, because the spec doesn't let offsets or renewable certificates lower the score.
+```
+  per million tokens         2.18–21 g CO₂e
+  per AI-assisted commit     19.3–185 g CO₂e
+  per working change         available from 2026-10-13
+```
+
 ## Privacy
 
 `report`, `pr` and `export` run entirely on your machine with no network calls (except `--fetch` for `git fetch`, and `pr --post`, which talks to GitHub). Your code and prompts are never uploaded. Replays send only the agent's own work to the model API, from a sandbox that can't read your home folder.

{aimpg-0.4.2 → aimpg-0.5.0}/README.md

@@ -70,6 +70,8 @@ Use sonnet: it solved 100% of tasks (best: 100%) at 3.1x lower cost per solved t
 
 It re-does your real past commits with each model in a locked sandbox, and **your own tests decide** what counts as solved.
 
+**Make it the team's default:** `aimpg defaults --repo .` reads that evidence and proposes the repo's default model for Claude Code; `--apply` writes it to `.claude/settings.json` (it asks first and keeps a backup). Commit it, and everyone on the repo starts with the model your own tests showed is good enough; anyone can still switch with `/model`.
+
 ### 4. Verify any efficiency claim on your own code
 Token savers, prompts, hooks, CLAUDE.md files, models, even other agents: one command reruns your real commits both ways in a locked sandbox, and your own tests judge them.
 ```bash
@@ -95,6 +97,8 @@ That's the real result on the author's Legwork repo: no saving shown, far from t
 
 Every run writes a **record** (`~/.aimpg/verify/*.record.json`) holding versions, both setups, each run's tokens, $ and outcome, and the verdict, but never code, diffs or commit messages. Repo and commits are hashed unless you add `--public`. Anyone can recheck the math and the record's consistency for free with `aimpg verify --check record.json` (it can't prove the runs happened), and rerun a public record on their own machine with `aimpg verify --rerun record.json --repo <clone>`, which first shows every command, hook and prompt the record would run and asks before running them. Private records keep only fingerprints (SHA-256) of your prompts, CLAUDE.md, settings and commands, never the text. Records also list every redone attempt and excluded commit.
 
+**Share it:** `aimpg submit <record>` publishes a stripped-down copy on the [public scoreboard](https://kumarganduri.github.io/aimpg-scoreboard) (no code, prompts, commit ids or repo name). It shows the exact file first and asks, then opens a pull request. Results only count once enough repos and people back them, and only independent reruns make the headline.
+
 Same model: the energy test decides (it must hold at every corner of the energy ranges). Different models or agents: cost per solved task decides, because model sizes are secret. A challenger that solves more than 10 points fewer tasks is never "supported". Codex runs are measured from its own logs and priced from OpenAI's published prices. Codex logs in with an OpenAI **API key** (a ChatGPT subscription login can't be used inside the sandbox); the key is written to the run's throwaway folder and deleted when the run ends. Other commands are judged on solve rate and time only.
 
 ### 5. Show the cost of each pull request
@@ -111,6 +115,13 @@ aimpg export --csv ai-energy.csv --no-subjects --no-authors
 ```
 One row per AI-assisted commit: date, repo, energy range, CO₂ range and cost. Teams can combine everyone's files. The privacy switches drop commit messages and author emails.
 
+For a standard figure, `aimpg sci --json sci.json` reports your carbon intensity in the Green Software Foundation's [SCI for AI](https://github.com/Green-Software-Foundation/sci-ai/blob/main/SPEC.md) format (Consumer SCI). It uses the spec's units: per million tokens, per AI-assisted commit (a "workflow execution" for agentic AI), and per working change. The JSON lists the boundary, every input with its source, and what's left out. Embodied hardware emissions come from Google's measured per-prompt figures; grid intensity is location-based, because the spec doesn't let offsets or renewable certificates lower the score.
+```
+  per million tokens         2.18–21 g CO₂e
+  per AI-assisted commit     19.3–185 g CO₂e
+  per working change         available from 2026-10-13
+```
+
 ## Privacy
 
 `report`, `pr` and `export` run entirely on your machine with no network calls (except `--fetch` for `git fetch`, and `pr --post`, which talks to GitHub). Your code and prompts are never uploaded. Replays send only the agent's own work to the model API, from a sandbox that can't read your home folder.

{aimpg-0.4.2 → aimpg-0.5.0}/aimpg/cli.py

@@ -20,6 +20,8 @@ from aimpg.gitkept import DAY
 from aimpg.logs import DEFAULT_ROOT, iter_log_files, parse_logs
 from aimpg.receipt import render
 from aimpg.replay import cli as replay_cli
+from aimpg import defaults as defaults_mod
+from aimpg import scoreboard as scoreboard_mod
 from aimpg.replay import verify as verify_mod
 
 
@@ -65,6 +67,11 @@ def main(argv: list[str] | None = None) -> int:
     export.add_argument("--no-subjects", action="store_true", help="leave commit messages out (privacy)")
     export.add_argument("--no-authors", action="store_true", help="leave author emails out (privacy)")
 
+    sci_p = sub.add_parser("sci", help="carbon intensity in the GSF SCI for AI format (per token, commit, working change)")
+    _common(sci_p, 30)
+    sci_p.add_argument("--grid", type=float, default=None, help="grid intensity in g CO2e/kWh (default: world average)")
+    sci_p.add_argument("--json", type=Path, default=None, help="also write the full disclosure as JSON")
+
     live = sub.add_parser("live", help="live status line + post-commit note inside Claude Code")
     live.add_argument("action", choices=("install", "uninstall"))
     sub.add_parser("statusline", help=argparse.SUPPRESS)  # called by Claude Code
@@ -73,11 +80,17 @@ def main(argv: list[str] | None = None) -> int:
 
     replay_cli.add_parser(sub)
     verify_mod.add_parser(sub)
+    scoreboard_mod.add_parsers(sub)
+    defaults_mod.add_parser(sub)
     args = parser.parse_args(argv)
     if args.command == "replay":
         return replay_cli.main(args)
     if args.command == "verify":
         return verify_mod.main(args)
+    if args.command in ("submit", "scoreboard"):
+        return scoreboard_mod.main(args)
+    if args.command == "defaults":
+        return defaults_mod.main(args)
     if args.command in ("statusline", "hook", "live"):
         from aimpg import live as live_mod
 
@@ -140,6 +153,20 @@ def main(argv: list[str] | None = None) -> int:
     from aimpg import durable, ledger
     from aimpg.receipt import task_energy
 
+    if args.command == "sci":
+        from aimpg import sci
+
+        ledger.record(task_energy(attribution.tasks))
+        judged = durable.judge(ledger.load(), now)
+        in_window = [r for r in parsed.requests if r.ts >= since]
+        result = sci.compute(in_window, len(attribution.tasks), judged,
+                             grid=args.grid if args.grid is not None else sci.default_grid(), period=(since, now))
+        sys.stdout.write(sci.render(result))
+        if args.json:
+            sci.write(result, args.json)
+            print(f"\nFull disclosure (boundary, inputs, sources, ranges): {args.json}")
+        return 0
+
     ledger.record(task_energy(attribution.tasks))
     judged = durable.judge(ledger.load(), now)
     sys.stdout.write(render(parsed, attribution, since, now, judged))

aimpg-0.5.0/aimpg/defaults.py

@@ -0,0 +1,158 @@
+"""`aimpg defaults`: turn a repo's replay evidence into a Claude Code setting the whole team gets.
+
+    aimpg defaults --repo .            what the evidence says, and the setting it supports
+    aimpg defaults --repo . --apply    write it to <repo>/.claude/settings.json (asks; keeps a backup)
+
+Evidence, newest first, for this repo only:
+  * model-picker runs (`aimpg replay models`): the cheapest model per solved
+    task that solves within 10 points of the best;
+  * `aimpg verify` records comparing two Claude models: a SUPPORTED cheaper challenger.
+
+The setting is the project's default model. It's committed with the repo, so
+everyone on the team starts with it; anyone can still switch with /model, and
+a personal choice goes in .claude/settings.local.json instead. Evidence from
+fewer than 20 runs per model is marked tentative, and nothing is written
+without a yes.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from aimpg.replay import picker
+from aimpg.replay.run import load_results
+
+REPLAY_STATE = Path.home() / ".aimpg" / "replay"
+VERIFY_STATE = Path.home() / ".aimpg" / "verify"
+
+
+@dataclass
+class Evidence:
+    source: str  # file it came from
+    model: str  # model id it supports as the default
+    summary: str
+    runs_per_model: int
+    when: float
+
+    @property
+    def tentative(self) -> bool:
+        return self.runs_per_model < picker.MIN_RUNS
+
+
+def gather(repo: Path) -> list[Evidence]:
+    repo = repo.resolve()
+    found: list[Evidence] = []
+    folder = REPLAY_STATE / repo.name
+    for path in sorted(folder.glob("models-*.jsonl")) if folder.is_dir() else []:
+        records, _ = load_results(path)
+        records = [r for r in records if Path(r.repo).resolve() == repo]
+        if not records:
+            continue
+        table = picker.rows(records)
+        choice = picker.pick(table)
+        if choice is None:
+            continue
+        found.append(Evidence(str(path), choice.model, picker.recommend(table), min(r.runs for r in table), path.stat().st_mtime))
+    found += _from_verify(repo)
+    return sorted(found, key=lambda e: e.when, reverse=True)
+
+
+def _from_verify(repo: Path) -> list[Evidence]:
+    from aimpg.scoreboard import repo_id
+
+    rid = repo_id(str(repo))
+    out = []
+    for path in sorted(VERIFY_STATE.glob("*.record.json")) if VERIFY_STATE.is_dir() else []:
+        try:
+            rec = json.loads(path.read_text())
+        except ValueError:
+            continue
+        b, c, v = rec.get("baseline", {}), rec.get("challenger", {}), rec.get("verdict", {})
+        if rid is None or rec.get("repo_id") != rid or not (b.get("agent", "claude") == c.get("agent", "claude") == "claude"):
+            continue
+        models = v.get("challenger", {}).get("models") or []
+        if v.get("answer") != "SUPPORTED" or len(models) != 1 or models == v.get("baseline", {}).get("models"):
+            continue
+        ratio = v.get("cost_ratio")
+        summary = (f"verify: {c['name']} vs {b['name']} → SUPPORTED"
+                   + (f", {1 - ratio:.0%} lower cost per solved task" if ratio else ""))
+        runs = min(v.get("baseline", {}).get("runs", 0), v.get("challenger", {}).get("runs", 0))
+        out.append(Evidence(str(path), models[0], summary, runs, path.stat().st_mtime))
+    return out
+
+
+def settings_path(repo: Path) -> Path:
+    return repo / ".claude" / "settings.json"
+
+
+def current_model(repo: Path) -> str | None:
+    try:
+        return json.loads(settings_path(repo).read_text()).get("model")
+    except (OSError, ValueError, AttributeError):
+        return None
+
+
+def apply(repo: Path, model: str) -> Path | None:
+    """Merge {"model": model} into the project settings. Returns the backup path, if a file existed."""
+    path = settings_path(repo)
+    data, backup = {}, None
+    if path.exists():
+        data = json.loads(path.read_text())
+        if not isinstance(data, dict):
+            raise ValueError(f"{path} isn't a JSON object")
+        backup = path.with_name(f"settings.json.aimpg-backup-{time.strftime('%Y%m%d-%H%M%S')}")
+        shutil.copy2(path, backup)
+    data["model"] = model
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return backup
+
+
+def add_parser(sub) -> None:
+    d = sub.add_parser("defaults", help="turn replay evidence into the repo's default Claude Code model (asks first)")
+    d.add_argument("--repo", type=Path, default=Path("."))
+    d.add_argument("--apply", action="store_true", help="write it to <repo>/.claude/settings.json")
+    d.add_argument("--yes", action="store_true", help="skip the confirmation")
+
+
+def main(args) -> int:
+    repo = args.repo.expanduser().resolve()
+    evidence = gather(repo)
+    now = current_model(repo)
+    print(f"Repo: {repo}")
+    print(f"Current team default model: {now or 'none set (each person uses their own)'}")
+    if not evidence:
+        print("\nNo replay evidence for this repo yet. Find out which model is good enough on your own commits:")
+        print(f"  aimpg replay select {repo}")
+        print(f"  aimpg replay models {repo} --cap 10 --task-mode tests")
+        return 0
+    print("\nEvidence (newest first):")
+    for e in evidence:
+        print(f"  • {e.summary}" + (" (tentative)" if e.tentative and "Tentative" not in e.summary else ""))
+        print(f"    from {e.source}")
+    top = evidence[0]
+    if now == top.model:
+        print(f"\nThe default already matches the evidence: {now}.")
+        return 0
+    print(f"\nProposed: {settings_path(repo)}")
+    print(f'  "model": "{top.model}"' + (f'   (was "{now}")' if now else ""))
+    print("Commit it and everyone on the repo starts with this model; anyone can still switch with /model.")
+    if top.tentative:
+        print(f"Tentative: fewer than {picker.MIN_RUNS} runs per model. A bigger run makes this safer to roll out.")
+    if not args.apply:
+        print("\nTo write it:  aimpg defaults --apply" + (f" --repo {args.repo}" if args.repo != Path(".") else ""))
+        return 0
+    if not args.yes and input("Write it? [y/N] ").strip().lower() != "y":
+        print("Stopped. Nothing was changed.")
+        return 1
+    try:
+        backup = apply(repo, top.model)
+    except ValueError as exc:
+        print(f"Can't update the settings file: {exc}")
+        return 1
+    print(f"Written. {'Backup: ' + str(backup) if backup else ''}\nReview and commit {settings_path(repo).relative_to(repo)}.")
+    return 0

{aimpg-0.4.2 → aimpg-0.5.0}/aimpg/replay/picker.py

@@ -61,17 +61,26 @@ def rows(records: list[Record]) -> list[ModelRow]:
     return sorted(out.values(), key=lambda x: (x.usd_per_solved is None, x.usd_per_solved or 0))
 
 
+def pick(table: list[ModelRow]) -> ModelRow | None:
+    """The cheapest model per solved task whose solve rate is within 10 points of the best."""
+    solved = [r for r in table if r.solved and r.usd_per_solved is not None]
+    if not solved:
+        return None
+    best = max(r.solve_rate for r in table)
+    return min((r for r in solved if r.solve_rate >= best - GOOD_ENOUGH), key=lambda r: r.usd_per_solved, default=None)
+
+
 def recommend(table: list[ModelRow]) -> str:
     solved = [r for r in table if r.solved]
-    if not solved:
+    choice = pick(table)
+    if choice is None:
         return "No model solved any task: nothing to recommend yet."
     best = max(r.solve_rate for r in table)
-    good = [r for r in solved if r.solve_rate >= best - GOOD_ENOUGH]
-    pick = min(good, key=lambda r: r.usd_per_solved)
+    pick_ = choice
     priciest = max(solved, key=lambda r: r.usd_per_solved)
-    text = f"Use {pick.setup.split('@')[-1]}: it solved {pick.solve_rate:.0%} of tasks (best: {best:.0%})"
-    if priciest is not pick:
-        ratio = priciest.usd_per_solved / pick.usd_per_solved
+    text = f"Use {pick_.setup.split('@')[-1]}: it solved {pick_.solve_rate:.0%} of tasks (best: {best:.0%})"
+    if priciest is not pick_:
+        ratio = priciest.usd_per_solved / pick_.usd_per_solved
         text += f" at {ratio:.1f}x lower cost per solved task than {priciest.setup.split('@')[-1]}"
     text += "."
     if min(r.runs for r in table) < MIN_RUNS:

{aimpg-0.4.2 → aimpg-0.5.0}/aimpg/replay/verify.py

@@ -211,6 +211,12 @@ def _spec(setup: S.Setup, public: bool) -> dict:
     return spec
 
 
+def _repo_id(repo: str) -> str | None:
+    from aimpg.scoreboard import repo_id
+
+    return repo_id(repo)
+
+
 def build_record(records: list[Record], *, claim: str, baseline: S.Setup, challenger: S.Setup, repo: str,
                  task_mode: str, public: bool, extra: dict | None = None,
                  attempts: list[Record] | None = None, excluded: set[str] | None = None) -> dict:
@@ -233,6 +239,7 @@ def build_record(records: list[Record], *, claim: str, baseline: S.Setup, challe
         "claim": claim,
         "public": public,
         "repo": _remote(repo) if public else hide(os.path.realpath(repo)),
+        "repo_id": _repo_id(repo),  # keyed with a local secret: lets the scoreboard count repos
         "task_mode": task_mode,
         "versions": _versions(),
         "baseline": _spec(baseline, public),
@@ -518,9 +525,12 @@ def _run(args) -> int:
     if batch.stopped:
         print(f"STOPPED EARLY: an account can't make calls ({batch.stopped}). Fix it, then rerun with --resume {results}")
     records, excluded = runner.load_results(results)
+    # A rerun of a scoreboard upload names it by the upload's SHA-256 (its file name there)
+    rerun_of = hashlib.sha256(args.rerun.read_bytes()).hexdigest() if prior and prior.get("aimpg_upload") else None
     record = build_record(records, claim=claim, baseline=baseline, challenger=challenger, repo=str(repo),
                           task_mode=task_mode, public=args.public if not prior else True,
-                          attempts=runner.all_attempts(results), excluded=excluded)
+                          attempts=runner.all_attempts(results), excluded=excluded,
+                          extra={"rerun_of": rerun_of} if rerun_of else None)
     out = results.with_suffix(".record.json")
     out.write_text(json.dumps(record, indent=1))
     print()

aimpg-0.5.0/aimpg/sci.py

@@ -0,0 +1,150 @@
+"""SCI for AI (Consumer) for AI coding: the Green Software Foundation's carbon
+intensity score, computed from your agent logs.
+
+    SCI = (O + M) / R      O = E × I (operational), M = embodied, R = functional unit
+
+Spec: GSF "Software Carbon Intensity for AI" (ratified; extends ISO/IEC 21031:2024),
+https://github.com/Green-Software-Foundation/sci-ai/blob/main/SPEC.md
+  * Consumer boundary: the Operation and Monitoring stage (API and inference,
+    orchestration, monitoring, ...). Provider training is the Provider SCI, not this.
+  * Functional units: "Per Token" for LLMs and "Per Workflow Execution" for
+    agentic AI. A coding agent's workflow ends in a commit, so aimpg reports
+    per AI-assisted commit and, the unit that matters, per working change
+    (a commit still standing after 30 days).
+  * Offsets, RECs, PPAs and other market-based measures may not reduce the
+    score, so I is a location-based grid average.
+
+E is aimpg's serving-energy range (full stack: accelerators, host, idle
+machines, data-centre overhead). M is amortized hardware emissions per kWh
+served, from Google's measured Scope 1+3 per prompt. Every number is a
+low–high range because model sizes and data-centre locations aren't disclosed.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+from aimpg.energy import load_factors, total_wh
+from aimpg.equivalence import load as load_equivalences
+
+SPEC_URL = "https://github.com/Green-Software-Foundation/sci-ai/blob/main/SPEC.md"
+# Google, arXiv 2508.15734, Table 2 (median Gemini Apps prompt, May 2025):
+# Scope 1+3 (accelerators + host CPU & DRAM, amortized) 0.010 g per 0.24 Wh
+# (comprehensive) and 0.007 g per 0.10 Wh (narrow method) → ~42–70 g per kWh served.
+EMBODIED_G_PER_KWH = (40.0, 70.0)
+EMBODIED_CITATION = ("Google, 'Measuring the environmental impact of delivering AI at Google scale' (arXiv 2508.15734), "
+                     "Table 2: Scope 1+3 emissions 0.010 gCO2e per 0.24 Wh median prompt (≈42 g/kWh) and 0.007 g per "
+                     "0.10 Wh with the narrower method (≈70 g/kWh)")
+INCLUDED = ["model inference via API (accelerators, host CPU and memory, idle provisioned capacity, data-centre overhead)",
+            "every model request the agents made, including sub-agents, tool loops and retries",
+            "embodied (manufacturing) emissions of the serving hardware, amortized per kWh served"]
+EXCLUDED = ["the developer's own computer and network (client side): not in the agents' logs",
+            "provider training (that is the Provider SCI, reported by the model provider)",
+            "orchestration, monitoring and storage outside the model API, where the provider doesn't disclose them",
+            "offsets, RECs, PPAs and other market-based measures (excluded by the spec)"]
+
+
+def compute(requests, n_commits: int, judged, *, grid: float, period: tuple[float, float]) -> dict:
+    """requests: in-window model requests; judged: durable.Judged (or None)."""
+    e = total_wh(requests)  # Wh
+    tokens = sum(r.usage.ctx_len + r.usage.output for r in requests)
+    lo_g = e.low / 1000 * (grid + EMBODIED_G_PER_KWH[0])
+    hi_g = e.high / 1000 * (grid + EMBODIED_G_PER_KWH[1])
+
+    def per(r: float | None) -> list[float] | None:
+        return [round(lo_g / r, 6), round(hi_g / r, 6)] if r else None
+
+    working = None
+    if judged is not None and judged.durable:
+        wh_lo = sum(c.get("wh_low", 0) for c in judged.judged)
+        wh_hi = sum(c.get("wh_high", 0) for c in judged.judged)
+        n = len(judged.durable)
+        working = {"value_g": [round(wh_lo / 1000 * (grid + EMBODIED_G_PER_KWH[0]) / n, 3),
+                               round(wh_hi / 1000 * (grid + EMBODIED_G_PER_KWH[1]) / n, 3)],
+                   "working_changes": n, "judged_commits": len(judged.judged),
+                   "note": "carbon of all judged AI-assisted commits (kept or not) divided by the ones still standing after 30 days"}
+    first = judged.first_judgeable() if judged is not None else None
+    return {
+        "standard": "Software Carbon Intensity for AI (GSF), Consumer SCI",
+        "specification": SPEC_URL,
+        "tool": "aimpg",
+        "generated": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "period": {"from": _day(period[0]), "to": _day(period[1])},
+        "formula": "SCI = (O + M) / R, O = E × I",
+        "boundary": {"persona": "consumer", "lifecycle_stage": "Operation and Monitoring",
+                     "included": INCLUDED, "excluded": EXCLUDED},
+        "inputs": {
+            "E_kwh": [round(e.low / 1000, 4), round(e.high / 1000, 4)],
+            "E_method": f"aimpg energy model, factors version {load_factors().get('version')} (method: https://github.com/kumarganduri/aimpg#how-energy-is-estimated)",
+            "I_g_per_kwh": grid,
+            "I_method": "location-based grid average (no market-based measures)",
+            "M_g_per_kwh_served": list(EMBODIED_G_PER_KWH),
+            "M_method": EMBODIED_CITATION,
+            "requests": len(requests),
+            "tokens": tokens,
+            "tokens_definition": "input (fresh, cache write and cache read) plus output tokens of every request",
+        },
+        "total_g": [round(lo_g, 1), round(hi_g, 1)],
+        "sci": {
+            "per_million_tokens_g": per(tokens / 1e6 if tokens else None),
+            "per_ai_assisted_commit_g": per(n_commits),
+            "per_working_change_g": working,
+        },
+        "functional_units": {
+            "per_million_tokens": "the spec's suggested unit for LLMs (per token), scaled",
+            "per_ai_assisted_commit": "per workflow execution (the spec's unit for agentic AI): one commit the agent helped make",
+            "per_working_change": "per workflow execution that lasted: committed, on the main branch and not reverted or largely rewritten 30 days later",
+        },
+        "working_change_available_from": _day(first + 30 * 86400) if working is None and first is not None else None,
+        "uncertainty": "Every value is a low–high range: model sizes and data-centre locations aren't disclosed, "
+                       "so energy is bracketed by assumptions (aimpg/factors.json); the range is the result, not noise.",
+    }
+
+
+def _day(ts: float) -> str:
+    return time.strftime("%Y-%m-%d", time.gmtime(ts))
+
+
+def _g(v: list[float] | None) -> str:
+    if not v:
+        return "—"
+    lo, hi = v
+    unit, k = ("kg", 1000) if hi >= 1000 else ("g", 1)
+    return f"{lo / k:,.3g}–{hi / k:,.3g} {unit} CO₂e"
+
+
+def render(s: dict) -> str:
+    sci, inp = s["sci"], s["inputs"]
+    lines = [
+        f"SCI FOR AI (Consumer) · {s['period']['from']} → {s['period']['to']}",
+        f"  Standard: GSF Software Carbon Intensity for AI ({s['specification']})",
+        f"  SCI = (O + M) / R,  O = E × I",
+        "",
+        f"  E (serving energy)      {inp['E_kwh'][0]:,.2f}–{inp['E_kwh'][1]:,.2f} kWh over {inp['requests']:,} model requests",
+        f"  I (grid, location-based) {inp['I_g_per_kwh']:.0f} g CO₂e/kWh",
+        f"  M (embodied hardware)   {inp['M_g_per_kwh_served'][0]:.0f}–{inp['M_g_per_kwh_served'][1]:.0f} g CO₂e per kWh served",
+        f"  Total (O + M)           {_g(s['total_g'])}",
+        "",
+        "  Per functional unit (R):",
+        f"    per million tokens         {_g(sci['per_million_tokens_g'])}",
+        f"    per AI-assisted commit     {_g(sci['per_ai_assisted_commit_g'])}",
+    ]
+    w = sci["per_working_change_g"]
+    if w:
+        lines.append(f"    per working change         {_g(w['value_g'])}  ({w['working_changes']} of {w['judged_commits']} judged commits lasted)")
+    else:
+        when = s.get("working_change_available_from")
+        lines.append(f"    per working change         available from {when}" if when else "    per working change         not available yet")
+    lines += ["", "  Not included: " + "; ".join(x.split(":")[0] for x in s["boundary"]["excluded"]) + ".",
+              "  Offsets and renewable-energy certificates never reduce this score (the spec excludes them)."]
+    return "\n".join(lines) + "\n"
+
+
+def default_grid() -> float:
+    return float(load_equivalences()["co2_g_per_kwh"]["value"])
+
+
+def write(s: dict, path: Path) -> None:
+    path.write_text(json.dumps(s, indent=2) + "\n")