aimpg 0.2.0__tar.gz → 0.3.0__tar.gz

{aimpg-0.2.0 → aimpg-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aimpg
-Version: 0.2.0
+Version: 0.3.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
@@ -28,28 +28,40 @@ uvx aimpg report
 
 ```
 YOUR AI CODING
-  Energy   11.34 kWh – 92.22 kWh
-           ≈ boiling a litre of water in a kettle 110–920 times · driving an electric car 67–540 km · 5.2–42.2 kg CO₂
-  Money    $1,210 API-equivalent (Anthropic's published prices)
-  Output   328 commits made with AI help
+  Energy   14.46 kWh – 130.59 kWh
+           ≈ boiling a litre of water in a kettle 140–1,300 times · driving an electric car 85–770 km · 6.6–59.8 kg CO₂
+  Money    $1,284 API-equivalent (Anthropic's published prices)
+  Output   353 commits made with AI help
 
-  A typical kept commit:  37.4 Wh – 283.5 Wh ≈ 2–17 full phone charges · $3.62
+  A typical kept commit:  36.6 Wh – 313.0 Wh ≈ 2–18 full phone charges · $2.05
 
 WHAT WOULD HAVE SAVED THE MOST (measured on your logs; upper bounds that overlap)
-  1. Start a fresh session after each commit: up to 44% less energy, $367
-     44% of your AI energy went to re-reading conversation from before your last commit.
+  1. Start a fresh session after each commit: up to 45% less energy, $397
+     45% of your AI energy went to re-reading conversation from before your last commit.
      → After committing, start a new session (or /clear) for the next task.
-  2. Use a mid-size model for routine work: up to 16% less energy, $316
+  2. Use a mid-size model for routine work: up to 16% less energy, $333
      94% of your AI energy ran on the largest models (Opus/Fable class).
      → Check a cheaper model is good enough on your own commits: `aimpg replay models`.
+
+WORKING CHANGES (commits that shipped and lasted 30 days)
+  Available on 2026-10-22: aimpg is keeping your history so it can tell.
 ```
 
 *(Real output from the author's last 30 days.)*
 
 ## What you can do with it
 
+### 0. See it live while you work
+```bash
+uv tool install aimpg && aimpg live install     # shows the change, asks y/N, keeps a backup
+```
+```
+⚡ task $1.96 · usual $2.05 · ctx 160k (92% from before your last commit) · /clear ≈ -92% per request · 5h 63%
+```
+After the agent commits, one line for you only (never sent to the model): *"that commit cost $2.40 over 31 AI requests. 92% of the context is from earlier work: /clear before the next task saves ~92% per request."* Undo with `aimpg live uninstall`.
+
 ### 1. See your AI footprint in terms you can picture
-`aimpg report` reads the Claude Code logs already on your machine and ties every AI request to the git commit it produced. Energy is shown as an honest range and translated into kettles, phone charges, EV kilometres and CO₂. Money is the API-equivalent cost at Anthropic's published prices (for subscribers, what the same work would cost on the API).
+`aimpg report` reads the Claude Code (and Codex CLI) logs already on your machine and ties every AI request to the git commit it produced. Energy is shown as an honest range and translated into kettles, phone charges, EV kilometres and CO₂. Money is the API-equivalent cost at Anthropic's published prices (for subscribers, what the same work would cost on the API).
 
 ### 2. Get tips measured on your own habits, not generic advice
 The receipt replays your own logs under "what if" rules and tells you what would have saved the most, in Wh and dollars. For example: how much energy went into re-reading old conversation in long sessions, or into running the biggest model for routine fixes.
@@ -99,13 +111,15 @@ One row per AI-assisted commit: date, repo, energy range, CO₂ range and cost.
 
 **Matching requests to commits:** when the agent runs `git commit`, the commit lands inside that tool call, so the match is exact. Within a session, requests since the previous commit belong to the next one. Work before a 2h+ break is shown separately as *lead-up*. Hand-made commits are matched only if you authored them and they touch files the session edited. On the author's history, a hand-labeled check matched 20/20 commits correctly (`evals/`).
 
-**Energy:** a physical formula, not a price proxy. Prefill compute for new input, one KV-cache re-read per output token (so long contexts cost more), plus datacenter overhead. Model sizes aren't public, so every number is a range. Sources for every factor are in [`aimpg/factors.json`](aimpg/factors.json), [`aimpg/prices.json`](aimpg/prices.json) and [`aimpg/equivalences.json`](aimpg/equivalences.json).
+**Working changes:** aimpg keeps a small history of what each commit cost (never prompts or code), because Claude Code deletes its own logs after 30 days. Once a commit is 30 days old, it is judged: still on the main branch and not reverted or largely rewritten counts as a *working change*. The receipt then shows **cost per working change** and a **waste ratio** (AI spend on work that didn't last).
+
+**Energy:** a physical formula, not a price proxy. Prefill compute for new input, one KV-cache re-read per output token (so long contexts cost more), plus datacenter overhead. Model sizes aren't public, so every number is a range. Overheads follow Google's full-stack measurement of a median Gemini prompt (chips, host CPU and memory, idle capacity, cooling ≈ 1.7× the chips alone), and a chat-sized prompt on a mid-size model comes out at 0.017–0.34 Wh, bracketing Google's disclosed 0.24 Wh ([arXiv 2508.15734](https://arxiv.org/pdf/2508.15734)). Sources for every factor are in [`aimpg/factors.json`](aimpg/factors.json), [`aimpg/prices.json`](aimpg/prices.json) and [`aimpg/equivalences.json`](aimpg/equivalences.json).
 
 **Replays:** each run starts from the code just before your commit, in a fresh, history-free copy, inside a macOS sandbox. The only network allowed is the model API, through an allowlisting proxy. Your own tests judge the result, and edited tests are always restored before judging. Every token count is cross-checked against Claude Code's own totals. Details are in [docs/designs/aimpg-design.md](docs/designs/aimpg-design.md).
 
 ## Limits (honest list)
 
-- Claude Code logs only, for now. Replays need macOS and an Anthropic API key (about $0.10–0.30 per run).
+- Claude Code and Codex CLI logs. Cursor keeps token usage on its servers, not on your machine, so it isn't covered yet. Codex's model prices aren't in the table yet; its requests count toward energy but are listed as unpriced. Replays need macOS and an Anthropic API key (about $0.10–0.30 per run).
 - Energy is an estimate with a wide range; dollars are close (within about 7% of Claude Code's own session totals on the author's logs).
 - Tips are upper bounds and overlap; they can't be added together.
 - Replays from commit messages alone are hard (12% solved on the author's repo); `--task-mode tests` shows the agent the tests, which makes tasks easier than real work but keeps comparisons fair.

{aimpg-0.2.0 → aimpg-0.3.0}/README.md

@@ -8,28 +8,40 @@ uvx aimpg report
 
 ```
 YOUR AI CODING
-  Energy   11.34 kWh – 92.22 kWh
-           ≈ boiling a litre of water in a kettle 110–920 times · driving an electric car 67–540 km · 5.2–42.2 kg CO₂
-  Money    $1,210 API-equivalent (Anthropic's published prices)
-  Output   328 commits made with AI help
+  Energy   14.46 kWh – 130.59 kWh
+           ≈ boiling a litre of water in a kettle 140–1,300 times · driving an electric car 85–770 km · 6.6–59.8 kg CO₂
+  Money    $1,284 API-equivalent (Anthropic's published prices)
+  Output   353 commits made with AI help
 
-  A typical kept commit:  37.4 Wh – 283.5 Wh ≈ 2–17 full phone charges · $3.62
+  A typical kept commit:  36.6 Wh – 313.0 Wh ≈ 2–18 full phone charges · $2.05
 
 WHAT WOULD HAVE SAVED THE MOST (measured on your logs; upper bounds that overlap)
-  1. Start a fresh session after each commit: up to 44% less energy, $367
-     44% of your AI energy went to re-reading conversation from before your last commit.
+  1. Start a fresh session after each commit: up to 45% less energy, $397
+     45% of your AI energy went to re-reading conversation from before your last commit.
      → After committing, start a new session (or /clear) for the next task.
-  2. Use a mid-size model for routine work: up to 16% less energy, $316
+  2. Use a mid-size model for routine work: up to 16% less energy, $333
      94% of your AI energy ran on the largest models (Opus/Fable class).
      → Check a cheaper model is good enough on your own commits: `aimpg replay models`.
+
+WORKING CHANGES (commits that shipped and lasted 30 days)
+  Available on 2026-10-22: aimpg is keeping your history so it can tell.
 ```
 
 *(Real output from the author's last 30 days.)*
 
 ## What you can do with it
 
+### 0. See it live while you work
+```bash
+uv tool install aimpg && aimpg live install     # shows the change, asks y/N, keeps a backup
+```
+```
+⚡ task $1.96 · usual $2.05 · ctx 160k (92% from before your last commit) · /clear ≈ -92% per request · 5h 63%
+```
+After the agent commits, one line for you only (never sent to the model): *"that commit cost $2.40 over 31 AI requests. 92% of the context is from earlier work: /clear before the next task saves ~92% per request."* Undo with `aimpg live uninstall`.
+
 ### 1. See your AI footprint in terms you can picture
-`aimpg report` reads the Claude Code logs already on your machine and ties every AI request to the git commit it produced. Energy is shown as an honest range and translated into kettles, phone charges, EV kilometres and CO₂. Money is the API-equivalent cost at Anthropic's published prices (for subscribers, what the same work would cost on the API).
+`aimpg report` reads the Claude Code (and Codex CLI) logs already on your machine and ties every AI request to the git commit it produced. Energy is shown as an honest range and translated into kettles, phone charges, EV kilometres and CO₂. Money is the API-equivalent cost at Anthropic's published prices (for subscribers, what the same work would cost on the API).
 
 ### 2. Get tips measured on your own habits, not generic advice
 The receipt replays your own logs under "what if" rules and tells you what would have saved the most, in Wh and dollars. For example: how much energy went into re-reading old conversation in long sessions, or into running the biggest model for routine fixes.
@@ -79,13 +91,15 @@ One row per AI-assisted commit: date, repo, energy range, CO₂ range and cost.
 
 **Matching requests to commits:** when the agent runs `git commit`, the commit lands inside that tool call, so the match is exact. Within a session, requests since the previous commit belong to the next one. Work before a 2h+ break is shown separately as *lead-up*. Hand-made commits are matched only if you authored them and they touch files the session edited. On the author's history, a hand-labeled check matched 20/20 commits correctly (`evals/`).
 
-**Energy:** a physical formula, not a price proxy. Prefill compute for new input, one KV-cache re-read per output token (so long contexts cost more), plus datacenter overhead. Model sizes aren't public, so every number is a range. Sources for every factor are in [`aimpg/factors.json`](aimpg/factors.json), [`aimpg/prices.json`](aimpg/prices.json) and [`aimpg/equivalences.json`](aimpg/equivalences.json).
+**Working changes:** aimpg keeps a small history of what each commit cost (never prompts or code), because Claude Code deletes its own logs after 30 days. Once a commit is 30 days old, it is judged: still on the main branch and not reverted or largely rewritten counts as a *working change*. The receipt then shows **cost per working change** and a **waste ratio** (AI spend on work that didn't last).
+
+**Energy:** a physical formula, not a price proxy. Prefill compute for new input, one KV-cache re-read per output token (so long contexts cost more), plus datacenter overhead. Model sizes aren't public, so every number is a range. Overheads follow Google's full-stack measurement of a median Gemini prompt (chips, host CPU and memory, idle capacity, cooling ≈ 1.7× the chips alone), and a chat-sized prompt on a mid-size model comes out at 0.017–0.34 Wh, bracketing Google's disclosed 0.24 Wh ([arXiv 2508.15734](https://arxiv.org/pdf/2508.15734)). Sources for every factor are in [`aimpg/factors.json`](aimpg/factors.json), [`aimpg/prices.json`](aimpg/prices.json) and [`aimpg/equivalences.json`](aimpg/equivalences.json).
 
 **Replays:** each run starts from the code just before your commit, in a fresh, history-free copy, inside a macOS sandbox. The only network allowed is the model API, through an allowlisting proxy. Your own tests judge the result, and edited tests are always restored before judging. Every token count is cross-checked against Claude Code's own totals. Details are in [docs/designs/aimpg-design.md](docs/designs/aimpg-design.md).
 
 ## Limits (honest list)
 
-- Claude Code logs only, for now. Replays need macOS and an Anthropic API key (about $0.10–0.30 per run).
+- Claude Code and Codex CLI logs. Cursor keeps token usage on its servers, not on your machine, so it isn't covered yet. Codex's model prices aren't in the table yet; its requests count toward energy but are listed as unpriced. Replays need macOS and an Anthropic API key (about $0.10–0.30 per run).
 - Energy is an estimate with a wide range; dollars are close (within about 7% of Claude Code's own session totals on the author's logs).
 - Tips are upper bounds and overlap; they can't be added together.
 - Replays from commit messages alone are hard (12% solved on the author's repo); `--task-mode tests` shows the agent the tests, which makes tasks easier than real work but keeps comparisons fair.

{aimpg-0.2.0 → aimpg-0.3.0}/aimpg/cli.py

@@ -4,6 +4,7 @@
     pr        AI energy + cost of the current branch's commits (markdown; --post to the PR)
     export    one CSV row per AI-assisted commit, for teams and sustainability reports
     replay    compare agent setups and models on your own past commits
+    live      install/uninstall the live status line + post-commit note in Claude Code
 """
 
 from __future__ import annotations
@@ -24,13 +25,16 @@ from aimpg.replay import cli as replay_cli
 def _common(p: argparse.ArgumentParser, days: int) -> None:
     p.add_argument("--days", type=int, default=days, help=f"window size in days (default {days})")
     p.add_argument("--logs", type=Path, default=DEFAULT_ROOT, help="Claude Code projects dir")
+    p.add_argument("--codex-logs", type=Path, default=None, help="Codex sessions dir (default ~/.codex/sessions)")
     p.add_argument("--fetch", action="store_true", help="git fetch each repo first (uses the network)")
 
 
 def _analyze(args):
+    from aimpg import codex_logs
+
     now = time.time()
     since = now - args.days * DAY
-    parsed = parse_logs(iter_log_files(args.logs))
+    parsed = codex_logs.merge(parse_logs(iter_log_files(args.logs)), codex_logs.parse_codex(codex_logs.iter_files(args.codex_logs)))
     return parsed, attribute(parsed, since, now, refresh=args.fetch), since, now
 
 
@@ -51,10 +55,34 @@ 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)")
 
+    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
+    hook = sub.add_parser("hook", help=argparse.SUPPRESS)  # called by Claude Code
+    hook.add_argument("event", choices=("post-commit",))
+
     replay_cli.add_parser(sub)
     args = parser.parse_args(argv)
     if args.command == "replay":
         return replay_cli.main(args)
+    if args.command in ("statusline", "hook", "live"):
+        from aimpg import live as live_mod
+
+        if args.command == "statusline":
+            return live_mod.run_statusline(live_mod.previous_statusline())
+        if args.command == "hook":
+            return live_mod.run_post_commit_hook()
+        if args.action == "install":
+            import shutil
+
+            exe = shutil.which("aimpg")
+            if exe is None:
+                print("Install aimpg permanently first so Claude Code can call it:  uv tool install aimpg")
+                return 1
+            print(live_mod.install(exe=exe))
+        else:
+            print(live_mod.uninstall())
+        return 0
 
     if args.days <= 0:
         parser.error("--days must be positive")
@@ -85,7 +113,12 @@ def main(argv: list[str] | None = None) -> int:
             print("\nPosted to the pull request.")
         return 0
 
-    sys.stdout.write(render(parsed, attribution, since, now))
+    from aimpg import durable, ledger
+    from aimpg.receipt import task_energy
+
+    ledger.record(task_energy(attribution.tasks))
+    judged = durable.judge(ledger.load(), now)
+    sys.stdout.write(render(parsed, attribution, since, now, judged))
     return 0
 
 

aimpg-0.3.0/aimpg/codex_logs.py

@@ -0,0 +1,142 @@
+"""Read OpenAI Codex CLI session logs (~/.codex/sessions/**/rollout-*.jsonl).
+
+Verified on real files (codex-cli 0.159):
+  * `event_msg` / `token_count` events carry `info.last_token_usage` for each
+    model call: input_tokens (includes cached), cached_input_tokens,
+    cache_write_input_tokens, output_tokens, reasoning_output_tokens.
+  * `turn_context` carries the model (e.g. gpt-6-luna) and cwd; `session_meta`
+    carries the session id and starting cwd.
+
+Not yet verified on a real file (no local session ran shell commands): how a
+`git commit` tool call is recorded. Detection is tolerant: any response_item
+tool call whose arguments contain `git ... commit`, closed by an output item
+with the same call_id. Commits made by hand are still matched by the fuzzy tier.
+
+Codex token usage is mapped onto the same buckets as Claude Code:
+    fresh_in = input − cached − cache_write · cache_read = cached
+    cache_write = cache_write_input · output = output + reasoning (generated text)
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Iterable, Iterator
+
+from aimpg.logs import _GIT_COMMIT, commit_cwd, parse_ts
+from aimpg.model import CommitCall, ParseResult, Request, Usage
+
+DEFAULT_ROOT = Path.home() / ".codex" / "sessions"
+TOOL_CALLS = ("function_call", "custom_tool_call", "local_shell_call")
+TOOL_OUTPUTS = ("function_call_output", "custom_tool_call_output", "local_shell_call_output")
+
+
+def iter_files(root: Path | None = None) -> Iterator[Path]:
+    root = root or DEFAULT_ROOT  # looked up at call time so tests can point it elsewhere
+    if root.is_dir():
+        yield from sorted(root.rglob("*.jsonl"))
+
+
+def _command_text(payload: dict) -> str:
+    for key in ("arguments", "input", "action"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            try:
+                value = json.loads(value)
+            except ValueError:
+                return value
+        if isinstance(value, dict):
+            cmd = value.get("command") or value.get("cmd")
+            if isinstance(cmd, list):
+                return " ".join(str(c) for c in cmd)
+            if cmd:
+                return str(cmd)
+    return ""
+
+
+def parse_codex(files: Iterable[Path]) -> ParseResult:
+    result = ParseResult()
+    stats = {"files": 0, "rows": 0, "unique_requests": 0, "corrupt_rows": 0}
+    versions: dict[str, int] = {}
+    for path in files:
+        stats["files"] += 1
+        session, cwd, model = path.stem, "", ""
+        pending: dict[str, tuple[float, str]] = {}
+        n = 0
+        with open(path, "rb") as fh:
+            for line in fh:
+                if not line.strip():
+                    continue
+                stats["rows"] += 1
+                try:
+                    row = json.loads(line)
+                except ValueError:
+                    stats["corrupt_rows"] += 1
+                    continue
+                kind, payload = row.get("type"), row.get("payload") or {}
+                ts = parse_ts(row.get("timestamp"))
+                if kind == "session_meta":
+                    session = str(payload.get("session_id") or payload.get("id") or session)
+                    cwd = str(payload.get("cwd") or cwd)
+                    if payload.get("cli_version"):
+                        versions["codex " + str(payload["cli_version"])] = versions.get("codex " + str(payload["cli_version"]), 0) + 1
+                elif kind == "turn_context":
+                    model = str(payload.get("model") or model)
+                    cwd = str(payload.get("cwd") or cwd)
+                elif kind == "event_msg" and payload.get("type") == "token_count" and ts is not None:
+                    usage = ((payload.get("info") or {}).get("last_token_usage")) or {}
+                    if not usage:
+                        continue
+                    cached = int(usage.get("cached_input_tokens") or 0)
+                    written = int(usage.get("cache_write_input_tokens") or 0)
+                    total_in = int(usage.get("input_tokens") or 0)
+                    n += 1
+                    result.requests.append(Request(
+                        id=f"codex:{session}:{n}",
+                        session_id=f"codex:{session}",
+                        model=model or "codex-unknown",
+                        ts=ts,
+                        usage=Usage(
+                            fresh_in=max(0, total_in - cached - written),
+                            cache_write=written,
+                            cache_read=cached,
+                            output=int(usage.get("output_tokens") or 0) + int(usage.get("reasoning_output_tokens") or 0),
+                        ),
+                        cwd=cwd,
+                    ))
+                elif kind == "response_item" and ts is not None:
+                    ptype = payload.get("type")
+                    if ptype in TOOL_CALLS:
+                        command = _command_text(payload)
+                        if _GIT_COMMIT.search(command):
+                            repo_dir = commit_cwd(command, cwd) or cwd
+                            pending[str(payload.get("call_id") or payload.get("id"))] = (ts, repo_dir)
+                    elif ptype in TOOL_OUTPUTS:
+                        call = pending.pop(str(payload.get("call_id")), None)
+                        if call:
+                            result.commit_calls.append(CommitCall(f"codex:{session}", call[1], call[0], ts))
+        stats["unique_requests"] += n
+    result.requests.sort(key=lambda r: r.ts)
+    result.commit_calls.sort(key=lambda c: c.start)
+    result.stats = stats
+    result.versions = versions
+    return result
+
+
+def merge(*parts: ParseResult) -> ParseResult:
+    """One ParseResult from several agents' logs."""
+    out = ParseResult()
+    stats: dict[str, int] = {}
+    for p in parts:
+        out.requests.extend(p.requests)
+        out.commit_calls.extend(p.commit_calls)
+        for k, v in p.files_touched.items():
+            out.files_touched.setdefault(k, set()).update(v)
+        for k, v in p.stats.items():
+            stats[k] = stats.get(k, 0) + v
+        for k, v in p.versions.items():
+            out.versions[k] = out.versions.get(k, 0) + v
+    out.requests.sort(key=lambda r: r.ts)
+    out.commit_calls.sort(key=lambda c: c.start)
+    out.stats = stats
+    return out

aimpg-0.3.0/aimpg/durable.py

@@ -0,0 +1,119 @@
+"""Working (durable) changes: AI-assisted commits that shipped and stayed.
+
+A commit becomes judgeable 30 days after it was made. It is:
+
+    reverted   a later commit says "This reverts commit <sha>"
+    reworked   within 30 days, later commits on the default branch deleted at
+               least 30% of the meaningful lines it added
+    not kept   it never reached the default branch (or is unknown)
+    durable    none of the above
+
+    cost per working change = AI $ on judged commits / number of durable ones
+    waste ratio             = AI $ on judged commits that weren't durable / AI $ on judged commits
+
+Commits younger than 30 days are "too new" and left out of both numbers.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+from aimpg.gitkept import DAY, GitError, KeptChecker, load_commits
+
+MATURE_AFTER = 30 * DAY
+REWORK_SHARE = 0.30
+
+
+@dataclass
+class Judged:
+    durable: list[dict] = field(default_factory=list)
+    reverted: list[dict] = field(default_factory=list)
+    reworked: list[dict] = field(default_factory=list)
+    not_kept: list[dict] = field(default_factory=list)
+    too_new: list[dict] = field(default_factory=list)
+    errors: dict[str, str] = field(default_factory=dict)
+
+    @property
+    def judged(self) -> list[dict]:
+        return self.durable + self.reverted + self.reworked + self.not_kept
+
+    def cost_per_durable(self) -> float | None:
+        usd = sum(r["usd"] for r in self.judged)
+        return usd / len(self.durable) if self.durable else None
+
+    def waste_ratio(self) -> float | None:
+        usd = sum(r["usd"] for r in self.judged)
+        wasted = usd - sum(r["usd"] for r in self.durable)
+        return wasted / usd if usd else None
+
+    def first_judgeable(self) -> float | None:
+        return min((r["ts"] for r in self.too_new), default=None)
+
+
+def reverted_shas(repo: str, since: float) -> set[str]:
+    proc = subprocess.run(
+        ["git", "-C", repo, "log", "--all", f"--since={int(since)}", "--grep=This reverts commit", "--format=%B%x1e"],
+        capture_output=True, text=True, errors="replace",
+    )
+    out = set()
+    for body in proc.stdout.split("\x1e"):
+        for word in body.replace(".", " ").split():
+            if len(word) == 40 and all(c in "0123456789abcdef" for c in word):
+                out.add(word)
+    return out
+
+
+def judge(ledger: dict[str, dict], now: float | None = None) -> Judged:
+    now = now or time.time()
+    result = Judged()
+    by_repo: dict[str, list[dict]] = defaultdict(list)
+    for rec in ledger.values():
+        (by_repo[rec["repo"]] if now - rec["ts"] >= MATURE_AFTER else result.too_new).append(rec)
+    for repo, recs in by_repo.items():
+        oldest = min(r["ts"] for r in recs)
+        try:
+            checker = KeptChecker(repo, oldest - DAY, now)
+            commits = load_commits(repo, oldest - DAY, reflog=False)
+            later = load_commits(repo, oldest, refs=[checker.ref])
+            statuses = checker.classify(commits)
+            reverts = reverted_shas(repo, oldest)
+        except GitError as exc:
+            result.errors[repo] = str(exc)
+            result.not_kept.extend(recs)
+            continue
+        own = {c.sha: c for c in commits}
+        for rec in recs:
+            status = statuses.get(rec["sha"])
+            if rec["sha"] in reverts:
+                result.reverted.append(rec)
+            elif status is None or not status.is_kept:
+                result.not_kept.append(rec)
+            elif _reworked(own.get(rec["sha"]), later):
+                result.reworked.append(rec)
+            else:
+                result.durable.append(rec)
+    return result
+
+
+def _reworked(commit, later) -> bool:
+    if commit is None:
+        return False
+    added = {p: lines for p, lines in commit.added.items() if lines}
+    total = sum(len(v) for v in added.values())
+    if total == 0:
+        return False
+    gone = set()
+    for c in later:
+        if c.sha == commit.sha or not (commit.ts < c.ts <= commit.ts + MATURE_AFTER):
+            continue
+        for path, lines in added.items():
+            gone |= {(path, l) for l in lines & c.removed.get(path, set())}
+    return len(gone) / total >= REWORK_SHARE
+
+
+def day(ts: float) -> str:
+    return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")

{aimpg-0.2.0 → aimpg-0.3.0}/aimpg/factors.json

@@ -1,20 +1,20 @@
 {
-  "version": "2026-10-01",
+  "version": "2026-10-03b",
   "constants": {
     "joules_per_flop": {
-      "value": 0.52e-12,
+      "value": 5.2e-13,
       "citation": "From Tokens to Watt-hours (arXiv 2607.26571): tensor-core coefficient alpha_TC = 0.52 pJ/FLOP, H100 BF16"
     },
     "joules_per_hbm_bit": {
-      "value": 11.68e-12,
+      "value": 1.168e-11,
       "citation": "From Tokens to Watt-hours (arXiv 2607.26571): HBM energy e_HBM = 11.68 pJ/bit, H100"
     }
   },
   "ranges": {
     "overhead": {
-      "low": 1.25,
-      "high": 1.5,
-      "citation": "EcoLogits LLM inference methodology: non-GPU server power 1.2 kW per 8-GPU server, provider PUE 1.09-1.20"
+      "low": 1.5,
+      "high": 2.0,
+      "citation": "Full-stack boundary per Google's measured breakdown of a median Gemini prompt (0.24 Wh = accelerators 58%, host CPU/DRAM 25%, idle provisioned machines 10%, PUE overhead 8%), i.e. total \u2248 1.7x accelerator energy: https://arxiv.org/pdf/2508.15734 . Range 1.5-2.0 brackets leaner and less efficient fleets. Previously 1.25-1.5 (PUE + server only), which left out host and idle energy."
     },
     "batch_size": {
       "low": 128,
@@ -27,8 +27,8 @@
       "citation": "Assumption: FP8 to BF16 serving precision"
     },
     "kv_bits_per_token": {
-      "low": 0.5e6,
-      "high": 3.0e6,
+      "low": 500000.0,
+      "high": 3000000.0,
       "citation": "Assumption: 2 x layers x kv_heads x head_dim x bytes for GQA models (e.g. 80x8x128x2x2 bytes = 2.6 Mbit BF16); FP8/compressed caches are lower"
     },
     "prefill_inefficiency": {
@@ -44,20 +44,40 @@
   },
   "classes": {
     "large": {
-      "active_params_billion": {"low": 100, "high": 400},
-      "matches": ["opus", "fable"],
+      "active_params_billion": {
+        "low": 100,
+        "high": 400
+      },
+      "matches": [
+        "opus",
+        "fable"
+      ],
       "citation": "Assumption: parameter counts are not disclosed for frontier closed models"
     },
     "mid": {
-      "active_params_billion": {"low": 30, "high": 150},
-      "matches": ["sonnet"],
+      "active_params_billion": {
+        "low": 30,
+        "high": 150
+      },
+      "matches": [
+        "sonnet"
+      ],
       "citation": "Assumption: parameter counts are not disclosed for frontier closed models"
     },
     "small": {
-      "active_params_billion": {"low": 8, "high": 40},
-      "matches": ["haiku"],
+      "active_params_billion": {
+        "low": 8,
+        "high": 40
+      },
+      "matches": [
+        "haiku"
+      ],
       "citation": "Assumption: parameter counts are not disclosed for frontier closed models"
     }
   },
-  "default_class": "mid"
+  "default_class": "mid",
+  "calibration": {
+    "check": "A chat-sized prompt (600 input, 400 output tokens, no cache) on a mid-size model should bracket Google's disclosed 0.24 Wh median Gemini prompt (same full-stack boundary).",
+    "citation": "https://arxiv.org/pdf/2508.15734"
+  }
 }

{aimpg-0.2.0 → aimpg-0.3.0}/aimpg/gitkept.py

@@ -54,6 +54,8 @@ class Commit:
     author_email: str = ""
     files: dict[str, tuple[int, int]] = field(default_factory=dict)  # path -> (added, deleted)
     added: dict[str, set[str]] = field(default_factory=dict)  # path -> meaningful added lines
+    removed: dict[str, set[str]] = field(default_factory=dict)  # path -> meaningful removed lines (rework detection)
+    message: str = ""  # full message body (revert detection); filled by load_commits
 
     @property
     def lines_changed(self) -> int:
@@ -182,6 +184,9 @@ def _parse_patch_log(text: str) -> list[Commit]:
             elif line.startswith("-"):
                 a, d = commit.files[current]
                 commit.files[current] = (a, d + 1)
+                stripped = line[1:].strip()
+                if len(stripped) >= _MIN_LINE:
+                    commit.removed.setdefault(current, set()).add(stripped)
         commits.append(commit)
     return commits
 

aimpg-0.3.0/aimpg/ledger.py

@@ -0,0 +1,61 @@
+"""aimpg's own history: what each AI-assisted commit cost, kept beyond Claude Code's logs.
+
+Claude Code deletes transcripts after 30 days by default, but a commit can only
+be called durable after 30 days. So every report records a small line per
+commit in ~/.aimpg/ledger.json: cost, energy range, request count. Never
+prompts, code or diffs. Re-running is safe: a commit's record is replaced
+only by one with at least as many requests, so deleted logs never shrink it.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+LEDGER = Path.home() / ".aimpg" / "ledger.json"
+
+
+def load(path: Path = LEDGER) -> dict[str, dict]:
+    try:
+        return json.loads(path.read_text())
+    except (OSError, ValueError):
+        return {}
+
+
+def key(repo: str, sha: str) -> str:
+    return f"{repo}|{sha}"
+
+
+def record(energies, path: Path = LEDGER) -> int:
+    """Upsert one line per commit from receipt.task_energy(...). Returns how many changed."""
+    data = load(path)
+    changed = 0
+    now = time.time()
+    for e in energies:
+        t = e.task
+        requests = len(t.requests) + len(t.lead_up)
+        if requests == 0:
+            continue
+        k = key(t.repo, t.sha)
+        old = data.get(k)
+        if old and old.get("requests", 0) > requests:
+            continue  # logs were cleaned up since: keep the fuller record
+        data[k] = {
+            "repo": t.repo,
+            "sha": t.sha,
+            "ts": t.ts,
+            "subject": t.subject,
+            "author": t.author,
+            "requests": requests,
+            "usd": round(e.usd + e.lead_up_usd, 4),
+            "wh_low": round(e.total.low, 3),
+            "wh_high": round(e.total.high, 3),
+            "first_seen": (old or {}).get("first_seen", now),
+        }
+        changed += old != data[k]
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(data))
+    tmp.replace(path)
+    return changed