@seanyao/roll 2026.526.1 → 2026.528.1

package/lib/backfill-pi-usage.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+backfill-pi-usage — one-time, idempotent recovery of pi/deepseek token+cost
+into an existing loop events file.
+
+Why this exists
+---------------
+Before US-LOOP-026 the loop ran pi via ``pi -p`` (text mode), which prints no
+usage. loop-fmt's old passthrough still appended a ``stage=="usage"`` event on
+every retry attempt, each with ``model=="pi"`` and null tokens — so a single
+cycle accumulated up to ~180 empty usage events. The dashboard SUMS token
+fields across same-label usage events; with all-null tokens the SUM was 0
+(harmless), but it means every affected cycle shows ``—/—``.
+
+pi persists every session to ``~/.pi/agent/sessions/<enc-cwd>/<ts>_<uuid>.jsonl``
+with real per-message usage. This script recovers that, and rewrites the events
+file so each affected cycle is left with **exactly one** authoritative usage
+event (real tokens, cost frozen in native CNY) — collapsing the N null events to
+avoid the dashboard ×N inflation.
+
+Safety / idempotency
+--------------------
+- Backs up the events file to ``<file>.bak-<UTC>`` first; aborts if backup fails.
+- Only touches labels whose usage events are all pi-vendor (``model`` in
+  {"pi", "deepseek-v4-pro"}) AND carry null tokens AND match a pi session.
+  claude cycles, already-real cycles, and unmatched-null cycles are passed
+  through untouched.
+- Re-runnable: once a label has a real-token usage event it is no longer a
+  candidate, so a second run is a no-op.
+- FIX-065 tripwire: refuses to rewrite a production ``~/.shared/roll`` events
+  file from a test context (BATS / temp cwd) unless HOME itself is sandboxed.
+
+Usage
+-----
+    python3 lib/backfill-pi-usage.py --slug roll-ecf079
+    python3 lib/backfill-pi-usage.py --events /path/to/events.ndjson --dry-run
+"""
+
+import argparse
+import importlib.util
+import json
+import os
+import shutil
+import sys
+from datetime import datetime, timezone
+
+_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+
+PI_VENDOR_MODELS = ("pi", "deepseek-v4-pro")
+
+
+def _load_pi_emit():
+    spec = importlib.util.spec_from_file_location(
+        "pi_emit", os.path.join(_THIS_DIR, "agent_usage", "pi_emit.py")
+    )
+    m = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(m)
+    return m
+
+
+def _default_events_path(slug, shared=None):
+    base = shared or os.environ.get("LOOP_SHARED_ROOT") \
+        or os.path.expanduser("~/.shared/roll")
+    return os.path.join(base, "loop", "events-%s.ndjson" % slug)
+
+
+def _is_test_context():
+    return bool(os.environ.get("BATS_TEST_FILENAME")) or _cwd_is_temp()
+
+
+def _cwd_is_temp():
+    p = os.environ.get("PWD") or os.getcwd()
+    return any(seg in p for seg in ("/tmp/", "/private/tmp/", "/var/folders/", "/tmp."))
+
+
+def _home_is_sandbox():
+    home = os.environ.get("HOME") or ""
+    return any(seg in home for seg in ("/tmp/", "/private/tmp/", "/var/folders/", "/tmp."))
+
+
+def _tripwire(evfile):
+    """FIX-065: refuse a prod write from a test context."""
+    home = os.environ.get("HOME") or ""
+    if not home or _home_is_sandbox():
+        return
+    prod = os.path.join(home, ".shared", "roll") + os.sep
+    if os.path.abspath(evfile).startswith(os.path.abspath(prod)) and _is_test_context():
+        raise SystemExit(
+            "[FIX-065] refusing to rewrite prod events file from test context: %s" % evfile
+        )
+
+
+def _scan(lines):
+    """Parse lines → (events_or_None list, per-label usage summary).
+
+    Returns (parsed, labels) where parsed is a list of (raw_line, obj_or_None)
+    preserving order, and labels maps label → {"pi": bool, "real": bool}.
+    """
+    parsed = []
+    labels = {}
+    for raw in lines:
+        obj = None
+        try:
+            obj = json.loads(raw)
+        except (ValueError, TypeError):
+            obj = None
+        parsed.append((raw, obj))
+        if not obj or obj.get("stage") != "usage":
+            continue
+        lab = obj.get("label")
+        d = obj.get("detail") or {}
+        rec = labels.setdefault(lab, {"pi": False, "real": False})
+        if d.get("model") in PI_VENDOR_MODELS:
+            rec["pi"] = True
+        if d.get("input_tokens"):
+            rec["real"] = True
+    return parsed, labels
+
+
+def backfill(evfile, slug=None, shared=None, base_dir=None, dry_run=False):
+    """Rewrite evfile so each recoverable pi cycle nets one real usage event.
+
+    Returns a stats dict.
+    """
+    _tripwire(evfile)
+    pi_emit = _load_pi_emit()
+
+    with open(evfile) as f:
+        lines = f.readlines()
+
+    parsed, labels = _scan(lines)
+
+    # Candidate = pi-vendor, all-null, and a session match yields real usage.
+    candidates = [l for l, r in labels.items() if r["pi"] and not r["real"]]
+    replacement = {}  # label -> detail payload
+    matched, unmatched = [], []
+    for lab in candidates:
+        cwd = os.path.join(
+            (shared or os.environ.get("LOOP_SHARED_ROOT")
+             or os.path.expanduser("~/.shared/roll")),
+            "worktrees", "%s-cycle-%s" % (slug, lab),
+        )
+        ev = pi_emit.build_event(cwd=cwd, cycle_id=lab, slug=slug, base_dir=base_dir)
+        if ev is None:
+            unmatched.append(lab)
+            continue
+        replacement[lab] = ev["detail"]
+        matched.append(lab)
+
+    if dry_run or not matched:
+        # Nothing recoverable to rewrite → no backup, no write (keeps re-runs
+        # a true no-op instead of spawning empty .bak files).
+        return {
+            "candidates": len(candidates),
+            "matched": len(matched),
+            "unmatched": len(unmatched),
+            "matched_labels": sorted(matched),
+            "unmatched_labels": sorted(unmatched),
+            "written": False,
+        }
+
+    # Backup before any write; abort the whole run if backup fails.
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    bak = "%s.bak-%s" % (evfile, stamp)
+    shutil.copy2(evfile, bak)
+
+    # Stream rewrite: for an affected label, the FIRST usage line becomes the
+    # real event (original ts preserved so it stays in its day bucket), every
+    # subsequent same-label usage line is dropped → exactly one per label.
+    emitted = set()
+    out = []
+    for raw, obj in parsed:
+        if not obj or obj.get("stage") != "usage":
+            out.append(raw)
+            continue
+        lab = obj.get("label")
+        if lab not in replacement:
+            out.append(raw)  # claude / already-real / unmatched-null: untouched
+            continue
+        if lab in emitted:
+            continue  # collapse the remaining null duplicates away
+        new_ev = {
+            "ts": obj.get("ts"),
+            "stage": "usage",
+            "label": lab,
+            "detail": replacement[lab],
+            "outcome": "ok",
+        }
+        out.append(json.dumps(new_ev) + "\n")
+        emitted.add(lab)
+
+    tmp = evfile + ".tmp-%s" % stamp
+    with open(tmp, "w") as f:
+        f.writelines(out)
+    os.replace(tmp, evfile)
+
+    return {
+        "candidates": len(candidates),
+        "matched": len(matched),
+        "unmatched": len(unmatched),
+        "matched_labels": sorted(matched),
+        "unmatched_labels": sorted(unmatched),
+        "backup": bak,
+        "written": True,
+    }
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="backfill pi/deepseek usage into events file")
+    ap.add_argument("--slug", help="project slug (resolves default events path + session cwd)")
+    ap.add_argument("--events", help="explicit events file path (overrides --slug default)")
+    ap.add_argument("--shared", help="shared root (default ~/.shared/roll)")
+    ap.add_argument("--base-dir", help="pi sessions root override (tests)")
+    ap.add_argument("--dry-run", action="store_true", help="report only, write nothing")
+    args = ap.parse_args(argv)
+
+    evfile = args.events or _default_events_path(args.slug, args.shared)
+    if not os.path.isfile(evfile):
+        print("[backfill] no events file: %s" % evfile, file=sys.stderr)
+        return 1
+    if not args.slug:
+        # slug is needed to reconstruct session cwd; derive from filename.
+        base = os.path.basename(evfile)
+        if base.startswith("events-") and base.endswith(".ndjson"):
+            args.slug = base[len("events-"):-len(".ndjson")]
+
+    stats = backfill(
+        evfile, slug=args.slug, shared=args.shared,
+        base_dir=args.base_dir, dry_run=args.dry_run,
+    )
+    mode = "DRY-RUN" if args.dry_run else "WROTE"
+    print("[backfill] %s %s" % (mode, evfile))
+    print("  candidates=%d matched=%d unmatched=%d"
+          % (stats["candidates"], stats["matched"], stats["unmatched"]))
+    if stats.get("backup"):
+        print("  backup=%s" % stats["backup"])
+    if stats["unmatched_labels"]:
+        print("  unmatched (left as null): %s" % ", ".join(stats["unmatched_labels"]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/lib/i18n.sh

@@ -15,31 +15,19 @@
 #             > (macOS) AppleLanguages > 'en'.
 # Decision:   value starting with `zh` → "zh", everything else → "en".
 
-# Sanitize a free-form key into a variable-safe suffix. Anything that isn't a
-# letter, digit, or underscore becomes an underscore so callers can use natural
-# dotted keys like "loop.cycle_start" without exploding bash syntax.
-_i18n_safe_key() {
-  echo "${1//[^A-Za-z0-9_]/_}"
-}
-
-# Uppercase a lang code without forking for the EN/ZH common case.
-# macOS still ships bash 3.2 which doesn't have ${var^^}; this helper keeps
-# the no-subshell goal for the languages we actually ship.
-_i18n_upper() {
-  case "$1" in
-    en|EN) printf 'EN' ;;
-    zh|ZH) printf 'ZH' ;;
-    *)     printf '%s' "$1" | tr '[:lower:]' '[:upper:]' ;;
-  esac
-}
-
 # Fill the catalog. Modules call this at source-time:
 #   _i18n_set en hello "Hello, %s!"
 #   _i18n_set zh hello "你好，%s！"
+# No subshell forks: lang uppercasing uses a case statement (bash 3.2-safe;
+# ${var^^} requires bash 4+), key sanitization uses inline param-expansion.
 _i18n_set() {
   local lang="$1" key="$2" val="$3"
   local upper safe varname
-  upper="$(_i18n_upper "$lang")"
+  case "$lang" in
+    en|EN) upper=EN ;;
+    zh|ZH) upper=ZH ;;
+    *)     upper="$(printf '%s' "$lang" | tr '[:lower:]' '[:upper:]')" ;;
+  esac
   safe="${key//[^A-Za-z0-9_]/_}"        # inline param-expansion — no subshell fork
   varname="MSG_${upper}_${safe}"
   printf -v "$varname" '%s' "$val"
@@ -135,7 +123,11 @@ msg() {
 msg_lang() {
   local lang="$1" key="$2"; shift 2 || true
   local upper safe varname tmpl
-  upper="$(_i18n_upper "$lang")"
+  case "$lang" in
+    en|EN) upper=EN ;;
+    zh|ZH) upper=ZH ;;
+    *)     upper="$(printf '%s' "$lang" | tr '[:lower:]' '[:upper:]')" ;;
+  esac
   safe="${key//[^A-Za-z0-9_]/_}"
   varname="MSG_${upper}_${safe}"
   tmpl="${!varname:-}"

package/lib/loop-fmt.py

@@ -445,9 +445,10 @@ def _passthrough_main(agent):
     """Transparent forwarding for non-claude agents (pi, deepseek, kimi, …).
 
     Writes every stdin line to stdout with a HH:MM:SS timestamp prefix so
-    tmux shows real-time progress.  Also appends each line as a lightweight
-    'usage'-type event to the per-slug events ndjson — token / cost fields
-    are set to null (agent-specific parsing is out of scope for this US).
+    tmux shows real-time progress.  Accumulates all lines; at cycle end,
+    dispatches to the agent_usage plugin registry (US-LOOP-026).  If a plugin
+    returns real token/cost data, emits a single usage event with it;
+    otherwise falls back to a single null-payload event (US-LOOP-010 compat).
     """
     slug   = os.environ.get("LOOP_PROJECT_SLUG")
     cycle  = os.environ.get("LOOP_CYCLE_ID")
@@ -460,24 +461,35 @@ def _passthrough_main(agent):
         except Exception:
             evfile = None
 
+    # Accumulate all lines for end-of-cycle usage extraction.
+    accumulated: list[str] = []
+
     for line in sys.stdin:
         if not line.rstrip():
             continue
+        accumulated.append(line.rstrip())
         # Timestamp prefix so tmux shows activity (even if agent output has
         # no timestamps of its own).
         ts = datetime.now(timezone.utc).strftime("%H:%M:%S")
         out = f"{DARK_GRAY}{ts}{RESET}  {line.rstrip()}"
         sys.stdout.write(out + "\n")
         sys.stdout.flush()
-        # Emit a lightweight usage event so the cycle has *some* event trace
-        # (token/cost are null — parsing those is agent-specific and out of
-        # scope for the minimal transparent-passthrough US).
-        if evfile:
-            _emit_passthrough_event(evfile, cycle, agent, line.rstrip())
+
+    # Passthrough is display-only. Usage is NOT emitted from here:
+    #  - pi -p text mode carries no usage in stdout (nothing to extract), and
+    #  - this runs once per retry attempt, so emitting here wrote N usage
+    #    events per cycle and the dashboard SUMS same-label usage → ×N.
+    # Instead bin/roll calls agent_usage/pi_emit.py exactly once after the
+    # agent phase, recovering real usage from pi's session files. The
+    # _emit_* helpers below are retained for US-LOOP-010 unit tests.
+    _ = (accumulated, evfile)  # intentionally unused now
 
 
 def _emit_passthrough_event(evfile, cycle, agent, text):
-    """Best-effort append a usage-type event to evfile."""
+    """Best-effort append a usage-type event to evfile (null payload).
+
+    Kept for backward-compat with US-LOOP-010 tests.
+    """
     payload = {
         "model":        agent,
         "input_tokens":  None,
@@ -499,6 +511,52 @@ def _emit_passthrough_event(evfile, cycle, agent, text):
         pass
 
 
+def _emit_final_usage_event(evfile, cycle, agent, accumulated_lines):
+    """Try plugin extraction; emit one usage event (real or null).
+
+    US-LOOP-026: at cycle end, dispatches accumulated stdout to the
+    agent_usage plugin registry.  If a plugin returns real data, emits
+    a usage event with it.  Otherwise emits a single null-payload event
+    (US-LOOP-010 backward-compat).
+    """
+    payload = None
+    try:
+        from agent_usage import extract_usage
+        usage = extract_usage(agent, accumulated_lines)
+        if usage is not None:
+            payload = {
+                "model":        usage.get("model", agent),
+                "input_tokens":  usage.get("input_tokens"),
+                "output_tokens": usage.get("output_tokens"),
+                "cost_list_usd": usage.get("cost_list_usd"),
+                "duration_ms":   usage.get("duration_ms"),
+            }
+    except Exception:
+        pass
+
+    if payload is None:
+        payload = {
+            "model":        agent,
+            "input_tokens":  None,
+            "output_tokens": None,
+            "cost_list_usd": None,
+            "duration_ms":   None,
+        }
+
+    record = json.dumps({
+        "ts":      datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "stage":   "usage",
+        "label":   cycle,
+        "detail":  payload,
+        "outcome": "ok",
+    }) + "\n"
+    try:
+        with open(evfile, "a") as f:
+            f.write(record)
+    except Exception:
+        pass
+
+
 def main():
     agent = os.environ.get("ROLL_LOOP_AGENT", "claude")
     if agent == "claude":

package/lib/prices/snapshot-2026-05-23-deepseek.json

@@ -1,15 +1,15 @@
 {
   "version": "2026-05-23",
   "effective_at": "2026-05-23",
-  "source_url": "https://api-docs.deepseek.com/quick_start/pricing",
+  "source_url": "https://api-docs.deepseek.com/zh-cn/quick_start/pricing/",
   "vendor": "deepseek",
-  "currency": "USD",
+  "currency": "CNY",
   "default_model": "deepseek-chat",
-  "notes": "Rates per million tokens (USD). deepseek-chat and deepseek-reasoner are both deepseek-v4-flash with different thinking modes — same pricing. deepseek-v4-pro has 75% promotional discount until 2026-05-31. cache_create estimated at 1.25x input (same convention as Claude snapshot). cache_hit discount per official docs: 1/50 for flash ($0.14→$0.0028), 1/120 for pro ($0.435→$0.003625). Actual cache_create not published by DeepSeek — using 1.25x input convention.",
+  "notes": "Rates per million tokens in CNY (¥) — DeepSeek's native billing currency; we never convert to USD (the dashboard already shows the currency symbol). deepseek-chat and deepseek-reasoner are both deepseek-v4-flash with different thinking modes — same pricing. deepseek-v4-pro is under a 2.5折 (75% off) promo until Beijing time 2026-05-31 23:59 (normal: in 12 / out 24); after expiry, refresh this snapshot. cache_read is the official cache-hit input price (reduced to 1/10 of launch price since 2026-04-26). cache_create = cache-miss input rate: DeepSeek levies no separate cache-write surcharge, and pi reports cacheWrite cost as 0, so this rate only ever applies to (near-zero) cacheWrite tokens. pi's own per-message cost.total is computed in USD and is kept as cost_reported_usd for audit, NOT used for the authoritative cost.",
   "prices": {
-    "deepseek-chat":        {"in": 0.14, "out": 0.28, "cache_create": 0.175,  "cache_read": 0.0028},
-    "deepseek-reasoner":    {"in": 0.14, "out": 0.28, "cache_create": 0.175,  "cache_read": 0.0028},
-    "deepseek-v4-flash":    {"in": 0.14, "out": 0.28, "cache_create": 0.175,  "cache_read": 0.0028},
-    "deepseek-v4-pro":      {"in": 0.435, "out": 0.87, "cache_create": 0.54375, "cache_read": 0.003625}
+    "deepseek-chat":        {"in": 1, "out": 2, "cache_create": 1, "cache_read": 0.02},
+    "deepseek-reasoner":    {"in": 1, "out": 2, "cache_create": 1, "cache_read": 0.02},
+    "deepseek-v4-flash":    {"in": 1, "out": 2, "cache_create": 1, "cache_read": 0.02},
+    "deepseek-v4-pro":      {"in": 3, "out": 6, "cache_create": 3, "cache_read": 0.025}
   }
 }

package/lib/roll-loop-status.py

@@ -711,8 +711,13 @@ def rollup_for_day(day_cycles: List[Dict[str, Any]]) -> Dict[str, Any]:
     # 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.
+    # FIX-126: cost is tracked per-currency. deepseek bills in native CNY (¥),
+    # claude in USD ($) — summing them into one number (and stamping it "$")
+    # is meaningless. `cost` stays as a legacy scalar sum for back-compat with
+    # callers that don't care about currency; `cost_by_cur` is the currency-
+    # aware breakdown the dashboard ROLLUP renders (one row per currency).
     r = {"cycles": len(day_cycles), "prs": 0, "failed": 0,
-         "duration_s": 0, "cost": 0.0,
+         "duration_s": 0, "cost": 0.0, "cost_by_cur": {},
          "input_tokens": 0, "output_tokens": 0,
          "cache_creation_tokens": 0, "cache_read_tokens": 0}
     for cy in day_cycles:
@@ -736,10 +741,14 @@ def rollup_for_day(day_cycles: List[Dict[str, Any]]) -> Dict[str, Any]:
             r["prs"] += 1
         if cy.get("cost_list") is not None:
             r["cost"] += cy["cost_list"]
+            cur = cy.get("cost_currency") or "USD"
+            r["cost_by_cur"][cur] = r["cost_by_cur"].get(cur, 0.0) + cy["cost_list"]
         elif cy.get("cron"):
             # No claude session backfill available — fall back to whatever
-            # cron.log carries (best-effort, only the latest cycle).
+            # cron.log carries (best-effort, only the latest cycle). cron.log
+            # cost is claude's USD figure.
             r["cost"] += cy["cron"]["cost"]
+            r["cost_by_cur"]["USD"] = r["cost_by_cur"].get("USD", 0.0) + cy["cron"]["cost"]
     return r
 
 # ════════════════════════════════════════════════════════════════════════════
@@ -753,8 +762,12 @@ def render(events, cron, state, backlog, *, days=3, lang="both", now=None,
         merge_runs_into_cycles(cycles, runs)
     if git_merges:
         repair_orphan_cycles_from_git(cycles, git_merges)
-    if claude_slug:
-        backfill_usage_from_claude_sessions(cycles, claude_slug)
+    # Path 1 (usage_event from the events stream) is authoritative and needs no
+    # slug; path 2 (claude session-log salvage) self-guards on the worktree dir
+    # existing, so it's a no-op when claude_slug is empty. Always run both — the
+    # old `if claude_slug:` gate dropped real per-currency cost for any caller
+    # that didn't pass a slug (FIX-126).
+    backfill_usage_from_claude_sessions(cycles, claude_slug or "")
     by_day = bucket_by_day(cycles)
     days_keys = sorted(by_day.keys(), reverse=True)[:days]
 
@@ -894,7 +907,28 @@ def render(events, cron, state, backlog, *, days=3, lang="both", now=None,
     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)
+    # FIX-126: one cost row per currency (deepseek ¥, claude $) — never summed
+    # across currencies. Show a currency only if it has spend in any of the 3
+    # days; default to a single USD row when there's no cost at all.
+    _cost_days = (today, yest, d2)
+    _currencies = []
+    for _cur in ["USD", "CNY"]:
+        if any(r["cost_by_cur"].get(_cur) for r in _cost_days):
+            _currencies.append(_cur)
+    for r in _cost_days:
+        for _cur in r["cost_by_cur"]:
+            if _cur not in _currencies and r["cost_by_cur"][_cur]:
+                _currencies.append(_cur)
+    if not _currencies:
+        _currencies = ["USD"]
+    for _cur in _currencies:
+        _sym = "¥" if _cur == "CNY" else "$"
+        _label = "cost" if len(_currencies) == 1 else "cost " + _sym
+        metric_dollar(_label,
+                      today["cost_by_cur"].get(_cur, 0.0),
+                      yest["cost_by_cur"].get(_cur, 0.0),
+                      d2["cost_by_cur"].get(_cur, 0.0),
+                      partial=is_partial, symbol=_sym)
 
     print()
     print(c("faint", "─" * COLS))
@@ -931,13 +965,10 @@ def render(events, cron, state, backlog, *, days=3, lang="both", now=None,
           c("muted", "       ") +
           c("dim", "more   ") + c("blue", "roll loop status --days 7"))
 
-# US-LOOP-013: valid schedule periods (must divide 60)
-_VALID_SCHEDULE_PERIODS = {60, 30, 20, 15, 12, 10, 6, 5}
-
-
+# US-LOOP-032: period 1–1440; offset 0–59 (deprecated, kept for backward compat)
 def _schedule_valid(period: int, offset: int) -> bool:
-    """Validate schedule spec: period must divide 60, offset in [0, period)."""
-    return period in _VALID_SCHEDULE_PERIODS and 0 <= offset < period
+    """Validate schedule spec: period 1–1440, offset in [0, 60)."""
+    return 1 <= period <= 1440 and 0 <= offset < 60
 
 
 def _read_schedule_spec(project_root: Optional[Path] = None) -> Tuple[int, int]:

package/lib/roll_render.py

@@ -146,8 +146,8 @@ def fmt_delta(today: float, yest: float, *, kind: str, unit: str = "") -> Tuple[
     arrow = "▲" if diff > 0 else "▼"
     sign = "+" if diff > 0 else "−"
     mag = abs(diff)
-    if unit == "$":
-        body = f"{sign}${mag:.2f}"
+    if unit in ("$", "¥"):
+        body = f"{sign}{unit}{mag:.2f}"
     elif unit == "m":
         body = f"{sign}{int(round(mag))}m"
     else:
@@ -215,16 +215,20 @@ def metric_dur(name: str, t: int, y: int, d2: int, *, partial: bool = False) ->
           c("dim", pad(fmt_dur(y), 10)) +
           c("muted", pad(fmt_dur(d2), 8)))
 
-def metric_dollar(name: str, t: float, y: float, d2: float, *, partial: bool = False) -> None:
-    delta_text, delta_c = fmt_delta(t, y, kind="up_bad", unit="$")
+def metric_dollar(name: str, t: float, y: float, d2: float, *,
+                  partial: bool = False, symbol: str = "$") -> None:
+    # FIX-126: currency-aware — deepseek cost is native CNY (¥), claude USD ($).
+    # We never convert; the rollup shows one row per currency with its own
+    # symbol, so a ¥-row and a $-row are never summed into a meaningless total.
+    delta_text, delta_c = fmt_delta(t, y, kind="up_bad", unit=symbol)
     if partial and delta_c not in ("muted",):
         delta_c = "muted"
     print("  " +
           c("dim", pad(name, 14)) +
-          c("fg", pad(f"${t:.2f}", 8, "r"), bold=True) + "  " +
+          c("fg", pad(f"{symbol}{t:.2f}", 8, "r"), bold=True) + "  " +
           c(delta_c, pad(delta_text, 12), bold=(delta_c != "muted")) +
-          c("dim", pad(f"${y:.2f}", 10)) +
-          c("muted", pad(f"${d2:.2f}", 8)))
+          c("dim", pad(f"{symbol}{y:.2f}", 10)) +
+          c("muted", pad(f"{symbol}{d2:.2f}", 8)))
 
 def metric_tokens(name: str, t: int, y: int, d2: int, *, partial: bool = False) -> None:
     # Compose the delta string with token-unit scaling so a 200M increase

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seanyao/roll",
-  "version": "2026.526.1",
+  "version": "2026.528.1",
   "description": "Roll — Roll out features with AI agents",
   "scripts": {
     "test": "bash tests/run.sh"

package/skills/roll-design/SKILL.md

@@ -121,7 +121,7 @@ Document structure (two-layer separation):
 3. **FIX / IDEA detail files use ID-prefixed filenames**: `.roll/features/<epic>/FIX-097.md`, not `.roll/features/<epic>/some-descriptive-slug.md`. Reason: a single FIX is one card, not a long-lived feature; the ID is the most stable handle, descriptive slugs date quickly and break links. US can keep feature-slug naming (US lives inside a multi-Story feature file). Quick lookup: `ls .roll/features/<epic>/FIX-*.md` finds all bugs in that area without grepping content.
 4. .roll/backlog.md only contains index rows (one row per US), **do not write** AC / Files / Notes
 5. Domain model files go in `.roll/domain/` — create on first greenfield design, update incrementally
-6. **Do not** write to `~/.kimi/` or any global config directory
+6. **Do not** write to `~/.kimi/`, `~/.kimi-code/`, or any global config directory
 
 **File path resolution order:**
 1. Determine Feature ownership (based on the requirement domain: compiler / ingest / qa / ...)

package/template/.github/workflows/ci.yml

@@ -11,12 +11,12 @@ jobs:
     runs-on: ubuntu-latest
     
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version: '24'
           cache: 'npm'
       
       - name: Install dependencies