modao-prd-cli 0.1.0__py3-none-any.whl

modao_prd_cli/modao_prd/capture_evidence.py

@@ -0,0 +1,547 @@
+"""Evidence capture helpers for rendered Modao pages.
+
+The browser layer keeps the original DOM records for the existing extractor and
+adds a loss-aware evidence snapshot beside them.  The snapshot is deliberately
+mechanical: it records what the browser rendered and does not infer product
+meaning.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import mimetypes
+import re
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any, Callable
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+from .evidence import EvidenceBundleWriter
+
+
+SENSITIVE_QUERY_KEYS = {
+    "access_token",
+    "authorization",
+    "code",
+    "key",
+    "secret",
+    "session",
+    "sig",
+    "signature",
+    "token",
+    "accesstoken",
+    "refreshtoken",
+    "clientsecret",
+    "jwt",
+    "auth",
+    "ticket",
+    "nonce",
+    "sessionid",
+}
+DEBUG_TEXT_CONTENT_TYPES = {
+    "application/json",
+    "application/manifest+json",
+    "application/xml",
+    "text/html",
+    "text/plain",
+}
+NOISE_ASSET_RE = re.compile(r"(?:favicon|loading|logo|spinner|tracker|tracking|pixel|analytics|beacon|collect)", re.I)
+
+
+def redact_url(value: str, *, base_url: str | None = None) -> str:
+    """Remove credential-like query values and optionally reduce cross-origin URLs."""
+
+    try:
+        parsed = urlsplit(value)
+    except ValueError:
+        return "[invalid-url]"
+    pairs = [
+        (key, val)
+        for key, val in parse_qsl(parsed.query, keep_blank_values=True)
+        if key.casefold() not in SENSITIVE_QUERY_KEYS
+    ]
+    query = urlencode(pairs)
+    sanitized = urlunsplit((parsed.scheme, parsed.netloc, parsed.path, query, ""))
+    if base_url and not same_origin(sanitized, base_url):
+        return urlunsplit((parsed.scheme, parsed.netloc, parsed.path, "", ""))
+    return sanitized
+
+
+def redact_text(value: str) -> str:
+    """Remove credential material from debug text without rewriting product copy."""
+
+    value = re.sub(r"(?i)(authorization\s*[:=]\s*bearer\s+)[^\s,;\"']+", r"\1[REDACTED]", value)
+    value = re.sub(r"(?i)((?:cookie|set-cookie)\s*[:=]\s*)[^\n]+", r"\1[REDACTED]", value)
+    value = re.sub(
+        r"(?i)([?&](?:access[_-]?token|refresh[_-]?token|client[_-]?secret|authorization|signature|token|jwt|ticket)=)[^&#\s\"']+",
+        r"\1[REDACTED]",
+        value,
+    )
+    return value
+
+
+def same_origin(left: str, right: str) -> bool:
+    try:
+        a = urlsplit(left)
+        b = urlsplit(right)
+    except ValueError:
+        return False
+    return (a.scheme.lower(), a.hostname, a.port or _default_port(a.scheme)) == (
+        b.scheme.lower(),
+        b.hostname,
+        b.port or _default_port(b.scheme),
+    )
+
+
+def merge_evidence(existing: list[dict[str, Any]], incoming: list[dict[str, Any]]) -> None:
+    """Append evidence records while keeping IDs unique.
+
+    Network response callbacks can add assets while a state screenshot is
+    being captured. The old offset-based IDs were therefore able to collide
+    with a newly observed asset, causing a real file to be present in the
+    bundle without a reference in ``document.json``.
+    """
+
+    used = {str(item.get("id")) for item in existing if item.get("id")}
+    next_number = 1
+    for value in used:
+        match = re.fullmatch(r"evidence-(\d+)", value)
+        if match:
+            next_number = max(next_number, int(match.group(1)) + 1)
+    for item in incoming:
+        record = dict(item)
+        evidence_id = str(record.get("id") or "")
+        if not evidence_id or evidence_id in used:
+            while f"evidence-{next_number:03d}" in used:
+                next_number += 1
+            evidence_id = f"evidence-{next_number:03d}"
+            next_number += 1
+            record["id"] = evidence_id
+        used.add(evidence_id)
+        existing.append(record)
+
+
+def _default_port(scheme: str) -> int | None:
+    return {"http": 80, "https": 443}.get(scheme.lower())
+
+
+def capture_state_evidence(
+    page: Any,
+    context: Any,
+    *,
+    writer: EvidenceBundleWriter | None,
+    state_id: str,
+    requested_url: str,
+    evidence_mode: str,
+    max_item: int,
+    max_total: int,
+    warnings: list[str],
+    network_records: list[dict[str, Any]],
+    evidence_id_offset: int = 0,
+) -> tuple[list[dict[str, Any]], dict[str, Any], dict[str, Any]]:
+    """Capture rendered page artifacts and return refs, DOM facts and stats."""
+
+    evidence: list[dict[str, Any]] = []
+    snapshot: dict[str, Any] = {}
+
+    def add_artifact(relative_path: str, content: Any, media_type: str, kind: str) -> None:
+        if writer is None:
+            return
+        try:
+            item = writer.add(relative_path, content, media_type=media_type)
+        except Exception as exc:
+            warnings.append(f"证据文件未保存（{kind}）：{_short_error(exc)}")
+            return
+        evidence.append({"id": f"evidence-{evidence_id_offset + len(evidence) + 1:03d}", "kind": kind, "state_id": state_id, **asdict(item)})
+
+    if evidence_mode == "full":
+        try:
+            rendered_html = redact_text(page.content())
+            add_artifact(f"evidence/{state_id}.rendered.html", rendered_html, "text/html", "html")
+        except Exception as exc:
+            warnings.append(f"无法保存渲染后 HTML：{_short_error(exc)}")
+
+    try:
+        snapshot = page.evaluate(DOM_LAYOUT_SCRIPT)
+        snapshot = sanitize_snapshot(snapshot, base_url=requested_url)
+        warnings.extend(str(item) for item in snapshot.get("warnings", []) if item)
+        add_artifact(
+            f"evidence/{state_id}.dom.json",
+            json.dumps(snapshot, ensure_ascii=False, indent=2) + "\n",
+            "application/json",
+            "dom",
+        )
+    except Exception as exc:
+        warnings.append(f"无法保存 DOM 布局快照：{_short_error(exc)}")
+
+    if evidence_mode == "full":
+        try:
+            try:
+                aria = page.aria_snapshot(mode="ai", boxes=True)
+            except TypeError:
+                aria = page.aria_snapshot()
+            add_artifact(f"evidence/{state_id}.aria.yaml", redact_text(aria), "text/yaml", "aria")
+        except Exception as exc:
+            warnings.append(f"无法保存 ARIA 快照：{_short_error(exc)}")
+    if evidence_mode == "full":
+        try:
+            screenshot = page.screenshot(full_page=True, animations="disabled")
+            add_artifact(f"evidence/{state_id}.full.png", screenshot, "image/png", "screenshot")
+        except Exception as exc:
+            warnings.append(f"无法保存页面截图：{_short_error(exc)}")
+    if evidence_mode in {"essential", "full"}:
+        try:
+            _capture_canvas_images(page, add_artifact, state_id=state_id, warnings=warnings)
+        except Exception as exc:
+            warnings.append(f"无法枚举画布截图：{_short_error(exc)}")
+
+    stats = {
+        "dom_node_count": len(snapshot.get("nodes", [])),
+        "visual_only_count": len(snapshot.get("visual_only", [])),
+        "frame_count": snapshot.get("frame_count", 0),
+        "evidence_count": len(evidence),
+        "network_count": len(network_records),
+        "max_item": max_item,
+        "max_total": max_total,
+    }
+    return evidence, snapshot, stats
+
+
+def make_response_handler(
+    *,
+    writer: EvidenceBundleWriter | None,
+    requested_url: str,
+    state_id: str,
+    evidence: list[dict[str, Any]],
+    network_records: list[dict[str, Any]],
+    warnings: list[str],
+    max_item: int,
+    max_total: int,
+    evidence_mode: str = "full",
+) -> Callable[[Any], None]:
+    """Create a safe Playwright response callback for one capture run."""
+
+    def handle(response: Any) -> None:
+        try:
+            url = str(response.url)
+            if evidence_mode == "none":
+                return
+            response_same_origin = same_origin(url, requested_url)
+            if evidence_mode == "essential" and not response_same_origin:
+                return
+            headers = getattr(response, "headers", {}) or {}
+            content_type = str(headers.get("content-type", "")).split(";", 1)[0].strip().lower()
+            record: dict[str, Any] = {
+                "state_id": state_id,
+                "url": redact_url(url, base_url=requested_url),
+                "same_origin": response_same_origin,
+                "status": int(response.status),
+                "ok": bool(response.ok),
+                "content_type": content_type,
+                "headers": {
+                    key: str(headers[key])
+                    for key in ("content-type", "content-length", "etag", "last-modified", "cache-control")
+                    if key in headers
+                },
+            }
+            is_image = content_type.startswith("image/")
+            is_debug_document = same_origin(url, requested_url) and content_type in DEBUG_TEXT_CONTENT_TYPES
+            should_capture_body = bool(writer and evidence_mode != "none")
+            should_capture_body = should_capture_body and (
+                (is_image and same_origin(url, requested_url))
+                or (evidence_mode == "full" and is_debug_document)
+            )
+            if should_capture_body:
+                try:
+                    body = response.body()
+                    if content_type in DEBUG_TEXT_CONTENT_TYPES:
+                        body = redact_text(body.decode("utf-8", "replace")).encode("utf-8")
+                    if is_image and not _is_useful_image(body, url, content_type):
+                        record["skipped_reason"] = "irrelevant_or_tiny_asset"
+                    elif not body:
+                        record["skipped_reason"] = "empty_body"
+                    elif len(body) <= max_item:
+                        digest = hashlib.sha256(body).hexdigest()
+                        suffix = _suffix(content_type, url)
+                        directory = "evidence/assets" if is_image else "evidence/network/bodies"
+                        relative = f"{directory}/{digest}{suffix}"
+                        if writer:
+                            existing = next((item for item in evidence if item.get("path") == relative), None)
+                            if existing:
+                                record["evidence_id"] = existing["id"]
+                            else:
+                                item = writer.add(relative, body, media_type=content_type or "application/octet-stream")
+                                evidence.append(
+                                    {
+                                        "id": f"evidence-{len(evidence) + 1:03d}",
+                                        "kind": "asset" if is_image else "network_body",
+                                        "state_id": state_id,
+                                        **asdict(item),
+                                    }
+                                )
+                                record["evidence_id"] = evidence[-1]["id"]
+                    else:
+                        record["skipped_reason"] = "item_size_limit"
+                except Exception as exc:
+                    record["skipped_reason"] = "body_unavailable"
+                    warnings.append(f"网络响应正文未保存：{_short_error(exc)}")
+            network_records.append(record)
+        except Exception as exc:
+            warnings.append(f"网络响应记录失败：{_short_error(exc)}")
+
+    return handle
+
+
+def _suffix(content_type: str, url: str) -> str:
+    suffix = mimetypes.guess_extension(content_type) or Path(urlsplit(url).path).suffix
+    if suffix == ".jpe":
+        return ".jpg"
+    return suffix or ".bin"
+
+
+def _is_useful_image(body: bytes, url: str, content_type: str) -> bool:
+    """Keep page artwork, but discard trackers and browser chrome assets."""
+
+    if NOISE_ASSET_RE.search(url):
+        return False
+    # Modao commonly serves small UI glyphs as standalone SVG files. They are
+    # already represented by the DOM and screenshots, so keeping them as
+    # binary evidence adds noise without improving an Agent's understanding of
+    # the prototype. Full/debug mode still retains the rendered HTML and DOM
+    # references needed to audit such elements.
+    if content_type == "image/svg+xml":
+        header = body[:4096].decode("utf-8", "ignore").lower()
+        if re.search(r"<svg[^>]*(?:class=[\"'][^\"']*\bicon\b|symbol|viewbox=[\"']0 0 1024 1024)", header):
+            return False
+    width = height = None
+    if content_type == "image/png" and len(body) >= 24 and body.startswith(b"\x89PNG"):
+        width = int.from_bytes(body[16:20], "big")
+        height = int.from_bytes(body[20:24], "big")
+    elif content_type == "image/gif" and len(body) >= 10 and body.startswith((b"GIF87a", b"GIF89a")):
+        width = int.from_bytes(body[6:8], "little")
+        height = int.from_bytes(body[8:10], "little")
+    if width is not None and height is not None and width <= 1 and height <= 1:
+        return False
+    return True
+
+
+def _capture_canvas_images(page: Any, add_artifact: Callable[..., None], *, state_id: str, warnings: list[str]) -> None:
+    """Capture a readable copy of the actual prototype artboard.
+
+    Modao's inspect view may scale ``#canvas`` to 10% and its ``.mb-screen``
+    wrapper can therefore report a zero-sized box. Cloning the artboard into a
+    temporary overlay preserves the rendered CSS while allowing a readable,
+    bounded screenshot without clicking the UI zoom controls.
+    """
+
+    target_selector = ".rResCanvas"
+    targets = page.locator(target_selector)
+    count = targets.count()
+    if not count:
+        target_selector = ".mb-screen"
+        targets = page.locator(target_selector)
+        count = targets.count()
+    for index in range(count):
+        try:
+            target = targets.nth(index)
+            box = target.bounding_box()
+            natural = target.evaluate("element => ({width: element.offsetWidth, height: element.offsetHeight})")
+            width = float(natural.get("width") or (box or {}).get("width", 0))
+            height = float(natural.get("height") or (box or {}).get("height", 0))
+            if width <= 1 or height <= 1:
+                warnings.append(f"画布节点不可见，未生成裁剪图（screen-{index + 1:03d}）。")
+                continue
+            # Keep one native-resolution image for the complete artboard. The
+            # image can be very large, but it preserves the original layout and
+            # lets an Agent zoom into any region without stitching tiles back
+            # together. Text facts remain available in document.json/dom.json.
+            overview = _canvas_overlay_screenshot(
+                page,
+                target_selector=target_selector,
+                index=index,
+                scale=1.0,
+                offset_x=0,
+                offset_y=0,
+                tile_width=width,
+                tile_height=height,
+            )
+            if overview is not None:
+                add_artifact(
+                f"evidence/{state_id}.screen-{index + 1:03d}.png",
+                    overview,
+                    "image/png",
+                    "screen_screenshot",
+                )
+        except Exception as exc:
+            warnings.append(f"画布截图未保存（screen-{index + 1:03d}）：{_short_error(exc)}")
+            try:
+                page.evaluate("() => document.getElementById('modao-prd-capture-overlay')?.remove()")
+            except Exception:
+                pass
+
+
+def _canvas_overlay_screenshot(
+    page: Any,
+    *,
+    target_selector: str,
+    index: int,
+    scale: float,
+    offset_x: int,
+    offset_y: int,
+    tile_width: float,
+    tile_height: float,
+) -> bytes | None:
+    """Clone one artboard into a scaled viewport and screenshot it."""
+
+    tile_width = max(1, int(round(tile_width)))
+    tile_height = max(1, int(round(tile_height)))
+    result = page.evaluate(
+        """({selector, index, scale, offsetX, offsetY, tileWidth, tileHeight}) => {
+          const nodes = Array.from(document.querySelectorAll(selector));
+          const source = nodes[index];
+          if (!source) return null;
+          const id = 'modao-prd-capture-overlay';
+          document.getElementById(id)?.remove();
+          const wrapper = document.createElement('div');
+          wrapper.id = id;
+          wrapper.style.cssText = `position:fixed;left:0;top:0;z-index:2147483647;overflow:hidden;background:#fff;width:${tileWidth * scale}px;height:${tileHeight * scale}px;`;
+          const clone = source.cloneNode(true);
+          clone.style.cssText += `;position:absolute;left:0;top:0;transform:translate(-${offsetX * scale}px, -${offsetY * scale}px) scale(${scale})!important;transform-origin:top left!important;width:${source.offsetWidth}px;height:${source.offsetHeight}px;`;
+          wrapper.appendChild(clone);
+          document.body.appendChild(wrapper);
+          return {id, width: wrapper.offsetWidth, height: wrapper.offsetHeight};
+        }""",
+        {
+            "selector": target_selector,
+            "index": index,
+            "scale": scale,
+            "offsetX": offset_x,
+            "offsetY": offset_y,
+            "tileWidth": tile_width,
+            "tileHeight": tile_height,
+        },
+    )
+    if not result:
+        return None
+    try:
+        return page.locator("#modao-prd-capture-overlay").screenshot(animations="disabled")
+    finally:
+        page.evaluate("() => document.getElementById('modao-prd-capture-overlay')?.remove()")
+
+
+def sanitize_snapshot(value: Any, *, base_url: str) -> Any:
+    if isinstance(value, dict):
+        result = {}
+        for key, item in value.items():
+            if key in {"href", "src", "url"} and isinstance(item, str):
+                result[key] = redact_url(item, base_url=base_url)
+            elif key == "attributes" and isinstance(item, dict):
+                result[key] = {
+                    attr: redact_url(attr_value, base_url=base_url)
+                    if attr.casefold() in {"href", "src"} and isinstance(attr_value, str)
+                    else sanitize_snapshot(attr_value, base_url=base_url)
+                    for attr, attr_value in item.items()
+                }
+            else:
+                result[key] = sanitize_snapshot(item, base_url=base_url)
+        return result
+    if isinstance(value, list):
+        return [sanitize_snapshot(item, base_url=base_url) for item in value]
+    return value
+
+
+def _short_error(exc: Exception, limit: int = 300) -> str:
+    text = " ".join(str(exc).split())
+    return text[:limit] + ("…" if len(text) > limit else "")
+
+
+DOM_LAYOUT_SCRIPT = r"""
+() => {
+  const root = document.documentElement || document.body;
+  const nodes = [];
+  const visualOnly = [];
+  const warnings = [];
+  const screenNodes = Array.from(document.querySelectorAll('.mb-screen'));
+  const screens = screenNodes.length ? screenNodes : [document.body];
+  const normalize = value => (value || '').replace(/\u00a0/g, ' ').replace(/[ \t]+/g, ' ').replace(/\s*\n\s*/g, '\n').trim();
+  const visible = (element, style, rect) => style.display !== 'none' && style.visibility !== 'hidden' && Number(style.opacity || 1) > 0 && rect.width > 0 && rect.height > 0;
+  const bounds = element => {
+    const rect = element.getBoundingClientRect();
+    const owner = element.closest?.('.mb-screen') || screens[0];
+    const screenRect = owner?.getBoundingClientRect?.() || {x: 0, y: 0};
+    return {
+      viewport: {x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height)},
+      document: {x: Math.round(rect.x + window.scrollX), y: Math.round(rect.y + window.scrollY), width: Math.round(rect.width), height: Math.round(rect.height)},
+      screen: {x: Math.round(rect.x - screenRect.x), y: Math.round(rect.y - screenRect.y), width: Math.round(rect.width), height: Math.round(rect.height)}
+    };
+  };
+  const screenId = element => {
+    const screen = element.closest?.('.mb-screen');
+    const index = screen ? screens.indexOf(screen) : 0;
+    return `screen-${String(Math.max(index, 0) + 1).padStart(3, '0')}`;
+  };
+  const allowedAttrs = new Set(['id', 'class', 'role', 'title', 'alt', 'type', 'name', 'placeholder', 'aria-label', 'aria-selected', 'aria-expanded', 'aria-controls', 'data-testid', 'href', 'src']);
+  const ignoredTags = new Set(['script', 'style', 'link', 'meta', 'noscript', 'template']);
+  const visit = (element, parentId = null, frameId = null) => {
+    if (!element || element.nodeType !== Node.ELEMENT_NODE) return;
+    const tag = element.tagName.toLowerCase();
+    if (ignoredTags.has(tag)) return;
+    const id = `dom-${nodes.length + 1}`;
+    const style = getComputedStyle(element);
+    const rect = element.getBoundingClientRect();
+    const directText = normalize(Array.from(element.childNodes).filter(node => node.nodeType === Node.TEXT_NODE).map(node => node.textContent).join(' '));
+    const semanticText = element.matches('.wRichText,button,[role=button],[role=tab],summary,table,th,td,label');
+    const node = {
+      id,
+      parent_id: parentId,
+      children: [],
+      frame_id: frameId,
+      screen_id: screenId(element),
+      tag,
+      role: element.getAttribute('role') || null,
+      attributes: {},
+      direct_text: directText,
+      text: directText || semanticText || element.children.length === 0 ? normalize(element.innerText || element.textContent || '') : null,
+      visibility: {visible: visible(element, style, rect), display: style.display, visibility: style.visibility, opacity: style.opacity},
+      bounds: bounds(element),
+      style: {position: style.position, z_index: style.zIndex, overflow: style.overflow, color: style.color, background_color: style.backgroundColor, font_size: style.fontSize, font_weight: style.fontWeight, transform: style.transform},
+      special: null
+    };
+    for (const attr of Array.from(element.attributes)) {
+      if (allowedAttrs.has(attr.name)) node.attributes[attr.name] = String(attr.value).slice(0, 2048);
+    }
+    nodes.push(node);
+    if (parentId) {
+      const parent = nodes.find(item => item.id === parentId);
+      if (parent) parent.children.push(id);
+    }
+    if (tag === 'iframe') {
+      node.special = {kind: 'iframe', src: element.getAttribute('src') || ''};
+      try {
+        if (element.contentDocument?.documentElement) visit(element.contentDocument.documentElement, id, id);
+      } catch (error) {
+        warnings.push(`跨域 iframe 无法读取：${element.getAttribute('src') || '[unknown]'}`);
+      }
+    }
+    if (tag === 'canvas') {
+      node.special = {kind: 'canvas', width: element.width, height: element.height};
+      visualOnly.push({node_id: id, kind: 'canvas', bounds: node.bounds});
+    }
+    if (tag === 'svg') {
+      node.special = {kind: 'svg'};
+      if (!normalize(element.textContent)) visualOnly.push({node_id: id, kind: 'svg', bounds: node.bounds});
+    }
+    if (visible(element, style, rect) && style.backgroundImage && style.backgroundImage !== 'none') {
+      visualOnly.push({node_id: id, kind: 'background_image', bounds: node.bounds});
+    }
+    if (element.shadowRoot) {
+      node.special = {...(node.special || {}), shadow_root: 'open'};
+      for (const child of Array.from(element.shadowRoot.children)) visit(child, id, frameId);
+    }
+    for (const child of Array.from(element.children)) visit(child, id, frameId);
+  };
+  visit(root);
+  return {nodes, screens: screens.map((screen, index) => ({id: `screen-${String(index + 1).padStart(3, '0')}`, title: normalize(screen.querySelector?.('.canvas-title')?.textContent) || `页面 ${index + 1}`, bounds: bounds(screen)})), visual_only: visualOnly, warnings, frame_count: nodes.filter(node => node.special?.kind === 'iframe').length};
+}
+"""

modao_prd_cli/modao_prd/classifier.py

@@ -0,0 +1,96 @@
+"""Explainable Chinese text classification for prototype requirements."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+CLASSIFICATION_PATTERNS: list[tuple[str, tuple[str, ...]]] = [
+    ("warning", ("注意", "谨慎", "禁止", "无关", "不可退款", "仅供娱乐")),
+    ("validation", ("若", "如果", "低于", "不足", "超过", "达到上限", "不可继续", "提示")),
+    ("persistence", ("不会重置", "不跟随", "保留", "整个活动期间有效", "退出活动清空")),
+    ("limit", ("上限", "最多", "至少", "1-3", "超过", "最高")),
+    ("timing", ("活动时间", "活动期间", "倒计时", "小时", "天", "有效期")),
+    ("probability", ("概率", "随机", "几率", "%")),
+    ("reward", ("奖励", "获得", "礼包", "礼物", "赠送", "奖池")),
+    ("interaction", ("点击", "选择", "切换", "弹出", "关闭", "打开", "输入", "按键")),
+]
+
+
+def classify_blocks(blocks: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]], list[str]]:
+    requirements: list[dict[str, Any]] = []
+    interactions: list[dict[str, Any]] = []
+    warnings: list[str] = []
+
+    for block in blocks:
+        if block.get("type") not in {"text", "heading", "label", "tab"}:
+            continue
+        text = str(block.get("text", "")).strip()
+        if not text:
+            continue
+        categories = [category for category, patterns in CLASSIFICATION_PATTERNS if any(pattern in text for pattern in patterns)]
+        if categories:
+            category = _select_primary_category(categories)
+            requirements.append(
+                {
+                    "id": f"rule-{len(requirements) + 1:03d}",
+                    "type": category,
+                    "statement": text,
+                    "conditions": _extract_conditions(text),
+                    "feedback": _extract_feedback(text),
+                    "source_block_ids": [block["id"]],
+                }
+            )
+        if "点击" in text or "选择" in text or "切换" in text or "弹出" in text:
+            interactions.append(
+                {
+                    "id": f"interaction-{len(interactions) + 1:03d}",
+                    "trigger": _extract_trigger(text),
+                    "action": text,
+                    "source_block_ids": [block["id"]],
+                }
+            )
+        if re.search(r"\b20\d{2}[./-]\d{1,2}[./-]\d{1,2}", text):
+            warnings.append("页面包含带具体日期的示例记录，请确认它们不是最终业务配置。")
+        if "谷歌文档" in text or "外部文档" in text:
+            warnings.append("页面引用了外部文档，外部文档内容未包含在本次提取结果中。")
+
+    if any(item["type"] == "probability" for item in requirements):
+        warnings.append("页面包含概率或随机规则，提取结果需要人工确认。")
+    return requirements, interactions, _unique(warnings)
+
+
+def _select_primary_category(categories: list[str]) -> str:
+    # Keep validation and interaction semantics visible; generic rewards come later.
+    priority = ["warning", "validation", "persistence", "limit", "timing", "probability", "reward", "interaction"]
+    return min(categories, key=priority.index)
+
+
+def _extract_conditions(text: str) -> list[str]:
+    conditions = re.findall(r"(?:若|如果|当|超过|低于|不足|达到)[^。；\n]*", text)
+    return [item.strip(" ，,：:") for item in conditions[:5]]
+
+
+def _extract_feedback(text: str) -> str | None:
+    match = re.search(r"(?:toast|提示|报错)\s*[：:]\s*([^。；\n]+)", text, re.I)
+    return match.group(1).strip() if match else None
+
+
+def _extract_trigger(text: str) -> str:
+    match = re.search(r"点击([^，。；\n]{0,24})", text)
+    if match:
+        return f"点击{match.group(1).strip()}".rstrip("，。")
+    match = re.search(r"(选择|切换|输入|弹出)[^，。；\n]{0,24}", text)
+    return match.group(0).strip() if match else "用户操作"
+
+
+def _unique(values: list[str]) -> list[str]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+