@seanyao/roll 2026.523.2 → 2026.524.2

package/lib/loop-fmt.py

@@ -346,11 +346,11 @@ class LoopFmt:
 
     @staticmethod
     def _price_at_snapshot(model, totals):
-        """Resolve (cost_list_usd, prices_version) from the active price snapshot.
+        """Resolve (cost_list, currency, prices_version) from the active price snapshot.
 
-        Returns (None, None) when model_prices isn't loadable or the snapshot
+        Returns (None, None, None) when model_prices isn't loadable or the snapshot
         has no usable prices — callers still emit the event so token data and
-        duration aren't lost. When tokens are all zero, cost_list_usd is None.
+        duration aren't lost. When tokens are all zero, cost_list is None.
         """
         try:
             import importlib.util
@@ -361,11 +361,11 @@ class LoopFmt:
             mp = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(mp)
         except Exception:
-            return None, None
+            return None, None, None
         prices_version = getattr(mp, "VERSION", None)
         has_tokens = any(int(totals.get(k) or 0) > 0 for k in totals)
         if not has_tokens:
-            return None, prices_version
+            return None, None, prices_version
         try:
             cost = mp.compute_list_cost(
                 model,
@@ -374,9 +374,10 @@ class LoopFmt:
                 cache_creation_tokens=int(totals.get("cache_creation_tokens") or 0),
                 cache_read_tokens=int(totals.get("cache_read_tokens") or 0),
             )
+            currency = mp.currency_for(model) if model else "USD"
         except Exception:
-            return None, prices_version
-        return float(cost), prices_version
+            return None, None, prices_version
+        return float(cost), currency, prices_version
 
     def _emit_usage_event(self, result_ev, dur_ms, cost_usd):
         slug    = os.environ.get("LOOP_PROJECT_SLUG")
@@ -405,7 +406,9 @@ class LoopFmt:
         # later prices refresh (or roll upgrade) never rewrites history. The
         # dashboard reads cost_list_usd first; only legacy events without it
         # fall back to recomputing and get tagged [legacy].
-        cost_list_usd, prices_version = self._price_at_snapshot(
+        # FIX-116: also capture cost_currency so the dashboard shows the
+        # correct currency symbol (e.g. $ for USD, ¥ for CNY).
+        cost_list_usd, cost_currency, prices_version = self._price_at_snapshot(
             model if has_model else None,
             self._usage_totals,
         )
@@ -419,6 +422,7 @@ class LoopFmt:
             "cost_reported_usd":     float(cost_usd) if has_cost else None,
             "duration_ms":           int(dur_ms) if has_dur else None,
             "cost_list_usd":         cost_list_usd,
+            "cost_currency":         cost_currency,
             "prices_version":        prices_version,
         }
         evfile = os.path.join(shared, "loop", f"events-{slug}.ndjson")
@@ -437,11 +441,73 @@ class LoopFmt:
             pass  # best-effort; never break tmux output
 
 
-def main():
-    fmt = LoopFmt()
+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).
+    """
+    slug   = os.environ.get("LOOP_PROJECT_SLUG")
+    cycle  = os.environ.get("LOOP_CYCLE_ID")
+    shared = os.environ.get("LOOP_SHARED_ROOT") or os.path.expanduser("~/.shared/roll")
+    evfile = None
+    if slug and cycle:
+        evfile = os.path.join(shared, "loop", f"events-{slug}.ndjson")
+        try:
+            os.makedirs(os.path.dirname(evfile), exist_ok=True)
+        except Exception:
+            evfile = None
+
     for line in sys.stdin:
-        fmt.process(line)
+        if not line.rstrip():
+            continue
+        # 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())
+
+
+def _emit_passthrough_event(evfile, cycle, agent, text):
+    """Best-effort append a usage-type event to evfile."""
+    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":
+        fmt = LoopFmt()
+        for line in sys.stdin:
+            fmt.process(line)
+            sys.stdout.flush()
+    else:
+        _passthrough_main(agent)
 
 if __name__ == "__main__":
     main()

package/lib/loop_unstick.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""FIX-112: revert 🔨 In Progress stories whose latest cycle definitively
+failed and has been quiet for a while. Default safe gate is conservative:
+
+- Story row is currently 🔨 In Progress in backlog
+- Most recent `pick_todo <story_id>` event in events-<slug>.ndjson lives in
+  a cycle whose `cycle_end` outcome is one of: failed | aborted | blocked
+- That cycle_end timestamp is at least N hours ago (default 4)
+
+Stories that match are flipped back to 📋 Todo and an ALERT note is appended
+to the per-project ALERT file. Stories still actively running, or claimed
+by a human / agent for legitimate work (no failed cycle_end), stay alone.
+
+Usage:
+  python3 lib/loop_unstick.py            # apply (writes backlog + ALERT)
+  python3 lib/loop_unstick.py --dry-run  # report what would change, write nothing
+  python3 lib/loop_unstick.py --ttl-hours 8
+
+Returns 0 always (idempotent). Prints one line per reverted story.
+"""
+from __future__ import annotations
+import argparse, json, os, re, sys, time
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+_LIB_DIR = os.path.dirname(os.path.realpath(__file__))
+if _LIB_DIR not in sys.path:
+    sys.path.insert(0, _LIB_DIR)
+
+# FIX-108-compatible: accept multi-segment story IDs (US-VIEW-011, US-I18N-001)
+# and alphanumeric segments (K8S, D2, 2FA-ish layouts within rules).
+ID_RE   = re.compile(r"^\s*\[?([A-Z][A-Z0-9]*(?:-[A-Z][A-Z0-9]*)*-\d+)")
+TICK    = chr(96)
+
+def _shared_root() -> Path:
+    # bin/roll uses _SHARED_ROOT, lib/roll-home.py uses ROLL_SHARED_ROOT.
+    # Honor both so tests that sandbox either name work transparently.
+    root = os.environ.get("ROLL_SHARED_ROOT") or os.environ.get("_SHARED_ROOT")
+    return Path(root or os.path.expanduser("~/.shared/roll"))
+
+def _project_slug() -> str:
+    try:
+        import subprocess, hashlib
+        path = os.path.realpath(os.getcwd())
+        common = subprocess.check_output(
+            ["git", "-C", path, "rev-parse", "--git-common-dir"],
+            stderr=subprocess.DEVNULL, text=True,
+        ).strip()
+        if common.endswith("/.git"):
+            path = common[:-5]
+    except Exception:
+        path = os.path.realpath(os.getcwd())
+    import hashlib
+    base = re.sub(r"[^A-Za-z0-9]+", "-", os.path.basename(path)).strip("-")
+    h = hashlib.md5(path.encode()).hexdigest()[:6]
+    return f"{base}-{h}"
+
+def _read_events(slug: str) -> list:
+    path = _shared_root() / "loop" / f"events-{slug}.ndjson"
+    out = []
+    if not path.exists():
+        return out
+    with path.open(errors="ignore") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                ev = json.loads(line)
+                ts = ev.get("ts", "")
+                ev["_ts"] = datetime.fromisoformat(ts.replace("Z", "+00:00")) if ts else None
+                out.append(ev)
+            except Exception:
+                continue
+    return out
+
+def _scan_in_progress(backlog: Path) -> list:
+    """Return list of (line_index, story_id, raw_line) for rows that are 🔨 In Progress."""
+    if not backlog.exists():
+        return []
+    rows = []
+    for i, line in enumerate(backlog.open(errors="ignore")):
+        if "| 🔨 In Progress |" not in line:
+            continue
+        if not line.startswith("|"):
+            continue
+        parts = [p.strip() for p in line.split("|")]
+        if len(parts) < 4:
+            continue
+        m = ID_RE.match(parts[1])
+        if not m:
+            continue
+        rows.append((i, m.group(1), line.rstrip("\n")))
+    return rows
+
+def _cycle_end_for_pick(events: list, story_id: str):
+    """Return (cycle_end_ts, outcome) of the latest cycle that picked
+    story_id, or None if no such cycle / cycle still running."""
+    # Walk events back to front looking for the latest pick_todo matching story_id
+    latest_pick = None
+    for ev in reversed(events):
+        if ev.get("stage") == "pick_todo" and ev.get("detail") == story_id:
+            latest_pick = ev
+            break
+    if not latest_pick:
+        return None
+    label = latest_pick.get("label", "")
+    # Look forward (from the pick) for cycle_end with the same label
+    pick_idx = events.index(latest_pick)
+    for ev in events[pick_idx + 1:]:
+        if ev.get("stage") == "cycle_end" and ev.get("label", "").endswith(label):
+            return ev.get("_ts"), ev.get("outcome", "")
+    return None
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--ttl-hours", type=float, default=4.0,
+                    help="Minimum hours since failed cycle_end before reverting (default 4)")
+    ap.add_argument("--backlog", default=".roll/backlog.md")
+    args = ap.parse_args()
+
+    backlog = Path(args.backlog)
+    if not backlog.exists():
+        print(f"backlog not found: {backlog}", file=sys.stderr)
+        return 0
+
+    slug = _project_slug()
+    events = _read_events(slug)
+    in_progress = _scan_in_progress(backlog)
+    if not in_progress:
+        return 0
+
+    now = datetime.now(timezone.utc)
+    cutoff = now - timedelta(hours=args.ttl_hours)
+    candidates_to_revert = []
+
+    failed_outcomes = {"failed", "aborted", "blocked"}
+    for line_idx, sid, raw in in_progress:
+        result = _cycle_end_for_pick(events, sid)
+        if not result:
+            continue  # still running OR no failed cycle yet — leave alone
+        end_ts, outcome = result
+        if outcome not in failed_outcomes:
+            continue
+        if not end_ts or end_ts > cutoff:
+            continue  # too recent
+        age_hours = (now - end_ts).total_seconds() / 3600
+        candidates_to_revert.append((line_idx, sid, raw, outcome, age_hours))
+
+    if not candidates_to_revert:
+        return 0
+
+    if args.dry_run:
+        for line_idx, sid, raw, outcome, age in candidates_to_revert:
+            print(f"would-revert {sid} (cycle ended {outcome} {age:.1f}h ago)")
+        return 0
+
+    # Apply: read backlog, flip status, write back.
+    lines = backlog.read_text(errors="ignore").splitlines(keepends=True)
+    for line_idx, sid, raw, outcome, age in candidates_to_revert:
+        lines[line_idx] = lines[line_idx].replace("| 🔨 In Progress |", "| 📋 Todo |")
+
+    backlog.write_text("".join(lines))
+
+    # Append ALERT
+    alert_file = _shared_root() / "loop" / f"ALERT-{slug}.md"
+    alert_file.parent.mkdir(parents=True, exist_ok=True)
+    with alert_file.open("a") as f:
+        for line_idx, sid, raw, outcome, age in candidates_to_revert:
+            ts = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+            f.write(f"[{ts}] unstick: reverted {sid} (cycle ended {outcome} {age:.1f}h ago, > {args.ttl_hours}h TTL)\n")
+
+    for line_idx, sid, raw, outcome, age in candidates_to_revert:
+        print(f"reverted {sid} (cycle ended {outcome} {age:.1f}h ago)")
+
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

package/lib/model_prices.py

@@ -1,14 +1,21 @@
 """
-model_prices — list-price table for Anthropic Claude API models.
+model_prices — list-price table for AI model API pricing.
 
-Pricing is per million tokens (MTok), USD. These are the public list rates;
-discounts (Pro subscription, prepay credits, etc.) are intentionally not
-modeled — IDEA-025 is about cross-account / cross-project comparable cost.
+Pricing is per million tokens (MTok), in the vendor's native currency.
+These are the public list rates; discounts (Pro subscription, prepay
+credits, etc.) are intentionally not modeled — IDEA-025 is about
+cross-account / cross-project comparable cost.
 
 US-VIEW-013: prices are no longer hardcoded here. They live in versioned
 snapshot files under ``lib/prices/snapshot-YYYY-MM-DD.json`` and are loaded
 at module import time. ``roll prices refresh`` produces new snapshots; this
-module never writes — it only loads the latest one.
+module never writes — it only loads all snapshots and merges them.
+
+FIX-116: multi-vendor support — snapshots carry ``vendor`` and ``currency``
+fields. All snapshots are loaded and merged into a single PRICES map, with
+each model entry carrying its native ``currency``. Vendor-prefixed model
+names (``deepseek/deepseek-chat``) are resolved by stripping the vendor
+segment when no exact match exists.
 
 Unknown models fall back to the snapshot's ``default_model`` with a stderr
 warning so dashboards don't blank out.
@@ -45,6 +52,8 @@ def load_snapshot(path: str) -> Dict[str, Any]:
     if not isinstance(data["prices"], dict) or not data["prices"]:
         raise ValueError(f"snapshot {path!r} has empty or invalid prices map")
     data.setdefault("default_model", next(iter(data["prices"])))
+    data.setdefault("vendor", "anthropic")
+    data.setdefault("currency", "USD")
     return data
 
 
@@ -58,12 +67,34 @@ def load_latest_snapshot(snapshot_dir: str = SNAPSHOT_DIR) -> Dict[str, Any]:
     return load_snapshot(snaps[-1])
 
 
-_SNAPSHOT: Dict[str, Any] = load_latest_snapshot()
-PRICES: Dict[str, Dict[str, float]] = _SNAPSHOT["prices"]
-DEFAULT: str = _SNAPSHOT["default_model"]
-VERSION: str = _SNAPSHOT["version"]
-EFFECTIVE_AT: str = _SNAPSHOT["effective_at"]
-SOURCE_URL: str = _SNAPSHOT["source_url"]
+def load_all_snapshots(snapshot_dir: str = SNAPSHOT_DIR) -> List[Dict[str, Any]]:
+    """Load all snapshots, sorted oldest → newest. Raises FileNotFoundError if none."""
+    snaps = list_snapshots(snapshot_dir)
+    if not snaps:
+        raise FileNotFoundError(
+            f"no price snapshots found in {snapshot_dir}; run `roll prices refresh`"
+        )
+    return [load_snapshot(p) for p in snaps]
+
+
+_SNAPSHOTS: List[Dict[str, Any]] = load_all_snapshots()
+_DEFAULT_SNAP: Dict[str, Any] = _SNAPSHOTS[-1]
+
+# Merge PRICES from all snapshots, injecting currency per model.
+# Later snapshots override earlier ones for the same model name.
+PRICES: Dict[str, Dict[str, float]] = {}
+_CURRENCY: Dict[str, str] = {}
+for _snap in _SNAPSHOTS:
+    _snap_currency = _snap.get("currency", "USD")
+    for _model, _rates in _snap["prices"].items():
+        PRICES[_model] = dict(_rates)
+        PRICES[_model]["currency"] = _snap_currency
+        _CURRENCY[_model] = _snap_currency
+
+DEFAULT: str = _DEFAULT_SNAP["default_model"]
+VERSION: str = _DEFAULT_SNAP["version"]
+EFFECTIVE_AT: str = _DEFAULT_SNAP["effective_at"]
+SOURCE_URL: str = _DEFAULT_SNAP["source_url"]
 
 _warned: set = set()
 
@@ -80,9 +111,20 @@ def _resolve(model: Optional[str], prices: Optional[Dict[str, Dict[str, float]]]
     if not model:
         return table[fallback]
     base = model.split("[")[0].rstrip("0123456789-")
+
+    # Direct match: model starts with a known key
     candidates = [k for k in table if model.startswith(k) or base.startswith(k)]
     if candidates:
         return table[max(candidates, key=len)]
+
+    # Vendor prefix: try stripping "vendor/" segment for proxy tools (pi, etc.)
+    if "/" in model:
+        inner = model.split("/", 1)[1]
+        inner_base = inner.split("[")[0].rstrip("0123456789-")
+        for k in table:
+            if inner == k or inner_base == k or inner.startswith(k) or inner_base.startswith(k):
+                return table[k]
+
     if model not in _warned:
         _warned.add(model)
         print(f"[model_prices] warn: unknown model {model!r}, falling back to {fallback}",
@@ -90,6 +132,45 @@ def _resolve(model: Optional[str], prices: Optional[Dict[str, Dict[str, float]]]
     return table[fallback]
 
 
+def _resolve_name(model: Optional[str],
+                  prices: Optional[Dict[str, Dict[str, float]]] = None,
+                  default: Optional[str] = None) -> str:
+    """Return the canonical model name (key in PRICES) for a given model string.
+
+    Same resolution logic as _resolve, but returns the matched key name
+    instead of the rate dict. Used by currency_for() to find the currency.
+    """
+    table = prices if prices is not None else PRICES
+    fallback = default if default is not None else DEFAULT
+    if not model:
+        return fallback
+    base = model.split("[")[0].rstrip("0123456789-")
+
+    # Direct match: model starts with a known key
+    candidates = [k for k in table if model.startswith(k) or base.startswith(k)]
+    if candidates:
+        return max(candidates, key=len)
+
+    # Vendor prefix: try stripping "vendor/" segment
+    if "/" in model:
+        inner = model.split("/", 1)[1]
+        inner_base = inner.split("[")[0].rstrip("0123456789-")
+        for k in table:
+            if inner == k or inner_base == k or inner.startswith(k) or inner_base.startswith(k):
+                return k
+
+    return fallback
+
+
+def currency_for(model: Optional[str]) -> str:
+    """Return the native currency code (USD/CNY) for a model.
+
+    Falls back to 'USD' when the model isn't in any snapshot.
+    """
+    name = _resolve_name(model)
+    return _CURRENCY.get(name, "USD")
+
+
 def compute_list_cost(model: Optional[str],
                       *,
                       input_tokens: int = 0,
@@ -98,7 +179,7 @@ def compute_list_cost(model: Optional[str],
                       cache_read_tokens: int = 0,
                       prices: Optional[Dict[str, Dict[str, float]]] = None,
                       default: Optional[str] = None) -> float:
-    """Return USD cost at list price for one cycle's token usage."""
+    """Return cost (in native currency) at list price for one cycle's token usage."""
     p = _resolve(model, prices=prices, default=default)
     total = (input_tokens         * p["in"]
            + output_tokens        * p["out"]

package/lib/prices/snapshot-2026-05-22.json

@@ -2,6 +2,8 @@
   "version": "2026-05-22",
   "effective_at": "2026-05-22",
   "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+  "vendor": "anthropic",
+  "currency": "USD",
   "default_model": "claude-sonnet-4-6",
   "notes": "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. 2026-05 repricing: Opus 4.5+ moved to $5/$25 base (3x cheaper than Opus 4/4.1).",
   "prices": {

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

@@ -0,0 +1,15 @@
+{
+  "version": "2026-05-23",
+  "effective_at": "2026-05-23",
+  "source_url": "https://api-docs.deepseek.com/quick_start/pricing",
+  "vendor": "deepseek",
+  "currency": "USD",
+  "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.",
+  "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}
+  }
+}

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

@@ -0,0 +1,14 @@
+{
+  "version": "2026-05-23",
+  "effective_at": "2026-05-23",
+  "source_url": "https://platform.kimi.com/docs/pricing/chat",
+  "vendor": "kimi",
+  "currency": "USD",
+  "default_model": "kimi-k2.5",
+  "notes": "Rates per million tokens (USD). cache_create estimated at 1.25x input. Prices from public Kimi API platform docs — verify with `roll prices refresh` if page layout changes. Model names: kimi-k2 (prior gen), kimi-k2.5 (current), kimi-k2.6 (latest).",
+  "prices": {
+    "kimi-k2":   {"in": 1.00, "out": 4.00, "cache_create": 1.25, "cache_read": 0.25},
+    "kimi-k2.5": {"in": 1.00, "out": 4.00, "cache_create": 1.25, "cache_read": 0.25},
+    "kimi-k2.6": {"in": 1.00, "out": 4.00, "cache_create": 1.25, "cache_read": 0.25}
+  }
+}

package/lib/roll-home.py

@@ -76,6 +76,22 @@ def _load_config() -> Dict[str, str]:
             return d
     return {}
 
+
+def _resolve_project_agent(config: Dict[str, str]) -> str:
+    """FIX-117: home banner agent label must honor project-level override
+    in `.roll/local.yaml` (set by `roll agent use`), not just the global
+    `~/.roll/config.yaml#primary_agent`. Mirror bin/roll _project_agent
+    precedence: local.yaml > .roll.yaml > config.primary_agent > 'claude'."""
+    for path in (
+        Path(".roll/local.yaml"),
+        Path(".roll.yaml"),
+    ):
+        if path.exists():
+            local = _load_yaml_flat(path)
+            if local.get("agent"):
+                return local["agent"]
+    return config.get("primary_agent") or "claude"
+
 def _git_info() -> Tuple[str, str]:
     try:
         branch = subprocess.check_output(
@@ -482,7 +498,7 @@ def main() -> None:
         d = dict(
             project_name   = os.path.basename(os.getcwd()),
             version        = _roll_version(),
-            agent          = config.get("primary_agent") or "claude",
+            agent          = _resolve_project_agent(config),
             git_branch     = bra,
             git_status     = gs,
             timestamp      = datetime.now().strftime("%H:%M"),

package/lib/roll-loop-status.py

@@ -231,6 +231,12 @@ def aggregate(events: List[Dict[str, Any]], cron: List[Dict[str, Any]]) -> List[
             sid = _extract_story_id(detail)
             if sid:
                 cy["story"] = sid
+        elif stage == "agent_used":
+            # FIX-119: non-claude agents don't expose model in stream-json.
+            # The inner runner emits an agent_used event with the agent name
+            # so the dashboard can show it when cy["model"] is None.
+            if detail:
+                cy["agent"] = detail
         elif stage == "usage":
             # US-LOOP-004: loop-fmt emits this with full token / cost data.
             # Detail is a dict (not the legacy string form).
@@ -373,6 +379,7 @@ def backfill_usage_from_claude_sessions(cycles: List[Dict[str, Any]], slug: str)
             persisted = ue.get("cost_list_usd")
             if persisted is not None:
                 cy["cost_list"]        = float(persisted)
+                cy["cost_currency"]    = ue.get("cost_currency") or "USD"
                 cy["cost_list_legacy"] = False
             else:
                 cy["cost_list"] = mp.compute_list_cost(
@@ -382,6 +389,7 @@ def backfill_usage_from_claude_sessions(cycles: List[Dict[str, Any]], slug: str)
                     cache_creation_tokens=ue.get("cache_creation_tokens", 0),
                     cache_read_tokens=ue.get("cache_read_tokens", 0),
                 )
+                cy["cost_currency"]    = mp.currency_for(ue.get("model")) or "USD"
                 cy["cost_list_legacy"] = True
             if ue.get("duration_ms") and not cy.get("duration_s"):
                 cy["duration_s"] = int(ue["duration_ms"] / 1000)
@@ -404,6 +412,7 @@ def backfill_usage_from_claude_sessions(cycles: List[Dict[str, Any]], slug: str)
             cache_creation_tokens=u["cache_creation_tokens"],
             cache_read_tokens=u["cache_read_tokens"],
         )
+        cy["cost_currency"]    = mp.currency_for(u["model"]) or "USD"
         # US-VIEW-014: session salvage never has a frozen cycle_end cost, so
         # this path is always legacy.
         cy["cost_list_legacy"] = True

package/lib/roll_render.py

@@ -313,10 +313,13 @@ def cycle_row(cy: Dict[str, Any], backlog: Dict[str, str]) -> None:
         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).
+    # FIX-116: use the model's native currency symbol.
+    cur = cy.get("cost_currency", "USD")
+    symbol = "¥" if cur == "CNY" else "$"
     if cy.get("cost_list") is not None:
-        cost = f"${cy['cost_list']:.2f}"
+        cost = f"{symbol}{cy['cost_list']:.2f}"
     elif cr:
-        cost = f"${cr.get('cost', 0):.2f}"
+        cost = f"{symbol}{cr.get('cost', 0):.2f}"
     else:
         cost = "—"
     sid = cy.get("story") or "—"
@@ -333,6 +336,11 @@ def cycle_row(cy: Dict[str, Any], backlog: Dict[str, str]) -> None:
     sid_c   = "red" if outcome == "fail" else "blue"
 
     model_label = fmt_model(cy.get("model"))
+    # FIX-119: fall back to cy["agent"] (from agent_used event) when model
+    # is unknown — non-claude agents (pi, deepseek, kimi) don't expose model
+    # info in stream-json, leaving a "—" or "?" on the dashboard.
+    if model_label in ("—", "?") and cy.get("agent"):
+        model_label = cy["agent"]
     # Auto-hide model column on narrow screens — keeps the dashboard readable
     # when terminal is < 100 cols (cost / story IDs are higher-priority).
     show_model = COLS >= 100

package/package.json

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

package/skills/roll-.dream/SKILL.md

@@ -2,13 +2,13 @@
 hidden: true
 name: roll-.dream
 license: MIT
-allowed-tools: "Read, Glob, Grep, Bash(git:*), Write, Edit"
+allowed-tools: "Read, Glob, Grep, Bash(git:*, curl:*, claude:*), Write, Edit"
 description: |
   Nightly code and architecture health scan. Passively triggered by scheduler
   (cron or GitHub Actions), not invoked by users directly. Detects dead code,
   architectural drift from domain model, pruning candidates, emerging patterns,
-  doc coverage gaps, and doc staleness (文档新鲜度). Outputs REFACTOR entries
-  to .roll/backlog.md and a daily log to .roll/dream/.
+  doc coverage gaps, and doc staleness (文档新鲜度).
+  Outputs REFACTOR entries to .roll/backlog.md and a daily log to .roll/dream/.
   Distinct from roll-sentinel: sentinel monitors runtime behavior; dream reviews
   code structure and architectural health.
 ---
@@ -34,7 +34,7 @@ in the morning brief.
 
 ## Scan Logic
 
-Run all six scans every night. Each scan is independent.
+Run all scans every night. Each scan is independent.
 
 ### Scan 1 — Dead Code