@seanyao/roll 2.603.1 → 2.604.2

package/lib/changelog_audit.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Changelog audit module (US-CONSIST-002).
+
+Checks that ✅ Done backlog stories are reflected in CHANGELOG.md.
+Provides both coverage checking and gap reporting.
+
+Usage as library:
+  from lib.changelog_audit import check_changelog_coverage
+  result = check_changelog_coverage(done_stories, changelog_path)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def _read_changelog_text(changelog_path: Path) -> str:
+    """Read changelog text, returning empty string if file is missing."""
+    if not changelog_path.exists():
+        return ""
+    return changelog_path.read_text(encoding="utf-8")
+
+
+def check_changelog_coverage(
+    done_stories: dict[str, list[str]],
+    changelog_path: Path,
+) -> dict[str, Any]:
+    """Check that Done stories appear in CHANGELOG.md.
+
+    Args:
+        done_stories: {feature_name: [story_id, ...]} from backlog
+        changelog_path: Path to CHANGELOG.md
+
+    Returns:
+        {"status": "pass"|"fail", "gaps": [descriptions...]}
+    """
+    if not changelog_path.exists():
+        return {"status": "pass", "gaps": []}
+
+    changelog_text = _read_changelog_text(changelog_path)
+    gaps: list[str] = []
+
+    for feature_name, story_ids in done_stories.items():
+        for story_id in story_ids:
+            if story_id not in changelog_text:
+                gaps.append(
+                    f"Story '{story_id}' (feature '{feature_name}') is Done "
+                    "but not referenced in CHANGELOG.md"
+                )
+
+    return {
+        "status": "pass" if not gaps else "fail",
+        "gaps": gaps,
+    }
+
+
+def check_features_md_coverage(
+    done_features: dict[str, list[str]],
+    features_md_path: Path,
+) -> dict[str, Any]:
+    """Check that features with Done stories are listed in features.md.
+
+    Args:
+        done_features: {feature_name: [story_id, ...]} from backlog
+        features_md_path: Path to .roll/features.md
+
+    Returns:
+        {"status": "pass"|"fail", "gaps": [descriptions...]}
+    """
+    import re
+
+    if not features_md_path.exists():
+        return {"status": "pass", "gaps": []}
+
+    features_text = features_md_path.read_text(encoding="utf-8")
+    gaps: list[str] = []
+
+    for feature_name in done_features:
+        escaped = re.escape(feature_name)
+        if not re.search(r"(^|[\s/])" + escaped + r"([\s/).]|$)", features_text):
+            gaps.append(
+                f"Feature '{feature_name}' has Done stories but is missing "
+                "from features.md catalog"
+            )
+
+    return {
+        "status": "pass" if not gaps else "fail",
+        "gaps": gaps,
+    }
+
+
+def check_guide_doc_coverage(
+    done_features: dict[str, list[str]],
+    guide_en_dir: Path,
+) -> dict[str, Any]:
+    """Check that features with Done stories have guide documentation.
+
+    Heuristic: checks whether a .md file in guide/en/ references the feature
+    name or its story IDs.
+
+    Args:
+        done_features: {feature_name: [story_id, ...]} from backlog
+        guide_en_dir: Path to guide/en/
+
+    Returns:
+        {"status": "pass"|"fail", "gaps": [descriptions...]}
+    """
+    if not guide_en_dir.exists() or not guide_en_dir.is_dir():
+        return {"status": "pass", "gaps": []}
+
+    # Collect all guide text
+    all_guide_text = ""
+    for md_file in sorted(guide_en_dir.glob("*.md")):
+        try:
+            all_guide_text += md_file.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+
+    # Also read practices/ subdirectory
+    practices_dir = guide_en_dir / "practices"
+    if practices_dir.exists() and practices_dir.is_dir():
+        for md_file in sorted(practices_dir.glob("*.md")):
+            try:
+                all_guide_text += md_file.read_text(encoding="utf-8")
+            except (OSError, UnicodeDecodeError):
+                continue
+
+    gaps: list[str] = []
+    for feature_name, story_ids in done_features.items():
+        found = False
+        # Check if feature name appears in guide text
+        if feature_name.lower() in all_guide_text.lower():
+            found = True
+        # Check if any story ID appears
+        for sid in story_ids:
+            if sid in all_guide_text:
+                found = True
+                break
+        if not found:
+            gaps.append(
+                f"Feature '{feature_name}' has Done stories but no guide "
+                "documentation found in guide/en/"
+            )
+
+    return {
+        "status": "pass" if not gaps else "fail",
+        "gaps": gaps,
+    }

package/lib/changelog_generate.py

@@ -323,19 +323,31 @@ def _pr_is_covered(
     return False
 
 
-def _build_uncarded_block(uncarded: list[tuple[str, str]]) -> str:
-    lines = [
-        "",
-        "### ⚠️ 待确认(merged 但未入 backlog)",
-        "",
-        "> 以下 PR 已合入主干，但在 backlog 中没有对应的 ✅ Done story，也未出现在 CHANGELOG 中。",
-        "> 请确认是否需要在 Unreleased 中补充条目。",
-        "",
-    ]
+def _uncarded_to_entries(uncarded: list[tuple[str, str]]) -> list[tuple[str, str, str, str]]:
+    """FIX-179: convert uncarded merged PRs (pr_num, title) into draft entries
+    (id, desc, source, category) so they fold into the categorized draft as
+    normal bullets. The old behaviour emitted a separate '⚠️ 待确认 … 请确认'
+    block — a maintainer prompt that must NEVER reach the published CHANGELOG
+    (it leaked into v2.603.1). The "lacked a card" notice now goes to stderr.
+
+    Uses the PR title as the description (stripped of conventional-commit
+    prefixes and the leading id); the story/fix id when present, else PR#<n>.
+    """
+    entries: list[tuple[str, str, str, str]] = []
     for pr_num, title in uncarded:
-        lines.append(f"- PR #{pr_num}: {title}")
-    lines.append("")
-    return "\n".join(lines)
+        t = re.sub(
+            r"^\s*(Fix|tcr|docs|chore|feat|refactor|perf|test|Story\s+\d+)\s*[:：]\s*",
+            "", title, flags=re.I,
+        )
+        idm = re.search(r"\b(US-[A-Z]+-\d+|FIX-\d+|REFACTOR-\d+)\b", title)
+        sid = idm.group(1) if idm else f"PR#{pr_num}"
+        if idm:
+            t = re.sub(r"\b" + re.escape(idm.group(1)) + r"\b\s*[:：]?\s*", "", t).strip()
+        cleaned = _clean_description(t) or t.strip()
+        cat = _detect_category(cleaned)
+        src = "loop" if re.search(r"US-AUTO|US-LOOP|FIX-|REFACTOR-", sid) else ""
+        entries.append((sid, cleaned, src, cat))
+    return entries
 
 
 # ─── Main ────────────────────────────────────────────────────────────────────
@@ -421,23 +433,29 @@ def main() -> int:
         print("# No new ✅ Done stories found for CHANGELOG.")
         return 0
 
+    # FIX-179: fold uncarded merged PRs INTO the categorized draft (complete
+    # coverage) rather than a separate '请确认' warning block — that maintainer
+    # prompt must never reach the published CHANGELOG. The "lacked a card"
+    # notice goes to STDERR so the human still sees what to back-fill.
+    all_entries: list[tuple[str, str, str, str]] = list(filtered) + _uncarded_to_entries(uncarded)
+    if uncarded:
+        pr_list = " ".join(f"#{p}" for p, _t in uncarded)
+        print(
+            f"note: {len(uncarded)} 个 merged PR 未建卡,已按 PR 标题并入草稿,建议补卡: {pr_list}",
+            file=sys.stderr,
+        )
+
     # FIX-178: style-lint warnings go to STDERR so the stdout draft stays clean
     # (no inline `# lint:` markers in the deliverable). The human still sees them.
-    for story_id, desc, source, _cat in filtered:
+    for story_id, desc, source, _cat in all_entries:
         viols = _lint_bullet(_format_bullet(desc, source, story_id))
         if viols:
             print(f"lint: {story_id or '?'}: {', '.join(viols)}", file=sys.stderr)
 
-    if filtered:
-        groups: dict[str, list[tuple[str, str, str]]] = {}
-        for story_id, desc, source, cat in filtered:
-            groups.setdefault(cat, []).append((story_id, desc, source))
-        draft = _build_draft(groups)
-    else:
-        draft = ""
-
-    if uncarded:
-        draft += _build_uncarded_block(uncarded)
+    groups: dict[str, list[tuple[str, str, str]]] = {}
+    for story_id, desc, source, cat in all_entries:
+        groups.setdefault(cat, []).append((story_id, desc, source))
+    draft = _build_draft(groups)
 
     if args.write:
         _write_to_changelog(draft, changelog)

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/i18n/loop.sh

@@ -7,8 +7,6 @@ _i18n_set en loop.roll_loop_s_active_02d_00 "  • roll-loop   %s  active %02d:0
 _i18n_set zh loop.roll_loop_s_active_02d_00 "  • roll-loop   %s  有效窗口 %02d:00–%02d:00  %s（active %02d:00–%02d:00）"
 _i18n_set en loop.roll_dream_daily_at_02d_02d "  • roll-.dream daily at %02d:%02d  每天 %02d:%02d"
 _i18n_set zh loop.roll_dream_daily_at_02d_02d "  • roll-.dream daily at %02d:%02d  每天 %02d:%02d"
-_i18n_set en loop.roll_brief_daily_at_02d_02d "  • roll-brief  daily at %02d:%02d  每天 %02d:%02d"
-_i18n_set zh loop.roll_brief_daily_at_02d_02d "  • roll-brief  daily at %02d:%02d  每天 %02d:%02d"
 _i18n_set en loop.loop_already_enabled_for_this_project_2 "Loop already enabled for this project"
 _i18n_set zh loop.loop_already_enabled_for_this_project_2 "当前项目 loop 已启用"
 _i18n_set en loop.loop_enabled_2 "Loop enabled"
@@ -17,8 +15,6 @@ _i18n_set en loop.roll_loop_s_active_02d_00_2 "  • roll-loop   %s  active %02d
 _i18n_set zh loop.roll_loop_s_active_02d_00_2 "  • roll-loop   %s  有效窗口 %02d:00–%02d:00  %s（active %02d:00–%02d:00）"
 _i18n_set en loop.roll_dream_daily_at_02d_02d_2 "  • roll-.dream daily at %02d:%02d  每天 %02d:%02d"
 _i18n_set zh loop.roll_dream_daily_at_02d_02d_2 "  • roll-.dream daily at %02d:%02d  每天 %02d:%02d"
-_i18n_set en loop.roll_brief_daily_at_02d_02d_2 "  • roll-brief  daily at %02d:%02d  每天 %02d:%02d"
-_i18n_set zh loop.roll_brief_daily_at_02d_02d_2 "  • roll-brief  daily at %02d:%02d  每天 %02d:%02d"
 _i18n_set en loop.loop_not_enabled_for_this_project "Loop not enabled for this project"
 _i18n_set zh loop.loop_not_enabled_for_this_project "当前项目 loop 未启用"
 _i18n_set en loop.loop_disabled "Loop disabled"