@seanyao/roll 2.602.4 → 2.603.1

package/lib/prices_fetcher.py

@@ -1,14 +1,19 @@
 """
-prices_fetcher — fetch + parse + diff + write Claude API pricing snapshots.
+prices_fetcher — fetch + parse + diff + write multi-vendor pricing snapshots.
 
 US-VIEW-013: replaces the hardcoded PRICES table in ``model_prices.py`` with
 versioned JSON snapshots under ``lib/prices/``. The fetcher pulls the live
 pricing docs page, extracts the model rate rows, and writes a new snapshot
 only when the rates differ from the most recent one on disk.
 
+US-VIEW-023: vendor-registry architecture — ``fetch``/``parse``/``refresh``
+dispatch by vendor. Adding a new vendor is a registry entry, not a change to
+the fetch/parse/refresh orchestration.
+
 Design:
   * ``fetch_pricing_html(url, timeout)`` — pure I/O, raises ``FetchError``
-  * ``parse_pricing_html(html)`` — pure parser, raises ``ParseError``
+  * ``parse_pricing_html(html, vendor)`` — dispatches to vendor parser,
+    raises ``ParseError``
   * ``diff_prices(old, new)`` — pure diff, returns list of changes
   * ``write_snapshot(prices, ...)`` — pure I/O, returns the path written
   * ``refresh(...)`` — orchestrator; the only function with side effects on
@@ -22,17 +27,14 @@ import json
 import os
 import re
 import sys
+from dataclasses import dataclass
 from html.parser import HTMLParser
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 from urllib.error import URLError
 from urllib.request import Request, urlopen
 
-DEFAULT_SOURCE_URL = "https://platform.claude.com/docs/en/about-claude/pricing"
 DEFAULT_TIMEOUT = 15
 
-_MODEL_RE = re.compile(r"claude-(?:opus|sonnet|haiku)-[0-9](?:-[0-9])?")
-_DOLLAR_RE = re.compile(r"\$\s*([0-9]+(?:\.[0-9]+)?)")
-
 
 class FetchError(RuntimeError):
     """Raised when fetching the pricing page fails."""
@@ -42,7 +44,235 @@ class ParseError(ValueError):
     """Raised when the pricing HTML cannot be parsed into a prices map."""
 
 
-def fetch_pricing_html(url: str = DEFAULT_SOURCE_URL,
+# ─── Vendor registry ──────────────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class VendorConfig:
+    """Configuration for a single pricing vendor."""
+
+    name: str
+    source_url: str
+    currency: str
+    parse: Callable[[str], Dict[str, Dict[str, float]]]
+
+
+def _parse_claude_html(html: str) -> Dict[str, Dict[str, float]]:
+    """Parse Anthropic/Claude pricing HTML into a {model: rates} map."""
+    model_re = re.compile(r"claude-(?:opus|sonnet|haiku)-[0-9](?:-[0-9])?")
+    dollar_re = re.compile(r"\$\s*([0-9]+(?:\.[0-9]+)?)")
+
+    extractor = _TableTextExtractor()
+    extractor.feed(html)
+
+    prices: Dict[str, Dict[str, float]] = {}
+    for row in extractor.rows:
+        text = " ".join(row)
+        model_match = model_re.search(text)
+        if not model_match:
+            continue
+        model = model_match.group(0)
+        amounts = [float(m.group(1)) for m in dollar_re.finditer(text)]
+        if len(amounts) < 4:
+            continue
+        in_rate, cache_create, cache_read, out_rate = amounts[:4]
+        prices[model] = {
+            "in": in_rate,
+            "out": out_rate,
+            "cache_create": cache_create,
+            "cache_read": cache_read,
+        }
+
+    if not prices:
+        raise ParseError("no price rows found in HTML; page layout may have changed")
+    return prices
+
+
+def _parse_deepseek_html(html: str) -> Dict[str, Dict[str, float]]:
+    """Parse DeepSeek pricing HTML into a {model: rates} map.
+
+    Handles both the Chinese (元) and English ($) pricing pages.
+    Extracts deepseek-v4-flash and deepseek-v4-pro rates, then adds
+    deepseek-chat and deepseek-reasoner as aliases for flash.
+    """
+    extractor = _TableTextExtractor()
+    extractor.feed(html)
+
+    # Find the header row with model names.
+    model_names: List[str] = []
+    header_idx = -1
+    for i, row in enumerate(extractor.rows):
+        if any(k in ' '.join(row) for k in ('模型', 'MODEL')):
+            # Cells after the label are model names.
+            # Strip footnote markers like (1) and HTML tags.
+            names = [
+                re.sub(r'<[^>]+>', '', re.sub(r'\s*\(\d+\)', '', cell)).strip()
+                for cell in row[1:]
+                if cell.strip()
+            ]
+            if len(names) >= 2:
+                model_names = names
+                header_idx = i
+                break
+
+    if len(model_names) < 2:
+        raise ParseError('no model header row found; page layout may have changed')
+
+    # Walk rows after header to find pricing data.
+    cache_hit: List[float] = []
+    cache_miss: List[float] = []
+    output: List[float] = []
+
+    for row in extractor.rows[header_idx + 1:]:
+        text = ' '.join(row)
+        # Skip non-pricing rows.
+        if not any(k in text for k in ('缓存命中', 'CACHE HIT', '缓存未命中', 'CACHE MISS', '输出', 'OUTPUT')):
+            continue
+
+        # Extract numeric values followed by 元 or $.
+        values: List[float] = []
+        for cell in row:
+            # Match numbers like 0.02元, $0.14, 1元, etc.
+            m = re.search(r'(?:\$)?\s*([0-9]+(?:\.[0-9]+)?)\s*(?:元|¥)?', cell)
+            if m:
+                values.append(float(m.group(1)))
+
+        if len(values) < len(model_names):
+            continue
+
+        if any(k in text for k in ('缓存命中', 'CACHE HIT')):
+            cache_hit = values[:len(model_names)]
+        elif any(k in text for k in ('缓存未命中', 'CACHE MISS')):
+            cache_miss = values[:len(model_names)]
+        elif any(k in text for k in ('输出', 'OUTPUT')):
+            output = values[:len(model_names)]
+
+    if not cache_miss or not output:
+        raise ParseError('no price rows found in HTML; page layout may have changed')
+
+    prices: Dict[str, Dict[str, float]] = {}
+    for idx, model in enumerate(model_names):
+        if model in ('deepseek-v4-flash', 'deepseek-v4-pro'):
+            prices[model] = {
+                'in': cache_miss[idx],
+                'out': output[idx],
+                'cache_create': cache_miss[idx],
+                'cache_read': cache_hit[idx] if cache_hit else 0.0,
+            }
+
+    if not prices:
+        raise ParseError('no price rows found in HTML; page layout may have changed')
+
+    # Aliases: deepseek-chat and deepseek-reasoner both map to v4-flash.
+    if 'deepseek-v4-flash' in prices:
+        flash = prices['deepseek-v4-flash']
+        prices['deepseek-chat'] = dict(flash)
+        prices['deepseek-reasoner'] = dict(flash)
+
+    return prices
+
+
+def _try_parse_kimi_pricing(html: str) -> Optional[Dict[str, Dict[str, float]]]:
+    """Try to parse Kimi pricing from HTML/MDX content.
+
+    Handles the JSX ``DocTable`` format used by Kimi's ``.md`` endpoints:
+    rows contain [model, unit, cache-hit, cache-miss, output, context].
+    """
+    prices: Dict[str, Dict[str, float]] = {}
+    price_re = re.compile(r"¥\s*([0-9]+(?:\.[0-9]+)?)")
+    row_re = re.compile(
+        r'\[\s*"([^"]+)"\s*,\s*"[^"]+"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"[^"]+"\s*\]'
+    )
+
+    for m in row_re.finditer(html):
+        model, cache_hit_str, cache_miss_str, output_str = m.groups()
+        cache_hit_m = price_re.search(cache_hit_str)
+        cache_miss_m = price_re.search(cache_miss_str)
+        output_m = price_re.search(output_str)
+        if not all((cache_hit_m, cache_miss_m, output_m)):
+            continue
+        prices[model] = {
+            "in": float(cache_miss_m.group(1)),
+            "out": float(output_m.group(1)),
+            "cache_create": float(cache_miss_m.group(1)),
+            "cache_read": float(cache_hit_m.group(1)),
+        }
+
+    return prices if prices else None
+
+
+def _parse_kimi_html(html: str) -> Dict[str, Dict[str, float]]:
+    """Parse Kimi pricing HTML into a {model: rates} map.
+
+    Kimi pricing is split across sub-pages (``pricing/chat-k25``,
+    ``pricing/chat-k26``).  The parser first tries to extract prices from the
+    provided HTML; if none found, it fetches the ``.md`` sub-pages and parses
+    those.
+    """
+    prices = _try_parse_kimi_pricing(html)
+    if prices:
+        if "kimi-k2.6" in prices:
+            prices["kimi-for-coding"] = dict(prices["kimi-k2.6"])
+        if "kimi-k2" not in prices:
+            prices["kimi-k2"] = {
+                "in": 1.00,
+                "out": 4.00,
+                "cache_create": 1.00,
+                "cache_read": 0.25,
+            }
+        return prices
+
+    sub_urls = [
+        "https://platform.kimi.com/docs/pricing/chat-k25.md",
+        "https://platform.kimi.com/docs/pricing/chat-k26.md",
+    ]
+    combined = html
+    for url in sub_urls:
+        try:
+            combined += "\n" + fetch_pricing_html(url)
+        except FetchError as exc:
+            raise ParseError(f"could not fetch kimi sub-page {url}: {exc}")
+
+    prices = _try_parse_kimi_pricing(combined)
+    if not prices:
+        raise ParseError("no price rows found in kimi pages")
+
+    if "kimi-k2.6" in prices:
+        prices["kimi-for-coding"] = dict(prices["kimi-k2.6"])
+    if "kimi-k2" not in prices:
+        prices["kimi-k2"] = {
+            "in": 1.00,
+            "out": 4.00,
+            "cache_create": 1.00,
+            "cache_read": 0.25,
+        }
+    return prices
+
+
+VENDOR_REGISTRY: Dict[str, VendorConfig] = {
+    "anthropic": VendorConfig(
+        name="anthropic",
+        source_url="https://platform.claude.com/docs/en/about-claude/pricing",
+        currency="USD",
+        parse=_parse_claude_html,
+    ),
+    "deepseek": VendorConfig(
+        name="deepseek",
+        source_url="https://api-docs.deepseek.com/zh-cn/quick_start/pricing/",
+        currency="CNY",
+        parse=_parse_deepseek_html,
+    ),
+    "kimi": VendorConfig(
+        name="kimi",
+        source_url="https://platform.kimi.com/docs/pricing/chat",
+        currency="CNY",
+        parse=_parse_kimi_html,
+    ),
+}
+
+
+# ─── Network I/O ──────────────────────────────────────────────────────────────
+
+def fetch_pricing_html(url: str,
                        timeout: float = DEFAULT_TIMEOUT) -> str:
     """Fetch the pricing docs page and return its raw HTML."""
     req = Request(url, headers={"User-Agent": "roll/prices_fetcher"})
@@ -55,6 +285,8 @@ def fetch_pricing_html(url: str = DEFAULT_SOURCE_URL,
         raise FetchError(f"could not fetch {url}: {exc}") from exc
 
 
+# ─── HTML parsing helpers ─────────────────────────────────────────────────────
+
 class _TableTextExtractor(HTMLParser):
     """Walk an HTML document and yield <tr> cell-text lists per row."""
 
@@ -88,39 +320,22 @@ class _TableTextExtractor(HTMLParser):
             self._cur.append(data)
 
 
-def parse_pricing_html(html: str) -> Dict[str, Dict[str, float]]:
+# ─── Parser dispatch ──────────────────────────────────────────────────────────
+
+def parse_pricing_html(html: str, vendor: str = "anthropic") -> Dict[str, Dict[str, float]]:
     """Parse pricing docs HTML into a {model: rates} map.
 
-    The parser is intentionally tolerant: it scans every table row, looks for
-    one ``claude-*`` model identifier and four dollar amounts on that row, and
-    treats them as ``in / cache_create / cache_read / out`` in the order they
-    appear. (Anthropic's table renders columns in that order.)
+    Dispatches to the vendor-specific parser registered in ``VENDOR_REGISTRY``.
     """
-    parser = _TableTextExtractor()
-    parser.feed(html)
+    config = VENDOR_REGISTRY.get(vendor)
+    if not config:
+        raise ParseError(
+            f"unknown vendor {vendor!r}; known: {', '.join(sorted(VENDOR_REGISTRY))}"
+        )
+    return config.parse(html)
 
-    prices: Dict[str, Dict[str, float]] = {}
-    for row in parser.rows:
-        text = " ".join(row)
-        model_match = _MODEL_RE.search(text)
-        if not model_match:
-            continue
-        model = model_match.group(0)
-        amounts = [float(m.group(1)) for m in _DOLLAR_RE.finditer(text)]
-        if len(amounts) < 4:
-            continue
-        in_rate, cache_create, cache_read, out_rate = amounts[:4]
-        prices[model] = {
-            "in": in_rate,
-            "out": out_rate,
-            "cache_create": cache_create,
-            "cache_read": cache_read,
-        }
-
-    if not prices:
-        raise ParseError("no price rows found in HTML; page layout may have changed")
-    return prices
 
+# ─── Diff & formatting ────────────────────────────────────────────────────────
 
 def diff_prices(old: Dict[str, Dict[str, float]],
                 new: Dict[str, Dict[str, float]]
@@ -168,10 +383,41 @@ def format_diff(changes: List[Tuple[str, str, str, Optional[float], Optional[flo
     return "\n".join(lines)
 
 
+# ─── Snapshot I/O ─────────────────────────────────────────────────────────────
+
+_SNAPSHOT_NAME_RE = re.compile(r"snapshot-(\d{4}-\d{2}-\d{2})(?:-([a-z]+))?\.json")
+
+
+def _extract_vendor_from_filename(name: str) -> Optional[str]:
+    """Extract vendor from snapshot filename.
+
+    snapshot-2026-05-22.json          → anthropic
+    snapshot-2026-05-22-deepseek.json → deepseek
+    snapshot-2026-06-02-kimi.json     → kimi
+    """
+    m = _SNAPSHOT_NAME_RE.match(name)
+    if not m:
+        return None
+    return m.group(2) or "anthropic"
+
+
+def _latest_snapshot_path(snapshot_dir: str, vendor: str = "anthropic") -> Optional[str]:
+    if not os.path.isdir(snapshot_dir):
+        return None
+    snaps = sorted(
+        os.path.join(snapshot_dir, n)
+        for n in os.listdir(snapshot_dir)
+        if _SNAPSHOT_NAME_RE.match(n) and _extract_vendor_from_filename(n) == vendor
+    )
+    return snaps[-1] if snaps else None
+
+
 def write_snapshot(prices: Dict[str, Dict[str, float]],
                    *,
                    snapshot_dir: str,
-                   source_url: str = DEFAULT_SOURCE_URL,
+                   source_url: str,
+                   vendor: str = "anthropic",
+                   currency: str = "USD",
                    effective_at: Optional[str] = None,
                    default_model: Optional[str] = None,
                    notes: Optional[str] = None) -> str:
@@ -182,12 +428,15 @@ def write_snapshot(prices: Dict[str, Dict[str, float]],
         "version": today,
         "effective_at": today,
         "source_url": source_url,
+        "vendor": vendor,
+        "currency": currency,
         "default_model": default_model or _pick_default(prices),
         "prices": prices,
     }
     if notes:
         payload["notes"] = notes
-    dest = os.path.join(snapshot_dir, f"snapshot-{today}.json")
+    suffix = f"-{vendor}" if vendor != "anthropic" else ""
+    dest = os.path.join(snapshot_dir, f"snapshot-{today}{suffix}.json")
     with open(dest, "w", encoding="utf-8") as f:
         json.dump(payload, f, indent=2, sort_keys=False)
         f.write("\n")
@@ -202,9 +451,12 @@ def _pick_default(prices: Dict[str, Dict[str, float]]) -> str:
     return next(iter(prices))
 
 
+# ─── Orchestrator ─────────────────────────────────────────────────────────────
+
 def refresh(*,
             snapshot_dir: str,
-            url: str = DEFAULT_SOURCE_URL,
+            vendor: str = "anthropic",
+            url: Optional[str] = None,
             timeout: float = DEFAULT_TIMEOUT,
             html: Optional[str] = None,
             ) -> Tuple[str, List[Tuple[str, str, str, Optional[float], Optional[float]]]]:
@@ -215,14 +467,26 @@ def refresh(*,
       ``"written:<path>"`` — new snapshot written at <path>
       ``"first:<path>"`` — no prior snapshot existed; baseline written
     """
+    config = VENDOR_REGISTRY.get(vendor)
+    if not config:
+        raise ParseError(
+            f"unknown vendor {vendor!r}; known: {', '.join(sorted(VENDOR_REGISTRY))}"
+        )
+
+    source_url = url or config.source_url
     if html is None:
-        html = fetch_pricing_html(url, timeout=timeout)
-    new_prices = parse_pricing_html(html)
+        html = fetch_pricing_html(source_url, timeout=timeout)
+    new_prices = parse_pricing_html(html, vendor=vendor)
 
-    # Load latest if any
-    latest = _latest_snapshot_path(snapshot_dir)
+    latest = _latest_snapshot_path(snapshot_dir, vendor=vendor)
     if latest is None:
-        dest = write_snapshot(new_prices, snapshot_dir=snapshot_dir, source_url=url)
+        dest = write_snapshot(
+            new_prices,
+            snapshot_dir=snapshot_dir,
+            source_url=source_url,
+            vendor=vendor,
+            currency=config.currency,
+        )
         return f"first:{dest}", diff_prices({}, new_prices)
 
     with open(latest, "r", encoding="utf-8") as f:
@@ -230,34 +494,38 @@ def refresh(*,
     changes = diff_prices(old, new_prices)
     if not changes:
         return "unchanged", []
-    dest = write_snapshot(new_prices, snapshot_dir=snapshot_dir, source_url=url)
-    return f"written:{dest}", changes
-
-
-def _latest_snapshot_path(snapshot_dir: str) -> Optional[str]:
-    if not os.path.isdir(snapshot_dir):
-        return None
-    snaps = sorted(
-        os.path.join(snapshot_dir, n)
-        for n in os.listdir(snapshot_dir)
-        if n.startswith("snapshot-") and n.endswith(".json")
+    dest = write_snapshot(
+        new_prices,
+        snapshot_dir=snapshot_dir,
+        source_url=source_url,
+        vendor=vendor,
+        currency=config.currency,
     )
-    return snaps[-1] if snaps else None
+    return f"written:{dest}", changes
 
 
-# CLI entry — `python3 lib/prices_fetcher.py refresh|show` is the fallback when
+# ─── CLI entry — `python3 lib/prices_fetcher.py refresh|show` is the fallback when
 # bin/roll is unavailable (e.g. running tests directly).
 def _main(argv: List[str]) -> int:
     snapshot_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "prices")
     if not argv or argv[0] in ("-h", "--help", "help"):
-        print("usage: prices_fetcher.py refresh|show [--url URL]")
+        print("usage: prices_fetcher.py refresh|show [--url URL] [--vendor VENDOR]")
         return 0
     cmd = argv[0]
-    url = DEFAULT_SOURCE_URL
-    if "--url" in argv:
-        url = argv[argv.index("--url") + 1]
+    url: Optional[str] = None
+    vendor = "anthropic"
+    i = 1
+    while i < len(argv):
+        if argv[i] == "--url" and i + 1 < len(argv):
+            url = argv[i + 1]
+            i += 2
+        elif argv[i] == "--vendor" and i + 1 < len(argv):
+            vendor = argv[i + 1]
+            i += 2
+        else:
+            i += 1
     if cmd == "show":
-        latest = _latest_snapshot_path(snapshot_dir)
+        latest = _latest_snapshot_path(snapshot_dir, vendor=vendor)
         if not latest:
             print("no snapshot found", file=sys.stderr)
             return 1
@@ -266,7 +534,7 @@ def _main(argv: List[str]) -> int:
         return 0
     if cmd == "refresh":
         try:
-            action, changes = refresh(snapshot_dir=snapshot_dir, url=url)
+            action, changes = refresh(snapshot_dir=snapshot_dir, vendor=vendor, url=url)
         except FetchError as exc:
             print(f"fetch failed: {exc}", file=sys.stderr)
             return 2

package/package.json

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

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

@@ -48,7 +48,7 @@ Create mode:
 CHANGELOG 是给**使用者**看的，不是给维护者看的。一句话讲清"用户能做什么 / 不再被什么坑"，能不写就不写。
 
 **BACKLOG 描述写好了，CHANGELOG 就是复制 + 过滤，不是重写。**
-如果 BACKLOG 描述已经是人话、一句话、说用户价值，直接用它（去掉 `depends-on:` / `manual-only:` 等功能性标签）。
+如果 BACKLOG 描述已经是人话、一句话、说用户价值，直接用它（去掉 `depends-on:` 等功能性标签）。
 只有 BACKLOG 描述包含实现细节或技术黑话时，才需要改写。
 
 **FIX 条目的 filter 规则**：BACKLOG 的 FIX 描述通常是 `<用户症状> — <修复手段>` 结构。

package/skills/roll-loop/SKILL.md

@@ -103,24 +103,12 @@ this point, any `🔨 In Progress` row in `.roll/backlog.md` belongs to a
 previous cycle that crashed before flipping it back; reclaim it before
 scanning.
 
-**Important — skip `manual-only:*` rows.** A row tagged `manual-only:*`
-means a human (or another non-loop process) has explicitly claimed it;
-it is not loop's to reclaim. Reverting it would silently undo the
-human's claim and cause confusing churn for `roll-brief` / dashboard
-readers. The rule mirrors the gate in Step 2.
-
 1. Scan .roll/backlog.md for all rows whose Status column contains `🔨 In Progress`.
-2. For each candidate row, run the manual-only gate before touching it:
-   ```bash
-   bash -c 'source "$(command -v roll)"; _loop_is_manual_only "<story-id>" .roll/backlog.md'
-   #   exit 0 → row has `manual-only:*` → SKIP (human-claimed; not orphan)
-   #   exit 1 → reclaimable orphan; continue to step 3
-   ```
-3. For each row that passes the gate: revert the status back to
+2. For each such row: revert the status back to
    `📋 Todo`, commit `chore: revert orphan 🔨 US-XXX to 📋`, and append
    a line to `~/.shared/roll/loop/ALERT-<slug>.md` recording the orphan
    id and time so the next brief surfaces it.
-4. After orphan sweep, proceed to Step 1.5 (Pre-run CI health check) before scanning.
+3. After orphan sweep, proceed to Step 1.5 (Pre-run CI health check) before scanning.
 
 ### Step 1.5 — Pre-run CI Health Check
 
@@ -157,7 +145,7 @@ Call `_loop_pr_inbox` after the pre-run CI check passes. It walks
 
 | Classification | Action |
 |---|---|
-| `loop_self` (head ref starts with `loop/`, CI not red) | Skip — let GitHub auto-merge handle it; never AI-review your own commit |
+| `loop_self` (head ref starts with `loop/` **or** `claude/`, CI not red) | `_loop_pr_merge_self_eager` — squash-merge directly when CI green + clean; if the PR is BEHIND/CONFLICTING with main, `_loop_pr_rebase_stale` rebases it first (circuit-gated) so it merges on a later tick. Never AI-review your own commit. (Agent-authored `claude/*` PRs are loop-owned the same way; a CI-red `claude/*` PR is **not** auto-healed — it falls through for a human to decide.) |
 | `loop_self_ci_red` (loop/* PR whose CI went red) | **US-LOOP-062a**: `_loop_pr_heal_self` — background-heal (per-PR lock + heal budget `ROLL_LOOP_HEAL_MAX`, default 2, via `_project_agent`); on `ROLL_LOOP_NO_HEAL=1` / budget exhausted → deduped `[TYPE:loop-pr-ci-red]` ALERT (never silently dropped) |
 | `blocked_human_request_changes` | Skip — last human review requested changes; wait for the author to push fixes |
 | `blocked_human_approved` | **US-LOOP-062b**: `_loop_pr_merge_approved` — merge directly (`gh pr merge --squash`) when CI green + mergeable, instead of relying on repo auto-merge (which may be off); merge failure is non-fatal (retried next tick) |
@@ -202,20 +190,16 @@ bash -c 'source "$(command -v roll)"; _loop_pr_claimed_stories'
 **Dependency gate** (FIX-032). For each `📋 Todo` candidate, before picking:
 
 ```bash
-# Source bin/roll once per cycle, then call the helpers per candidate.
+# Source bin/roll once per cycle, then call the helper per candidate.
 source "$(command -v roll)"
 
-bash -c 'source "$(command -v roll)"; _loop_is_manual_only "<story-id>" .roll/backlog.md'
-#   exit 0 → row has `manual-only:true` → SKIP this story, log to runs.jsonl
-#            `skipped`, append INFO line ("manual-only — requires $roll-build")
-
 bash -c 'source "$(command -v roll)"; _loop_check_depends_on "<story-id>" .roll/backlog.md'
 #   exit 0 → all `depends-on:US-X,US-Y` are ✅ Done → eligible
 #   exit 1 → stdout lists unsatisfied dep IDs; SKIP this story, log to
 #            runs.jsonl `skipped` with reason "depends-on: <unsatisfied>"
 ```
 
-Move to the next candidate when skipping. The two gates are pure functions
+Move to the next candidate when skipping. The gate is a pure function
 over .roll/backlog.md text — no side effects, no LOCK interaction.
 
 Cap at `max_items_per_run` to limit blast radius per cycle.
@@ -244,14 +228,14 @@ Together these mean: only one loop runs at a time per project (LOCK), and within
 > **US-AGENT-006 — Per-story agent routing (pre-cycle)**
 >
 > Before this skill even starts, the runner inner script has already:
-> 1. Picked the next eligible Todo via `_loop_pick_next_story` (priority FIX > US > REFACTOR, manual-only / depends-on gates respected)
+> 1. Picked the next eligible Todo via `_loop_pick_next_story` (priority FIX > US > REFACTOR, depends-on gate respected)
 > 2. Read its Agent profile (est_min / risk_zone) and routed an agent via `_loop_pick_agent_for_story` (hard rules from `.roll/agent-routes.yaml` + soft preference from `runs.jsonl`)
 > 3. Exported `ROLL_LOOP_ROUTED_STORY` / `ROLL_LOOP_ROUTED_AGENT` / `ROLL_LOOP_ROUTED_RULE` and printed `[loop] story <id> routed to <agent> via <rule_kind>` to cron.log
 >
 > When `ROLL_LOOP_ROUTED_STORY` is set, prefer it as `US_ID` for this cycle. The story has already been chosen by hard+soft routing rules — and, per FIX-146, the runner re-validates it against the authoritative backlog right before handing it to you (re-picking the next eligible Todo if it went ✅ Done / In Progress / ineligible between pick and handoff, emitting a `story_stale` event). So treat `ROLL_LOOP_ROUTED_STORY` as already-eligible and just work it. Only if you still find at cycle start that it is no longer 📋 Todo in BACKLOG (a residual concurrent flip), re-pick the next eligible Todo via `_loop_pick_next_story` rather than idling the whole cycle.
 >
 > Old single-agent fallback (`primary_agent` from `~/.roll/config.yaml`) still applies when:
-> - no story is pickable (empty Todo / all manual-only)
+> - no story is pickable (empty Todo / all blocked by depends-on)
 > - the matching agent-routes.yaml has no agent that fits the story profile (then `cold_start_default` is used)
 
 For each item, **before invoking the executor skill**, mark the story 🔨 In Progress in the **main repo's** .roll/backlog.md so brief and peer agents can see it being worked on. The cycle worktree is gitignored at .roll/, so editing the worktree's own copy + committing carries no change back to main — write directly via the helper instead: