@seanyao/roll 2026.522.1 → 2026.523.1

package/conventions/config.yaml

@@ -7,7 +7,7 @@
 sync_claude: ~/.claude/CLAUDE.md
 sync_kimi: ~/.kimi/AGENTS.md
 sync_codex: ~/.codex/AGENTS.md
-sync_gemini: ~/.gemini/GEMINI.md
+sync_agy: ~/.gemini/GEMINI.md   # Antigravity (agy) reuses the legacy ~/.gemini/ path
 
 # User preferences
 default_language: zh

package/conventions/global/AGENTS.md

@@ -133,7 +133,7 @@ conventions, deploy targets.
 |---|---|---|
 | `conventions/global/AGENTS.md` | `conventions/templates/<type>/AGENTS.md` | All agents |
 | `conventions/global/CLAUDE.md` | `conventions/templates/<type>/CLAUDE.md` | Claude Code |
-| `conventions/global/GEMINI.md` | `conventions/templates/<type>/GEMINI.md` | Gemini CLI |
+| `conventions/global/GEMINI.md` | `conventions/templates/<type>/GEMINI.md` | Antigravity (agy) — reads `~/.gemini/GEMINI.md` natively |
 | `conventions/global/project_rules.md` | `conventions/templates/<type>/project_rules.md` | Trae IDE |
 
 The CLAUDE / GEMINI / project_rules global files themselves declare they

package/conventions/global/GEMINI.md

@@ -1,9 +1,14 @@
-# Global Preferences — Gemini CLI
+# Global Preferences — Antigravity (agy)
 
 > Extends AGENTS.md in this directory — read that first for shared conventions.
-> This file adds Gemini CLI-specific configuration only.
+> This file adds Antigravity-specific configuration only.
+>
+> File is named `GEMINI.md` because agy reads `~/.gemini/GEMINI.md` natively
+> (it reuses the legacy Gemini CLI config dir). The filename is the canonical
+> agy-side filename; the content here is for agy.
 
-## Gemini-Specific
+## Antigravity-Specific
 
 - When running shell commands, prefer the most specific tool available.
 - When a project has Roll workflow, follow the AGENTS.md conventions and use Roll skills.
+- Invoke interactively with `agy -i "<prompt>"`; non-interactive with `agy -p "<prompt>"`.

package/conventions/templates/backend-service/GEMINI.md

@@ -1,6 +1,6 @@
-# Project Preferences — Backend Service (Gemini CLI)
+# Project Preferences — Backend Service (Antigravity)
 
-> Extends global GEMINI.md + project AGENTS.md.
+> Extends global GEMINI.md (Antigravity) + project AGENTS.md.
 
 ## Stack
 
@@ -8,7 +8,7 @@
 - Database: Prisma or Drizzle ORM
 - Testing: Vitest + Supertest
 
-## Gemini Notes
+## Antigravity (agy) Notes
 
 - No frontend in this project. API-only service.
 - Write integration tests that hit real endpoints, not mocked handlers.

package/conventions/templates/cli/GEMINI.md

@@ -1,6 +1,6 @@
-# Project Preferences — CLI Tool (Gemini CLI)
+# Project Preferences — CLI Tool (Antigravity)
 
-> Extends global GEMINI.md + project AGENTS.md.
+> Extends global GEMINI.md (Antigravity) + project AGENTS.md.
 
 ## Stack
 
@@ -8,7 +8,7 @@
 - CLI framework: commander or citty
 - Testing: Vitest
 
-## Gemini Notes
+## Antigravity (agy) Notes
 
 - No server, no frontend. CLI tool only.
 - Test commands by running them, not just unit tests.

package/conventions/templates/frontend-only/GEMINI.md

@@ -1,13 +1,13 @@
-# Project Preferences — Frontend Only (Gemini CLI)
+# Project Preferences — Frontend Only (Antigravity)
 
-> Extends global GEMINI.md + project AGENTS.md.
+> Extends global GEMINI.md (Antigravity) + project AGENTS.md.
 
 ## Stack
 
 - React + shadcn/ui + Tailwind CSS + Vite
 - Testing: Vitest + Playwright
 
-## Gemini Notes
+## Antigravity (agy) Notes
 
 - No backend in this project. All data via external API consumption.
 - Run `npm run build` to verify production bundle compiles before pushing.

package/conventions/templates/fullstack/GEMINI.md

@@ -1,6 +1,6 @@
-# Project Preferences — Fullstack Web (Gemini CLI)
+# Project Preferences — Fullstack Web (Antigravity)
 
-> Extends global GEMINI.md + project AGENTS.md.
+> Extends global GEMINI.md (Antigravity) + project AGENTS.md.
 
 ## Stack
 
@@ -8,7 +8,7 @@
 - Backend: Node.js API (Express/Hono/Fastify)
 - Testing: Vitest (unit) + Playwright (E2E)
 
-## Gemini Notes
+## Antigravity (agy) Notes
 
 - When modifying API contracts, update both `api/types.ts` and `src/shared/types/` in the same commit.
 - Run `npm run build` to verify both frontend and backend compile before pushing.

package/lib/loop-fmt.py

@@ -353,14 +353,28 @@ class LoopFmt:
         # Use the cumulative totals accumulated across all assistant turns;
         # result.usage is per-turn (last only) so it would under-count badly.
         model = result_ev.get("model") or self._last_model or ""
+
+        # FIX-099: skip writing the usage event when claude returned no real
+        # usage data (model empty AND cost/duration both zero). This prevents
+        # stale/placeholder values from leaking into the events stream and
+        # showing up as "cost=$1.24 dur=372s" in three consecutive cycles when
+        # the real cycle had no token data (the default-value fallback).
+        # The dashboard can render "n/a" for missing usage rather than false data.
+        has_model   = bool(model)
+        has_tokens  = any(self._usage_totals[k] > 0 for k in self._usage_totals)
+        has_cost    = bool(cost_usd)
+        has_dur     = bool(dur_ms)
+        if not has_model and not has_tokens and not has_cost and not has_dur:
+            return  # nothing real to report — skip rather than persist zeros
+
         payload = {
-            "model":                 model,
+            "model":                 model if has_model else None,
             "input_tokens":          self._usage_totals["input_tokens"],
             "output_tokens":         self._usage_totals["output_tokens"],
             "cache_creation_tokens": self._usage_totals["cache_creation_tokens"],
             "cache_read_tokens":     self._usage_totals["cache_read_tokens"],
-            "cost_reported_usd":     float(cost_usd or 0),
-            "duration_ms":           int(dur_ms or 0),
+            "cost_reported_usd":     float(cost_usd) if has_cost else None,
+            "duration_ms":           int(dur_ms) if has_dur else None,
         }
         evfile = os.path.join(shared, "loop", f"events-{slug}.ndjson")
         line = json.dumps({

package/lib/model_prices.py

@@ -12,15 +12,26 @@ to sonnet rates with a stderr warning so dashboards don't blank out.
 import sys
 from typing import Dict, Optional
 
-# Rates per million tokens (USD).
+# Rates per million tokens (USD). cache_create = 5-minute cache write (1.25x
+# input). 1-hour cache writes (2x input) are not modeled — Roll loop uses the
+# default 5m caching only.
+# Source: https://platform.claude.com/docs/en/about-claude/pricing
 PRICES: Dict[str, Dict[str, float]] = {
-    # Claude 4.x family (current as of 2026-05).
-    "claude-opus-4-7":    {"in": 15.00, "out": 75.00, "cache_create": 18.75, "cache_read": 1.50},
-    "claude-opus-4-6":    {"in": 15.00, "out": 75.00, "cache_create": 18.75, "cache_read": 1.50},
+    # Claude 4.x Opus family — 2026-05 repricing: Opus 4.5+ moved to
+    # $5/$25 base, 3x cheaper than Opus 4 / 4.1.
+    "claude-opus-4-7":    {"in":  5.00, "out": 25.00, "cache_create":  6.25, "cache_read": 0.50},
+    "claude-opus-4-6":    {"in":  5.00, "out": 25.00, "cache_create":  6.25, "cache_read": 0.50},
+    "claude-opus-4-5":    {"in":  5.00, "out": 25.00, "cache_create":  6.25, "cache_read": 0.50},
+    "claude-opus-4-1":    {"in": 15.00, "out": 75.00, "cache_create": 18.75, "cache_read": 1.50},
+    "claude-opus-4":      {"in": 15.00, "out": 75.00, "cache_create": 18.75, "cache_read": 1.50},
+    # Claude 4.x Sonnet family.
     "claude-sonnet-4-6":  {"in":  3.00, "out": 15.00, "cache_create":  3.75, "cache_read": 0.30},
+    "claude-sonnet-4-5":  {"in":  3.00, "out": 15.00, "cache_create":  3.75, "cache_read": 0.30},
     "claude-sonnet-4":    {"in":  3.00, "out": 15.00, "cache_create":  3.75, "cache_read": 0.30},
+    # Claude 4.x Haiku family.
     "claude-haiku-4-5":   {"in":  1.00, "out":  5.00, "cache_create":  1.25, "cache_read": 0.10},
-    # Older fallbacks
+    # Older / retired models (Bedrock & Vertex only for 3.5 Haiku).
+    "claude-haiku-3-5":   {"in":  0.80, "out":  4.00, "cache_create":  1.00, "cache_read": 0.08},
     "claude-3-5-sonnet":  {"in":  3.00, "out": 15.00, "cache_create":  3.75, "cache_read": 0.30},
 }
 

package/lib/roll-loop-status.py

@@ -336,10 +336,16 @@ def load_claude_session_usage(label: str, slug: str) -> Optional[Dict[str, Any]]
             "cost_reported_usd": cost, "duration_ms": duration_ms}
 
 def backfill_usage_from_claude_sessions(cycles: List[Dict[str, Any]], slug: str) -> None:
-    """Populate cy['tokens'], cy['cost_list'], cy['model']. Two paths:
+    """Populate cy['input_tokens'], cy['output_tokens'], cy['cost_list'],
+    cy['model']. Two paths:
       1. usage_event from events stream (US-LOOP-004 writer side) — authoritative
       2. claude session JSONL backfill — for cycles that ran before the
          writer existed, or on machines where events.ndjson got truncated
+
+    US-VIEW-012: dashboard exposes input + output only (the model's actual
+    work). cache_creation / cache_read remain in the usage_event for
+    compute_list_cost — they're still part of true API cost — but no longer
+    surface in the UI where they previously inflated visible token totals.
     """
     import importlib.util
     spec = importlib.util.spec_from_file_location("model_prices",
@@ -350,12 +356,10 @@ def backfill_usage_from_claude_sessions(cycles: List[Dict[str, Any]], slug: str)
         # Path 1: usage event written by loop-fmt at result time.
         ue = cy.get("usage_event")
         if isinstance(ue, dict) and (ue.get("input_tokens") or ue.get("output_tokens")):
-            cy["tokens"] = mp.total_tokens(
-                input_tokens=ue.get("input_tokens", 0),
-                output_tokens=ue.get("output_tokens", 0),
-                cache_creation_tokens=ue.get("cache_creation_tokens", 0),
-                cache_read_tokens=ue.get("cache_read_tokens", 0),
-            )
+            cy["input_tokens"]          = int(ue.get("input_tokens")          or 0)
+            cy["output_tokens"]         = int(ue.get("output_tokens")         or 0)
+            cy["cache_creation_tokens"] = int(ue.get("cache_creation_tokens") or 0)
+            cy["cache_read_tokens"]     = int(ue.get("cache_read_tokens")     or 0)
             cy["model"] = ue.get("model")
             # US-VIEW-010: aggregate now sums per-turn usage tokens, so the
             # totals in `ue` reflect the whole cycle. Always compute cost at
@@ -373,17 +377,15 @@ def backfill_usage_from_claude_sessions(cycles: List[Dict[str, Any]], slug: str)
                 cy["duration_s"] = int(ue["duration_ms"] / 1000)
             continue
         # Path 2: salvage from claude's own session log.
-        if cy.get("tokens"):
+        if cy.get("input_tokens") or cy.get("output_tokens"):
             continue
         u = load_claude_session_usage(cy.get("label", ""), slug)
         if not u:
             continue
-        cy["tokens"] = mp.total_tokens(
-            input_tokens=u["input_tokens"],
-            output_tokens=u["output_tokens"],
-            cache_creation_tokens=u["cache_creation_tokens"],
-            cache_read_tokens=u["cache_read_tokens"],
-        )
+        cy["input_tokens"]          = int(u.get("input_tokens")          or 0)
+        cy["output_tokens"]         = int(u.get("output_tokens")         or 0)
+        cy["cache_creation_tokens"] = int(u.get("cache_creation_tokens") or 0)
+        cy["cache_read_tokens"]     = int(u.get("cache_read_tokens")     or 0)
         cy["model"] = u["model"]
         cy["cost_list"] = mp.compute_list_cost(
             u["model"],
@@ -553,15 +555,27 @@ def bucket_by_day(cycles: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]
     return out
 
 def rollup_for_day(day_cycles: List[Dict[str, Any]]) -> Dict[str, Any]:
+    # US-VIEW-012: track input + output separately so the daily summary can
+    # show two metric rows. cache_read tokens deliberately excluded — they're
+    # already captured in cy["cost_list"] via list-price math (compute_list_cost
+    # reads all 4 fields), but they don't represent the model's actual work.
     r = {"cycles": len(day_cycles), "prs": 0, "failed": 0,
-         "duration_s": 0, "cost": 0.0, "tokens": 0}
+         "duration_s": 0, "cost": 0.0,
+         "input_tokens": 0, "output_tokens": 0,
+         "cache_creation_tokens": 0, "cache_read_tokens": 0}
     for cy in day_cycles:
         if cy.get("outcome") == "fail":
             r["failed"] += 1
         if cy.get("duration_s"):
             r["duration_s"] += cy["duration_s"]
-        if cy.get("tokens"):
-            r["tokens"] += cy["tokens"]
+        if cy.get("input_tokens"):
+            r["input_tokens"] += cy["input_tokens"]
+        if cy.get("output_tokens"):
+            r["output_tokens"] += cy["output_tokens"]
+        if cy.get("cache_creation_tokens"):
+            r["cache_creation_tokens"] += cy["cache_creation_tokens"]
+        if cy.get("cache_read_tokens"):
+            r["cache_read_tokens"] += cy["cache_read_tokens"]
         # US-VIEW-011: rollup only counts cycles whose PR actually merged.
         # Backward compat: rows where pr_outcome is missing but pr URL exists
         # (no `pr` event after the writer upgrade ran for that cycle) are
@@ -620,9 +634,26 @@ def render(events, cron, state, backlog, *, days=3, lang="both", now=None,
                 c("muted", " · ") + c("dim", state.get("paused_reason", "")))
         eb_zh = c("dim", "  已暂停 · run: roll loop resume")
     else:
-        eb_l = (c("blue", "● IDLE", bold=True) + c("muted", "   ") +
-                c("dim", "next run ") + c("fg", _next_cron_hint(state), bold=True))
-        eb_zh = c("dim", f"  闲置 · 距下一轮 {_next_cron_hint(state, zh=True)}")
+        # FIX-095: surface three-state install/enable status. Pre-FIX, every
+        # case fell through to '● IDLE' which hid 'not installed' and
+        # 'installed/off' from the user.
+        install_state = _detect_install_state()
+        if install_state == "not-installed":
+            eb_l = (c("muted", "○ not installed", bold=True) + c("muted", "   ") +
+                    c("dim", "run ") + c("fg", "roll loop on", bold=True) +
+                    c("dim", " to enable"))
+            eb_zh = c("dim", "  未安装 · 运行 ") + c("fg", "roll loop on") + c("dim", " 启用")
+        elif install_state in ("stale", "disabled"):
+            # FIX-098: 'stale' = plist on disk but agent not registered in launchd.
+            # 'disabled' kept for back-compat (old install_state values). Both mean
+            # the user needs to run 'roll loop on' to bootstrap the agent.
+            eb_l = (c("amber", "◌ STALE — plist present, not loaded", bold=True) + c("muted", "   ") +
+                    c("dim", "run ") + c("fg", "roll loop on", bold=True) + c("dim", " to repair"))
+            eb_zh = c("dim", "  Plist 存在但未加载 · 运行 ") + c("fg", "roll loop on") + c("dim", " 修复")
+        else:
+            eb_l = (c("blue", "● IDLE", bold=True) + c("muted", " · ") +
+                    c("dim", "enabled · next run ") + c("fg", _next_cron_hint(state), bold=True))
+            eb_zh = c("dim", f"  已启用 · 闲置 · 距下一轮 {_next_cron_hint(state, zh=True)}")
 
     # 'last' = the most recent cycle the user can act on — skip cycles that
     # are still running (the running banner already announces those) and skip
@@ -704,7 +735,13 @@ def render(events, cron, state, backlog, *, days=3, lang="both", now=None,
            yest_color="amber" if yest["failed"] > 0 else "dim",
            yest_suffix="⚠" if yest["failed"] > 0 else "")
     metric_dur("duration", today["duration_s"], yest["duration_s"], d2["duration_s"], partial=is_partial)
-    metric_tokens("tokens", today["tokens"],    yest["tokens"],    d2["tokens"],     partial=is_partial)
+    # US-VIEW-017: show all 4 token components so the cost is explainable.
+    # cache_creation (↑) and cache_read (↓) typically account for 80-90% of
+    # cost — hiding them makes the cost line incomprehensible.
+    metric_tokens("input tokens",  today["input_tokens"],  yest["input_tokens"],  d2["input_tokens"],  partial=is_partial)
+    metric_tokens("cache writes",  today["cache_creation_tokens"], yest["cache_creation_tokens"], d2["cache_creation_tokens"], partial=is_partial)
+    metric_tokens("cache reads",   today["cache_read_tokens"],     yest["cache_read_tokens"],     d2["cache_read_tokens"],     partial=is_partial)
+    metric_tokens("output tokens", today["output_tokens"], yest["output_tokens"], d2["output_tokens"], partial=is_partial)
     metric_dollar("cost",   today["cost"],      yest["cost"],      d2["cost"],       partial=is_partial)
 
     print()
@@ -759,6 +796,40 @@ def _read_plist_loop_minute() -> int:
     return int(m.group(1)) if m else 48
 
 
+def _detect_install_state() -> str:
+    """FIX-095 / FIX-098: classify the launchd install state of the loop service.
+
+    Returns one of:
+      'not-installed' — no plist for com.roll.loop.<slug> in ~/Library/LaunchAgents/
+      'stale'         — plist on disk but agent NOT registered in launchd
+                        (happens after roll loop off + roll update without roll loop on)
+      'enabled'       — plist on disk AND registered in launchd
+
+    FIX-098: switched from `launchctl print-disabled` (disabled-overrides DB) to
+    `launchctl print gui/<uid>/<label>` which probes the actual launchd registry.
+    The old approach returned false-positive 'enabled' when the disabled-overrides
+    DB had no entry for the label (empty = not explicitly disabled, not loaded).
+    """
+    slug = project_slug()
+    label = f"com.roll.loop.{slug}"
+    plist = Path(os.path.expanduser("~/Library/LaunchAgents")) / f"{label}.plist"
+    if not plist.exists():
+        return "not-installed"
+    try:
+        uid = os.getuid()
+        result = subprocess.run(
+            ["launchctl", "print", f"gui/{uid}/{label}"],
+            capture_output=True, timeout=2,
+        )
+        if result.returncode == 0:
+            return "enabled"
+        return "stale"
+    except Exception:
+        # launchctl missing or timed out — assume stale (safe: user sees STALE
+        # banner and is told to run 'roll loop on' to repair).
+        return "stale"
+
+
 def _next_cron_hint(state: Dict[str, str], zh: bool = False) -> str:
     """Compute next cron fire time from the actual launchd plist Minute (FIX-063)."""
     now = datetime.now().astimezone()

package/lib/roll-peer.py

@@ -30,7 +30,7 @@ _AGENT_COLOR = {
     "codex":    "pink",
     "kimi":     "amber",
     "deepseek": "green",
-    "gemini":   "purple",
+    "agy":      "purple",   # Antigravity (formerly Gemini CLI)
     "pi":       "yellow",
     "opencode": "muted",
     "trae":     "fg",

package/lib/roll-status.py

@@ -160,7 +160,7 @@ def _fixture_data() -> Dict[str, Any]:
         ai_clients=[
             {"name": "claude",  "cfg_file": "CLAUDE.md",  "path": "~/.claude/CLAUDE.md",   "sync": "sync",        "skills": 12},
             {"name": "cursor",  "cfg_file": "AGENTS.md",  "path": "~/.cursor/AGENTS.md",    "sync": "out-of-sync", "skills": 12},
-            {"name": "gemini",  "cfg_file": "GEMINI.md",  "path": "~/.gemini/GEMINI.md",    "sync": "missing",     "skills": 0},
+            {"name": "agy",     "cfg_file": "GEMINI.md",  "path": "~/.gemini/GEMINI.md",    "sync": "missing",     "skills": 0},
         ],
         templates=[
             ("fullstack", 14), ("frontend-only", 9), ("backend-service", 11), ("cli", 7),

package/lib/roll_render.py

@@ -159,7 +159,8 @@ def trunc(s: str, n: int) -> str:
     return out
 
 def empty_rollup() -> Dict[str, Any]:
-    return {"cycles": 0, "prs": 0, "failed": 0, "duration_s": 0, "cost": 0.0, "tokens": 0}
+    return {"cycles": 0, "prs": 0, "failed": 0, "duration_s": 0, "cost": 0.0,
+            "input_tokens": 0, "output_tokens": 0}
 
 # ════════════════════════════════════════════════════════════════════════════
 # Section / metric / cycle rows — printers used by all dashboards
@@ -297,7 +298,19 @@ def cycle_row(cy: Dict[str, Any], backlog: Dict[str, str]) -> None:
         from datetime import datetime as _dt, timezone as _tz
         dur_s = int((_dt.now(_tz.utc) - cy["start"]).total_seconds())
     dur = fmt_dur(dur_s) if dur_s else "—"
-    tok = fmt_tokens(cy.get("tokens") or 0)
+    # US-VIEW-017: show all 4 token components when cache data is available.
+    # Format: "in/cw↑ cr↓/out" (cache writes ↑, cache reads ↓).
+    # Falls back to "in/out" for cycles that predate cache tracking.
+    inp = cy.get('input_tokens') or 0
+    out_tok = cy.get('output_tokens') or 0
+    cw  = cy.get('cache_creation_tokens') or 0
+    cr  = cy.get('cache_read_tokens') or 0
+    if cw or cr:
+        tok = (f"{fmt_tokens(inp)}"
+               f"/{fmt_tokens(cw)}↑ {fmt_tokens(cr)}↓"
+               f"/{fmt_tokens(out_tok)}")
+    else:
+        tok = f"{fmt_tokens(inp)}/{fmt_tokens(out_tok)}"
     # cost prefers the backfilled list-price; falls back to cron.log when
     # the claude session log isn't available (only the latest cycle).
     if cy.get("cost_list") is not None:
@@ -341,7 +354,7 @@ def cycle_row(cy: Dict[str, Any], backlog: Dict[str, str]) -> None:
         "  " + c(glyph_c, glyph, bold=True) + "  " +
         c(time_c, pad(time_str, 5), bold=(outcome == "fail")) + "   " +
         c("muted", pad(dur, 4, "r")) + "  " +
-        c("muted", pad(tok, 6, "r")) + "  " +
+        c("muted", pad(tok, 26)) + "  " +
         model_seg +
         c("muted", pad(cost, 7, "r")) + "   " +
         c(sid_c, ids_str, bold=True) + pr_marker