@seanyao/roll 2026.522.1 → 2026.522.2

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,8 @@ 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["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 +375,13 @@ 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["model"] = u["model"]
         cy["cost_list"] = mp.compute_list_cost(
             u["model"],
@@ -553,15 +551,22 @@ 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}
     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"]
         # 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 +625,23 @@ 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 == "disabled":
+            eb_l = (c("amber", "◌ installed/off", bold=True) + c("muted", "   ") +
+                    c("dim", "loop disabled — run ") + c("fg", "roll loop on", bold=True))
+            eb_zh = c("dim", "  未启用 · 运行 ") + 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 +723,12 @@ 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-012: input + output as two separate rows. cache_read no longer
+    # surfaces here — true cost is on the "cost" line below (computed from all
+    # 4 token kinds via list price). This row labels what the model actually
+    # processed and generated for this cycle.
+    metric_tokens("input tokens",  today["input_tokens"],  yest["input_tokens"],  d2["input_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 +783,37 @@ def _read_plist_loop_minute() -> int:
     return int(m.group(1)) if m else 48
 
 
+def _detect_install_state() -> str:
+    """FIX-095: classify the launchd install state of the loop service.
+
+    Returns one of:
+      'not-installed' — no plist for com.roll.loop.<slug> in ~/Library/LaunchAgents/
+      'disabled'      — plist exists but launchctl print-disabled shows '=> disabled'
+      'enabled'       — plist exists and no disable override is set
+
+    Pre-FIX-095, the v2 view rendered '● IDLE' for all three states, leaving
+    users unable to tell whether the loop was actually installed/enabled.
+    """
+    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()
+        out = subprocess.run(
+            ["launchctl", "print-disabled", f"gui/{uid}"],
+            capture_output=True, text=True, timeout=2,
+        ).stdout or ""
+        for line in out.splitlines():
+            if f'"{label}"' in line and "=> disabled" in line:
+                return "disabled"
+    except Exception:
+        # launchctl missing or timed out — best-effort fall through to enabled.
+        pass
+    return "enabled"
+
+
 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,12 @@ 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-012: token column shows model's real work as input/output. Cache
+    # creation / cache read are kept in events.ndjson for cost math but never
+    # surface in the UI — they would inflate the visible number to 10–100× the
+    # "real" work done by the model on this cycle. fmt_tokens(0) already
+    # returns "—", so a cycle missing usage_event prints as "—/—".
+    tok = f"{fmt_tokens(cy.get('input_tokens') or 0)}/{fmt_tokens(cy.get('output_tokens') or 0)}"
     # 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 +347,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, 11, "r")) + "  " +
         model_seg +
         c("muted", pad(cost, 7, "r")) + "   " +
         c(sid_c, ids_str, bold=True) + pr_marker