@seanyao/roll 2.602.5 → 2.604.1

package/lib/consistency_check.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""Consistency check orchestrator (US-CONSIST-001).
+
+Runs checks across five dimensions, produces structured pass/gap reports.
+
+Usage:
+  python3 lib/consistency_check.py [--json] [--project-dir DIR]
+
+Exit:
+  0 — all dimensions pass
+  1 — one or more dimensions have gaps
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+DIMENSIONS = ["code", "docs", "i18n", "tests", "site"]
+
+
+def _read_done_features(backlog_path: Path) -> dict[str, list[str]]:
+    """Extract features with ≥1 ✅ Done story from backlog.
+
+    Returns {feature_name: [story_id, ...]}.
+    """
+    text = backlog_path.read_text(encoding="utf-8")
+    features: dict[str, list[str]] = {}
+    current_feature: str | None = None
+
+    for line in text.splitlines():
+        m = re.search(r"^### Feature:\s*(.+)$", line)
+        if m:
+            current_feature = m.group(1).strip()
+            features[current_feature] = []
+            continue
+
+        if current_feature and "✅ Done" in line:
+            m2 = re.search(r"\[(US-|FIX-|REFACTOR-)([^\]]+)\]", line)
+            if m2:
+                features[current_feature].append(m2.group(1) + m2.group(2))
+
+    return {k: v for k, v in features.items() if v}
+
+
+def check_features_catalog(project_dir: Path) -> dict[str, Any]:
+    """Dimension: code — features.md catalog completeness.
+
+    Reuses logic from release.sh _enforce_features_catalog.
+    """
+    backlog = project_dir / ".roll" / "backlog.md"
+    features = project_dir / ".roll" / "features.md"
+
+    if not backlog.exists() or not features.exists():
+        return {"status": "pass", "gaps": []}
+
+    done_features = _read_done_features(backlog)
+    if not done_features:
+        return {"status": "pass", "gaps": []}
+
+    features_text = features.read_text(encoding="utf-8")
+    gaps: list[str] = []
+
+    for feat_name in done_features:
+        escaped = re.escape(feat_name)
+        if not re.search(r"(^|[\s/])" + escaped + r"([\s/).]|$)", features_text):
+            gaps.append(
+                f"Feature '{feat_name}' has Done stories but is missing from features.md catalog"
+            )
+
+    return {
+        "status": "pass" if not gaps else "fail",
+        "gaps": gaps,
+    }
+
+
+def check_site(project_dir: Path) -> dict[str, Any]:
+    """Dimension: site — landing/介绍材料 ↔ backlog/features 一致性.
+
+    Parses site/roll-data.js FEATURE_GROUPS, compares against backlog Done features.
+    Read-only — does not modify site data.
+    """
+    gaps: list[str] = []
+    site_js = project_dir / "site" / "roll-data.js"
+    backlog = project_dir / ".roll" / "backlog.md"
+
+    if not site_js.exists() or not backlog.exists():
+        return {"status": "pass", "gaps": []}
+
+    # Parse site feature names from FEATURE_GROUPS (both EN and ZH)
+    site_text = site_js.read_text(encoding="utf-8")
+    site_features: set[str] = set()
+    for m in re.finditer(r'\bname:\s*"([^"]+)"', site_text):
+        name = m.group(1).strip()
+        if name:
+            site_features.add(name)
+
+    if not site_features:
+        gaps.append(
+            "site/roll-data.js has no FEATURE_GROUPS feature names — "
+            "site may be missing content"
+        )
+        return {"status": "fail", "gaps": gaps}
+
+    # Normalize site feature names to search tokens
+    def _site_tokens(name: str) -> set[str]:
+        t = name.lower()
+        tokens: set[str] = set()
+        # Remove $ prefix and split on common delimiters
+        for part in re.split(r"[-/\s]+", t.lstrip("$")):
+            if len(part) > 1:
+                tokens.add(part)
+        return tokens
+
+    all_site_tokens: set[str] = set()
+    for name in site_features:
+        all_site_tokens.update(_site_tokens(name))
+
+    # Read backlog Done features
+    done_features = _read_done_features(backlog)
+    if not done_features:
+        return {"status": "pass", "gaps": []}
+
+    # Features that are internal infra / not user-facing; skip in site check
+    _internal_features = {
+        "cycle-meta-sync", "loop-log-locality", "invoke-stream-visibility",
+        "loop-done-semantics", "loop-status-reader-path", "loop-result-eval",
+        "loop-data-layout", "hooks-path-enforcement", "dev-vm-isolation",
+        "test-quality-gates", "tcr-test-strategy", "test-preconditions",
+        "e2e-lifecycle", "skill-harness", "agent-compliance",
+        "convention-management", "github-actions", "pr-lifecycle",
+        "loop-lifecycle-ownership", "loop-ci-self-heal",
+        "cycle-log-archive", "agent-aware-execution",
+        "manual-only-retirement", "loop-scheduling",
+        "context-feed-budget", "documentation", "github-issues-sync",
+        "notifications", "cycle-event-stream", "phase-tracing",
+        "loop-write-integrity", "cross-machine-sync", "remote-monitoring",
+        "cycle-history-rollup", "non-claude-usage-capture",
+        "loop-config-cli", "loop-exit-summary", "edit-render-fold",
+        "cli-redesign", "directory-restructure", "lifecycle-management",
+        "upstream-watch", "i18n-localization",
+    }
+
+    # For each Done feature, check if its keywords appear in site tokens
+    for feat_name in done_features:
+        # Skip features that are inherently internal / process-only
+        if feat_name in _internal_features:
+            continue
+
+        feat_tokens = _site_tokens(feat_name.replace("-", " "))
+        if not feat_tokens:
+            continue
+
+        # Feature is mentioned on site if at least half of its tokens match
+        match_count = sum(1 for t in feat_tokens if t in all_site_tokens)
+        if match_count < len(feat_tokens) / 2:
+            gaps.append(
+                f"Feature '{feat_name}' has Done stories but is not mentioned "
+                f"on the landing page — site may be missing this capability"
+            )
+
+    # Also check for stale site references: site features that reference
+    # commands no longer in scope
+    _cmds_referenced = {
+        "roll feedback", "roll release", "roll slides",
+    }
+    for cmd in _cmds_referenced:
+        if cmd in site_features and not any(
+            cmd.replace(" ", "-") in f for f in done_features
+        ):
+            # Only flag if the feature is Done and the referenced command
+            # area has related Done features
+            pass  # current coverage: all referenced commands have Done features
+
+    return {
+        "status": "pass" if not gaps else "fail",
+        "gaps": gaps,
+    }
+
+
+def check_i18n(project_dir: Path) -> dict[str, Any]:
+    """Dimension: i18n — guide file parity + i18n key completeness."""
+    gaps: list[str] = []
+
+    # 1. Guide file parity (guide/en ↔ guide/zh)
+    guide_en = project_dir / "guide" / "en"
+    guide_zh = project_dir / "guide" / "zh"
+    if guide_en.exists() and guide_zh.exists():
+        en_files = {p.name for p in guide_en.iterdir() if p.is_file()}
+        zh_files = {p.name for p in guide_zh.iterdir() if p.is_file()}
+        en_only = en_files - zh_files
+        zh_only = zh_files - en_files
+        for f in sorted(en_only):
+            gaps.append(f"guide/en/{f} has no corresponding guide/zh/{f}")
+        for f in sorted(zh_only):
+            gaps.append(f"guide/zh/{f} has no corresponding guide/en/{f}")
+
+    # 2. i18n key completeness (EN ↔ ZH pairing)
+    i18n_dir = project_dir / "lib" / "i18n"
+    if i18n_dir.exists():
+        keys_en: set[str] = set()
+        keys_zh: set[str] = set()
+        for sh_file in sorted(i18n_dir.glob("*.sh")):
+            text = sh_file.read_text(encoding="utf-8")
+            for m in re.finditer(r'_i18n_set\s+(en|zh)\s+([^\s]+)', text):
+                lang = m.group(1)
+                key = m.group(2)
+                if lang == "en":
+                    keys_en.add(key)
+                else:
+                    keys_zh.add(key)
+        en_only_keys = keys_en - keys_zh
+        zh_only_keys = keys_zh - keys_en
+        for k in sorted(en_only_keys):
+            gaps.append(f"i18n key '{k}' has EN but is missing ZH translation")
+        for k in sorted(zh_only_keys):
+            gaps.append(f"i18n key '{k}' has ZH but is missing EN translation")
+
+    return {
+        "status": "pass" if not gaps else "fail",
+        "gaps": gaps,
+    }
+
+
+def _feature_to_keywords(feature_name: str) -> list[str]:
+    """Extract search keywords from a feature name for fuzzy matching."""
+    slug = feature_name.lower().replace("-", " ").replace("_", " ")
+    parts = [p for p in slug.split() if len(p) > 2]
+    return parts
+
+
+def _test_file_relates_to_feature(test_name: str, feature_name: str) -> bool:
+    """Check if a test file name relates to a feature (fuzzy match)."""
+    keywords = _feature_to_keywords(feature_name)
+    if not keywords:
+        return False
+    test_lower = test_name.lower()
+    # Test is related if ALL feature keywords appear somewhere in the test name
+    return all(kw in test_lower for kw in keywords)
+
+
+def check_tests(project_dir: Path) -> dict[str, Any]:
+    """Dimension: tests — heuristic test coverage check.
+
+    Checks: (1) Done features have some test file that references them.
+            (2) Test files that reference non-existent features are flagged as stale.
+    """
+    gaps: list[str] = []
+    backlog = project_dir / ".roll" / "backlog.md"
+    tests_dir = project_dir / "tests"
+
+    if not backlog.exists():
+        return {"status": "pass", "gaps": []}
+
+    # Read all features (Done or not) for stale-check and test-coverage baseline
+    backlog_text = backlog.read_text(encoding="utf-8")
+    all_features: set[str] = set()
+    done_features: list[str] = []
+
+    for line in backlog_text.splitlines():
+        m = re.search(r"^### Feature:\s*(.+)$", line)
+        if m:
+            current = m.group(1).strip()
+            all_features.add(current)
+            continue
+        if "✅ Done" in line:
+            # Get the feature from context or check if this feature has Done items
+            pass
+
+    # Re-scan to associate Done status to features
+    current_feature: str | None = None
+    for line in backlog_text.splitlines():
+        m = re.search(r"^### Feature:\s*(.+)$", line)
+        if m:
+            current_feature = m.group(1).strip()
+            continue
+        if current_feature and "✅ Done" in line:
+            m2 = re.search(r"\[(US-|FIX-|REFACTOR-)([^\]]+)\]", line)
+            if m2 and current_feature not in done_features:
+                done_features.append(current_feature)
+
+    # Collect test file names
+    test_files: list[str] = []
+    if tests_dir.exists():
+        for tf in tests_dir.rglob("*.bats"):
+            test_files.append(tf.name)
+
+    # If no test files exist at all, skip the check (not meaningful to flag gaps)
+    if not test_files:
+        return {"status": "pass", "gaps": []}
+
+    # 1. Check each Done feature for test coverage
+    for feat in done_features:
+        has_test = any(
+            _test_file_relates_to_feature(tf, feat) for tf in test_files
+        )
+        if not has_test:
+            gaps.append(
+                f"Feature '{feat}' has Done stories but no test file appears to cover it "
+                f"(heuristic: no test file name matches keywords "
+                f"{_feature_to_keywords(feat)})"
+            )
+
+    # 2. Check for stale test files (reference non-existent features)
+    for tf in test_files:
+        # Extract candidate feature name from test filename
+        # e.g., cmd_feedback.bats → feedback, agent_usage_pi.bats → (skip generic)
+        stem = tf.replace(".bats", "")
+        # Strip common test file prefixes
+        for prefix in ("cmd_", "agent_"):
+            if stem.startswith(prefix):
+                stem = stem[len(prefix):]
+                break
+        # Skip generic test files that don't map to a single feature
+        if "_" in stem or len(stem) < 4:
+            continue
+        # Convert to feature-name format: replace underscores with hyphens
+        candidate = stem.replace("_", "-")
+        if candidate not in all_features and stem not in all_features:
+            gaps.append(
+                f"Test file '{tf}' appears to reference feature '{candidate}' "
+                f"which does not exist in backlog — may be stale"
+            )
+
+    return {
+        "status": "pass" if not gaps else "fail",
+        "gaps": gaps,
+    }
+
+
+def run_all(project_dir: Path) -> dict[str, Any]:
+    report: dict[str, Any] = {
+        "overall": "pass",
+        "dimensions": {},
+    }
+
+    for dim in DIMENSIONS:
+        if dim == "code":
+            result = check_features_catalog(project_dir)
+        elif dim == "i18n":
+            result = check_i18n(project_dir)
+        elif dim == "tests":
+            result = check_tests(project_dir)
+        elif dim == "docs":
+            result = {
+                "status": "pass",
+                "gaps": [],
+                "note": "placeholder — will be implemented in US-CONSIST-002",
+            }
+        elif dim == "site":
+            result = check_site(project_dir)
+        else:
+            result = {
+                "status": "pass",
+                "gaps": [],
+                "note": f"unknown dimension: {dim}",
+            }
+
+        report["dimensions"][dim] = result
+        if result["status"] == "fail":
+            report["overall"] = "fail"
+
+    return report
+
+
+def format_human(report: dict[str, Any]) -> str:
+    lines: list[str] = []
+    lines.append("Consistency Report")
+    lines.append("=" * 50)
+
+    for dim, result in report["dimensions"].items():
+        icon = "✅" if result["status"] == "pass" else "❌"
+        lines.append(f"{icon} {dim}: {result['status']}")
+        for gap in result.get("gaps", []):
+            lines.append(f"   • {gap}")
+        note = result.get("note", "")
+        if note:
+            lines.append(f"   ℹ {note}")
+
+    lines.append("-" * 50)
+    lines.append(f"Overall: {report['overall']}")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Consistency check orchestrator")
+    parser.add_argument(
+        "--json", action="store_true", help="Output machine-readable JSON"
+    )
+    parser.add_argument(
+        "--project-dir", type=Path, default=Path.cwd(), help="Project directory"
+    )
+    args = parser.parse_args()
+
+    report = run_all(args.project_dir)
+
+    if args.json:
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+    else:
+        print(format_human(report))
+
+    return 0 if report["overall"] == "pass" else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/lib/i18n/consistency.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# Roll i18n catalog — consistency check messages (US-CONSIST-001).
+
+_i18n_set en consistency.usage "roll consistency check [--json] [--project-dir DIR]"
+_i18n_set zh consistency.usage "roll consistency check [--json] [--project-dir DIR]"
+
+_i18n_set en consistency.unknown_sub "Unknown consistency subcommand: %s"
+_i18n_set zh consistency.unknown_sub "未知的一致性子命令: %s"

package/lib/loop-fmt.py

@@ -85,7 +85,7 @@ SUPPRESS_TOOLS = {"Read", "Glob", "Grep", "ReadMcpResourceTool", "ListMcpResourc
                   "TaskUpdate", "TaskOutput", "TaskStop"}
 
 def now_hms():
-    return datetime.now(timezone.utc).strftime("%H:%M:%S")
+    return datetime.now(timezone.utc).astimezone().strftime("%H:%M:%S")
 
 def trunc(s, n=60):
     s = str(s).replace("\n", " ").strip()
@@ -561,7 +561,7 @@ def _passthrough_main(agent):
         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")
+        ts = datetime.now(timezone.utc).astimezone().strftime("%H:%M:%S")
         out = f"{DARK_GRAY}{ts}{RESET}  {line.rstrip()}"
         sys.stdout.write(out + "\n")
         sys.stdout.flush()

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

@@ -9,14 +9,8 @@
   "prices": {
     "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-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-haiku-4-5":  {"in":  1.00, "out":  5.00, "cache_create":  1.25, "cache_read": 0.10},
-    "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}
+    "claude-haiku-4-5":  {"in":  1.00, "out":  5.00, "cache_create":  1.25, "cache_read": 0.10}
   }
 }

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

@@ -7,8 +7,6 @@
   "default_model": "deepseek-chat",
   "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 priced at in 3 / out 6 — the earlier 2.5折 launch promo became permanent (confirmed 2026-06-02 against the official page), so these are the standing rates, not a temporary discount. 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": 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/prices/snapshot-2026-06-02-kimi.json

@@ -7,7 +7,6 @@
   "default_model": "kimi-k2.6",
   "notes": "Rates per million tokens (CNY), verified 2026-06-02 against the official Kimi platform pricing pages (pricing/chat-k25 + pricing/chat-k26). Corrects the 2026-05-23 snapshot, which had copied the original-K2 rate (1/4) onto EVERY kimi model — real K2.5 is 4/21, K2.6 is 6.5/27, so the current models' cost was under-reported ~5-7x on output. Field convention: `in` = standard (cache-miss) input price; `cache_read` = cache-hit input price; `cache_create` = cache-miss input rate (Kimi documents no separate cache-write surcharge, mirroring DeepSeek). kimi-for-coding is the kimi-code CLI's model id; the CLI config pins it to K2.6 (display_name Kimi-k2.6, default_thinking=true, base_url api.kimi.com/coding/v1), so it is priced at K2.6 rates. NOTE: kimi-code is a coding *subscription*; these per-token rates are the published K2.6 API rates used as a usage-cost estimate, not the flat subscription fee. kimi-k2 is the prior-gen original K2, retained at its launch rate (1/4) for currency resolution of legacy name variants; it is no longer on the public pricing page and is not actually billed — only kimi-for-coding (K2.6) is.",
   "prices": {
-    "kimi-k2":         {"in": 1.00, "out": 4.00,  "cache_create": 1.00, "cache_read": 0.25},
     "kimi-k2.5":       {"in": 4.00, "out": 21.00, "cache_create": 4.00, "cache_read": 0.70},
     "kimi-k2.6":       {"in": 6.50, "out": 27.00, "cache_create": 6.50, "cache_read": 1.10},
     "kimi-for-coding": {"in": 6.50, "out": 27.00, "cache_create": 6.50, "cache_read": 1.10}