@baimingtao/lbs-agent 1.0.0

package/extensions/skills/optional/devops/watchers/scripts/watch_github.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""Watch GitHub activity — issues, pulls, releases, or commits — with dedup.
+
+Usage (via cron with --no-agent):
+
+    hermes cron create hermes-issues \\
+      --schedule "*/5 * * * *" --no-agent \\
+      --script "$HERMES_HOME/skills/devops/watchers/scripts/watch_github.py" \\
+      --script-args "--name hermes-issues --repo NousResearch/hermes-agent --scope issues"
+
+Set GITHUB_TOKEN (or GH_TOKEN) in the Hermes .env file
+(``${HERMES_HOME:-~/.hermes}/.env``) to avoid the 60 req/hr
+anonymous rate limit.
+
+Scopes: issues | pulls | releases | commits.  Or pass --search QUERY to
+use the /search/issues endpoint instead of /repos/:owner/:repo/:scope.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from _watermark import Watermark, format_items_as_markdown  # type: ignore
+
+
+VALID_SCOPES = ("issues", "pulls", "releases", "commits")
+
+
+def _flatten_commit(item):
+    """Commit objects nest title/author/date under 'commit' — flatten for rendering."""
+    commit = item.get("commit") or {}
+    msg = (commit.get("message") or "").strip().splitlines()
+    title = msg[0] if msg else ""
+    body = "\n".join(msg[1:]).strip() if len(msg) > 1 else ""
+    author = (item.get("author") or {}).get("login") or (commit.get("author") or {}).get("name", "")
+    date = (commit.get("author") or {}).get("date", "")
+    return {
+        "id": item.get("sha", ""),
+        "title": f"{title}  ({author})" if author else title,
+        "url": item.get("html_url"),
+        "body": body,
+        "created_at": date,
+    }
+
+
+def _flatten_issue_or_release(item):
+    return {
+        "id": str(item.get("id", "")),
+        "title": item.get("title") or item.get("name") or "",
+        "url": item.get("html_url") or item.get("url"),
+        "body": (item.get("body") or "").strip(),
+        "state": item.get("state"),
+        "author": (item.get("user") or {}).get("login")
+        or (item.get("author") or {}).get("login"),
+        "created_at": item.get("created_at"),
+    }
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="Watch GitHub issues / pulls / releases / commits.")
+    p.add_argument("--name", required=True, help="Watcher name (used for state file)")
+    p.add_argument("--repo", default="",
+                   help="owner/name of the repo (one of --repo or --search is required)")
+    p.add_argument("--scope", default="issues", choices=VALID_SCOPES,
+                   help="What to poll (default: issues)")
+    p.add_argument("--search", default="",
+                   help="GitHub issues search query (alternative to --repo/--scope)")
+    p.add_argument("--per-page", type=int, default=30,
+                   help="Results per page (default: 30, max: 100)")
+    p.add_argument("--max", type=int, default=20,
+                   help="Max new items to emit per tick (default: 20)")
+    p.add_argument("--with-body", action="store_true",
+                   help="Include issue/commit body as a snippet under each item")
+    p.add_argument("--timeout", type=float, default=30.0,
+                   help="HTTP timeout in seconds (default: 30)")
+    args = p.parse_args()
+
+    if not args.repo and not args.search:
+        print("watch_github: one of --repo or --search is required", file=sys.stderr)
+        return 2
+    if args.repo and not re.fullmatch(r"[A-Za-z0-9._-]+/[A-Za-z0-9._-]+", args.repo):
+        print(f"watch_github: --repo must be owner/name (got {args.repo!r})", file=sys.stderr)
+        return 2
+
+    # URL + flattening 策略。
+    if args.search:
+        url = (
+            "https://api.github.com/search/issues"
+            f"?q={urllib.parse.quote(args.search)}&per_page={args.per_page}"
+        )
+        flatten = _flatten_issue_or_release
+        items_path = "items"
+    elif args.scope == "commits":
+        url = f"https://api.github.com/repos/{args.repo}/commits?per_page={args.per_page}"
+        flatten = _flatten_commit
+        items_path = ""
+    else:
+        url = (
+            f"https://api.github.com/repos/{args.repo}/{args.scope}"
+            f"?per_page={args.per_page}&state=all"
+        )
+        flatten = _flatten_issue_or_release
+        items_path = ""
+
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "Hermes-Watcher/1.0",
+    }
+    token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    req = urllib.request.Request(url)
+    for k, v in headers.items():
+        req.add_header(k, v)
+
+    try:
+        with urllib.request.urlopen(req, timeout=args.timeout) as resp:
+            raw = resp.read()
+    except urllib.error.HTTPError as e:
+        print(f"watch_github: HTTP {e.code} from {url}", file=sys.stderr)
+        return 2
+    except (urllib.error.URLError, TimeoutError, OSError) as e:
+        print(f"watch_github: network error: {e}", file=sys.stderr)
+        return 2
+
+    try:
+        data = json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as e:
+        print(f"watch_github: response is not valid JSON: {e}", file=sys.stderr)
+        return 2
+
+    # 如有需要，深入 items_path（搜索端点返回 {"items":[...]}）。
+    if items_path:
+        data = data.get(items_path) if isinstance(data, dict) else None
+    if not isinstance(data, list):
+        print(f"watch_github: expected a list of items; got {type(data).__name__}",
+              file=sys.stderr)
+        return 2
+
+    items = [flatten(i) for i in data if isinstance(i, dict)]
+    # 丢弃任何展平后没有 ID 的项（防御性措施）。
+    items = [i for i in items if i.get("id")]
+
+    wm = Watermark.load(args.name)
+    new_items = wm.filter_new(items, id_key="id")
+    wm.save()
+
+    if args.max > 0:
+        new_items = new_items[: args.max]
+
+    body_key = "body" if args.with_body else None
+    output = format_items_as_markdown(new_items, body_key=body_key)
+    if output:
+        sys.stdout.write(output)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/extensions/skills/optional/devops/watchers/scripts/watch_http_json.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Watch any JSON endpoint that returns a list of objects; dedup by ID field.
+
+Usage (via cron with --no-agent):
+
+    hermes cron create api-events \\
+      --schedule "*/1 * * * *" --no-agent \\
+      --script "$HERMES_HOME/skills/devops/watchers/scripts/watch_http_json.py" \\
+      --script-args "--name api --url https://api.example.com/events \\
+                     --id-field event_id --items-path data.events"
+
+The response can be:
+  - a top-level JSON list (default), or
+  - a JSON object with a dotted ``--items-path`` pointing to the list.
+
+Each item is deduped by ``--id-field`` (default "id").
+
+Optional ``--header KEY:VALUE`` flags pass HTTP headers (repeatable).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from _watermark import Watermark, format_items_as_markdown  # type: ignore
+
+
+def _dig(obj, path: str):
+    """Dotted-path lookup: _dig({'a':{'b':[1,2]}}, 'a.b') → [1,2]."""
+    if not path:
+        return obj
+    cur = obj
+    for part in path.split("."):
+        if isinstance(cur, dict) and part in cur:
+            cur = cur[part]
+        else:
+            return None
+    return cur
+
+
+def _parse_header(s: str):
+    if ":" not in s:
+        raise argparse.ArgumentTypeError(
+            f"--header expects 'KEY: VALUE' (got {s!r})"
+        )
+    k, v = s.split(":", 1)
+    return (k.strip(), v.strip())
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="Poll a JSON endpoint.")
+    p.add_argument("--name", required=True, help="Watcher name (used for state file)")
+    p.add_argument("--url", required=True, help="JSON endpoint URL")
+    p.add_argument("--id-field", default="id",
+                   help="Field used to dedup items (default: 'id')")
+    p.add_argument("--items-path", default="",
+                   help="Dotted path to the list inside the JSON response (e.g. 'data.events')")
+    p.add_argument("--title-field", default="title",
+                   help="Field used as the item title in the rendered output (default: 'title')")
+    p.add_argument("--url-field", default="url",
+                   help="Field used as the item URL in the rendered output (default: 'url')")
+    p.add_argument("--body-field", default="",
+                   help="Optional body field to include as a snippet under each item")
+    p.add_argument("--max", type=int, default=20,
+                   help="Max new items to emit per tick (default: 20)")
+    p.add_argument("--header", action="append", type=_parse_header, default=[],
+                   metavar="KEY: VALUE",
+                   help="HTTP header (repeatable)")
+    p.add_argument("--timeout", type=float, default=20.0,
+                   help="HTTP timeout in seconds (default: 20)")
+    args = p.parse_args()
+
+    req = urllib.request.Request(args.url, headers={"User-Agent": "Hermes-Watcher/1.0"})
+    for k, v in args.header:
+        req.add_header(k, v)
+
+    try:
+        with urllib.request.urlopen(req, timeout=args.timeout) as resp:
+            raw = resp.read()
+    except urllib.error.HTTPError as e:
+        print(f"watch_http_json: HTTP {e.code} from {args.url}", file=sys.stderr)
+        return 2
+    except (urllib.error.URLError, TimeoutError, OSError) as e:
+        print(f"watch_http_json: network error: {e}", file=sys.stderr)
+        return 2
+
+    try:
+        data = json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as e:
+        print(f"watch_http_json: response is not valid JSON: {e}", file=sys.stderr)
+        return 2
+
+    items = _dig(data, args.items_path) if args.items_path else data
+    if not isinstance(items, list):
+        print(
+            f"watch_http_json: items_path={args.items_path!r} did not resolve to a list "
+            f"(got {type(items).__name__})",
+            file=sys.stderr,
+        )
+        return 2
+
+    # 仅保留字典 — 跳过任何纯字符串/数字，以免 filter_new 崩溃。
+    items = [i for i in items if isinstance(i, dict)]
+
+    wm = Watermark.load(args.name)
+    new_items = wm.filter_new(items, id_key=args.id_field)
+    wm.save()
+
+    if args.max > 0:
+        new_items = new_items[: args.max]
+
+    body_key = args.body_field or None
+    output = format_items_as_markdown(
+        new_items,
+        title_key=args.title_field,
+        url_key=args.url_field,
+        body_key=body_key,
+    )
+    if output:
+        sys.stdout.write(output)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/extensions/skills/optional/devops/watchers/scripts/watch_rss.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Watch an RSS 2.0 or Atom feed; print new items to stdout, silent on empty.
+
+Usage (via cron with --no-agent):
+
+    hermes cron create my-feed \\
+      --schedule "*/15 * * * *" --no-agent \\
+      --script "$HERMES_HOME/skills/devops/watchers/scripts/watch_rss.py" \\
+      --script-args "--name hn --url https://news.ycombinator.com/rss"
+
+First run records a baseline (emits nothing).  Subsequent runs emit only
+items whose <guid> / <id> isn't in the watermark.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+sys.path.insert(0, str(Path(__file__).parent))
+from _watermark import Watermark, format_items_as_markdown  # type: ignore
+
+
+def _strip_ns(tag: str) -> str:
+    return tag.split("}", 1)[1] if "}" in tag else tag
+
+
+def _parse_feed(xml_bytes: bytes):
+    """Return a list of {id, title, url, summary} dicts.
+
+    Handles both RSS 2.0 ``<item>`` and Atom ``<entry>``.
+    """
+    try:
+        root = ET.fromstring(xml_bytes)
+    except ET.ParseError as e:
+        print(f"watch_rss: invalid XML: {e}", file=sys.stderr)
+        sys.exit(2)
+
+    entries = []
+    for item in root.iter():
+        tag = _strip_ns(item.tag)
+        if tag not in {"item", "entry"}:
+            continue
+        # 没有子节点的 ElementTree Elements 为 *假值* —— 请使用 `is not None`。
+        children = {_strip_ns(c.tag): c for c in item}
+
+        guid_el = children.get("guid")
+        if guid_el is None:
+            guid_el = children.get("id")
+        link_el = children.get("link")
+        if link_el is not None:
+            href = link_el.attrib.get("href") or (link_el.text or "").strip()
+        else:
+            href = ""
+        guid = (guid_el.text or "").strip() if guid_el is not None else ""
+        guid = guid or href
+        if not guid:
+            continue
+
+        title_el = children.get("title")
+        title = (title_el.text or "").strip() if title_el is not None else ""
+
+        summ_el = children.get("description")
+        if summ_el is None:
+            summ_el = children.get("summary")
+        summary = (summ_el.text or "").strip() if summ_el is not None else ""
+
+        entries.append(
+            {"id": guid, "title": title, "url": href, "summary": summary}
+        )
+    return entries
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="Watch an RSS/Atom feed.")
+    p.add_argument("--name", required=True, help="Watcher name (used for state file)")
+    p.add_argument("--url", required=True, help="Feed URL")
+    p.add_argument("--max", type=int, default=10,
+                   help="Max new items to emit per tick (default: 10)")
+    p.add_argument("--with-summary", action="store_true",
+                   help="Include <description>/<summary> snippet under each item")
+    p.add_argument("--timeout", type=float, default=20.0,
+                   help="HTTP timeout in seconds (default: 20)")
+    args = p.parse_args()
+
+    try:
+        req = urllib.request.Request(args.url, headers={"User-Agent": "Hermes-Watcher/1.0"})
+        with urllib.request.urlopen(req, timeout=args.timeout) as resp:
+            xml_bytes = resp.read()
+    except urllib.error.HTTPError as e:
+        print(f"watch_rss: HTTP {e.code} from {args.url}", file=sys.stderr)
+        return 2
+    except (urllib.error.URLError, TimeoutError, OSError) as e:
+        print(f"watch_rss: network error: {e}", file=sys.stderr)
+        return 2
+
+    entries = _parse_feed(xml_bytes)
+
+    wm = Watermark.load(args.name)
+    new_items = wm.filter_new(entries, id_key="id")
+    wm.save()
+
+    # 限制已发射项目的数量（水位线仍会记录所有已见的 ID，这样我们不会
+    # 在下次 tick 时重新发射它们）。
+    if args.max > 0:
+        new_items = new_items[: args.max]
+
+    body_key = "summary" if args.with_summary else None
+    output = format_items_as_markdown(new_items, body_key=body_key)
+    if output:
+        sys.stdout.write(output)
+    # 无新增项时清空 stdout —— cron 会将其视为静默处理。
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/extensions/skills/optional/dogfood/DESCRIPTION.md

@@ -0,0 +1,3 @@
+# Dogfood — 高级 QA 与测试技能
+
+超越基础 bug 查找的专业 QA 工作流。这些技能采用结构化的方法论，旨在发现标准测试容易遗漏的 UX 摩擦、无障碍问题以及产品层面的问题。

package/extensions/skills/optional/dogfood/adversarial-ux-test/SKILL.md

@@ -0,0 +1,191 @@
+---
+name: adversarial-ux-test
+description: 扮演你的产品中最难搞、最抗拒技术的用户。以该人设浏览应用，找出每一个 UX 痛点，然后通过一个实用主义过滤层来过滤抱怨，从而区分真正的问题和噪音。仅针对真正的问题创建可执行的工单。
+version: 1.0.0
+author: Omni @ Comelse
+license: MIT
+platforms: [linux, macos, windows]
+metadata:
+  hermes:
+    tags: [qa, ux, testing, adversarial, dogfood, personas, user-testing]
+    related_skills: [dogfood]
+---
+
+# Adversarial UX 测试
+
+扮演你的产品中处于最糟糕情况下的用户——讨厌科技、不需要你的软件，并且会找出一切理由来抱怨的人。然后通过一个实用主义过滤层来过滤他们的反馈，从而将真实的 UX 问题与“我讨厌电脑”这种噪音区分开来。
+
+把它想象成一个自动化的“老妈测试”——不过是愤怒版的。
+
+## 为什么这有效
+
+大多数 QA 找出的是 bug。而这找出的是**摩擦（friction）**。一个技术上完全正确的应用对于真实的人类来说可能仍然是不可用的。对抗性人设可以捕捉到：
+- 对开发人员来说有意义但对用户毫无意义的令人困惑的术语
+- 完成基本任务所需的步骤过多
+- 缺少新手引导或“Aha moment（顿悟时刻）”
+- 可访问性问题（字体大小、对比度、点击目标）
+- 冷启动问题（空状态、没有演示内容）
+- 损害转化率的付费墙/注册阻力
+
+**实用主义过滤层**（第3阶段）使这项工作变得有用而不仅仅是具有娱乐性。如果没有它，你会因为老爷爷搞不懂 PDF 而在每个屏幕上都添加一个“打印此页面”的按钮。
+
+## 如何使用
+
+告诉 agent：
+```
+"Run an adversarial UX test on [URL]"
+"Be a grumpy [persona type] and test [app name]"
+"Do an asshole user test on my staging site"
+```
+
+你可以提供一个人设，或者让 agent 根据你产品的目标受众生成一个。
+
+## 第 1 步：定义人设
+
+如果没有提供人设，请通过回答以下问题来生成一个：
+
+1. **谁是该产品最难搞的用户？**（50岁以上、非技术职位、拥有数十年按“老办法”做事的经验）
+2. **他们的技术适应水平如何？**（越低越好——只用 WhatsApp、纸质笔记本、邮箱是老婆帮设置的）
+3. **他们必须完成的一项任务是什么？**（他们的核心工作，而不是你的功能列表）
+4. **什么会让他们放弃？**（点击太多、专业术语、速度慢、令人困惑）
+5. **他们受挫时会怎么说话？**（直言不讳、爆粗口、不屑一顾、唉声叹气）
+
+### 好 Persona 示例
+> **"Big Mick" McAllister** —— 58岁的体能教练。只用 WhatsApp，仅此而已。他的“电子表格”是一本纸质笔记本。“如果我在 10 秒内搞不明白，我就回去用我的笔记本了。”他需要记录 25 名球员的训练成绩。讨厌小号字体、专业术语和密码。
+
+### 糟糕 Persona 示例
+> “一个不喜欢这款应用的用户”——太模糊，没有约束条件，没有说话口吻。
+
+人设必须**足够具体**，才能在 20 分钟的测试中保持入戏。
+
+## 第 2 步：成为混蛋（以人设身份浏览）
+
+1. 阅读任何可用的项目文档，以获取应用上下文和 URL
+2. **完全代入人设**——他们的挫折感、局限性和目标
+3. 使用浏览器工具导航到该应用
+4. **尝试人设的实际任务**（而不是功能导览）：
+   - 他们能做他们想做的事吗？
+   - 需要多少次点击/屏幕才能完成？
+   - 什么让他们感到困惑？
+   - 什么让他们生气？
+   - 他们在哪里迷失了？
+   - 什么会让他们放弃并重操旧业？
+
+5. 测试这些阻力类别：
+   - **第一印象**——他们在落地页之后还会继续尝试吗？
+   - **核心工作流**——他们最常需要做的那一件事
+   - **错误恢复**——当他们做错事时会发生什么？
+   - **可读性**——文本大小、对比度、信息密度
+   - **速度**——感觉比他们目前的方法快吗？
+   - **术语**——有他们听不懂的专业术语吗？
+   - **导航**——他们能找到回去的路吗？他们知道自己在哪儿吗？
+
+6. 截取每一个痛点的屏幕截图
+7. 在每个页面上检查浏览器控制台是否有 JS 错误
+
+## 第 3 步：发泄（以人设身份撰写反馈）
+
+作为人设撰写反馈——用他们的口吻，带着他们的挫折感。这不是一份 bug 报告。这是一个真实的人类在发泄。
+
+```
+[PERSONA NAME] 对 [PRODUCT] 的评价
+
+总体评价：[他们会继续使用它吗？是/否/视条件而定]
+
+好的方面（勉强承认）：
+- [即使是他们也不得不承认管用的事情]
+
+坏的方面（合理的 UX 问题）：
+- [会阻碍他们使用该产品的真实问题]
+
+丑陋的一面（阻碍性缺陷）：
+- [会让他们立刻卸载/取消的事情]
+
+具体抱怨：
+1. [页面/功能]：“[人设口吻的引语]”——[发生了什么，预期是什么]
+2. ...
+
+结论：“[一句话的人设引语，总结他们的体验]”
+```
+
+## 第 4 步：实用主义过滤层（关键 —— 不要跳过）
+
+走出人设。作为产品人员评估每一个抱怨：
+
+- **红色：真正的 UX BUG**——任何用户都会遇到这个问题，而不仅仅是脾气暴躁的人。修复它。
+- **黄色：有效但优先级低**——真实存在的问题，但仅限于极端用户。记录下来。
+- **白色：人设噪音**——“我讨厌电脑”的牢骚，而不是产品问题。跳过它。
+- **绿色：功能请求**——隐藏在抱怨中的好主意。考虑采纳。
+
+### 过滤标准
+1. 一个 35 岁、技术 competent 但工作繁忙的用户也会有同样的抱怨吗？→ 红色
+2. 这是一个真正的可访问性问题（字体大小、对比度、点击目标）吗？→ 红色
+3. 这是“我希望它像纸一样工作”的对数字化的抗拒吗？→ 白色
+4. 这是人设偶然发现的真实工作流低效问题吗？→ 黄色或红色
+5. 修复这个问题是否会给那些毫无问题的 80% 的用户增加复杂性？→ 白色
+6. 抱怨是否揭示了一个缺失的新手引导时刻？→ 绿色
+
+**此过滤器是强制性的。** 绝不要把原始的人设抱怨当成工单提交。
+
+## 第 5 步：创建工单
+
+仅针对**红色**和**绿色**项目：
+- 清晰、可执行的标题
+- 包含人设的原话（具有娱乐性且令人印象深刻）
+- 背后隐藏的真实 UX 问题（客观的）
+- 建议的修复方案（可执行的）
+- 标签/记号："ux-review"
+
+对于**黄色**项目：创建一个包含所有备注的汇总工单。
+
+**白色**项目仅出现在报告中。不要创建工单。
+
+**每次会话最多 10 个工单**——把精力集中在最糟糕的问题上。
+
+## 第 6 步：报告
+
+交付内容：
+1. 人设发泄（第 3 步）——具有娱乐性和发自内心的
+2. 过滤后的评估（第 4 步）——实用且可执行的
+3. 创建的工单（第 5 步）——带链接
+4. 关键问题的截图
+
+## 提示
+
+- **每次会话一个人设。** 不要混合不同的视角。
+- **在第 2-3 步中保持角色状态。** 仅在第 4 步脱离角色。
+- **首先测试核心工作流。** 不要被设置页面分散注意力。
+- **空状态是金矿。** 新用户体验最能揭示摩擦点。
+- **最好的发现是人设在尝试做其他事情时意外发现的红色项目。**
+- **如果人设没有任何抱怨，说明你的人设技术太熟练了。** 把他们设定得更老、更没有耐心、更固执己见。
+- **在演示、发布或发布一批新功能之前运行此测试。**
+- **尽可能注册为新用户。** 不要使用预先填充的管理员账户——冷启动体验是摩擦最常存在的地方。
+- **零白色项目是一个信号，而不是失败。** 如果实用主义过滤层没有发现噪音，说明你的产品存在真正的 UX 问题，而不仅仅是一个暴躁的人设。
+- **测试结束后在项目文档中检查已知问题。** 如果人设发现了一个已经在已知问题列表中的 bug，那实际上是最具毁灭性的发现——这意味着团队知道这个问题，但从未体会过用户的痛苦。
+- **订阅/付费墙测试至关重要。** 使用过期的账户进行测试，而不仅仅是有效的账户。“当你无法付款时会发生什么”的体验揭示了产品是尊重用户还是将他们的数据作为人质。
+- **计算完成人设的唯一任务所需的点击次数。** 如果超过 5 次，无论人设的技术水平如何，这几乎总是一个红色发现。
+
+## 按行业分类的示例人设
+
+这些是起点——请根据你的具体产品进行定制：
+
+| 产品类型 | 人设 | 年龄 | 关键特征 |
+| ------------- | --------- | ----- | ----------- |
+| CRM | 养老院院长 | 68 | 目前的 CRM 就是文件柜 |
+| 摄影 SaaS | 乡村婚礼摄影师 | 62 | 通过电话预约客户，纸质发票 |
+| AI/ML 工具 | 百货公司采购员 | 55 | 曾在 3 次失败的科技初创公司中吃过亏 |
+| 健身应用 | 传统健身房教练 | 58 | 纸质笔记本、粗手指、老花眼 |
+| 会计 | 家庭面包店老板 | 64 | 用鞋盒装收据，讨厌订阅制 |
+| 电子商务 | 摊位摊主 | 60 | 只收现金，智能手机只用来打电话 |
+| 医疗保健 | 资深全科医生 | 63 | 口述笔记，护士负责操作电脑 |
+| 教育 | 资深教师 | 57 | 粉笔加讲授，活页夹里的讲义 |
+
+## 规则
+
+- 在第 2-3 步期间保持角色状态
+- 真正的刻薄但公正——找出真实的问题，而不是捏造问题
+- 实用主义过滤层（第 4 步）是**强制性的**
+- 每一个抱怨都必须提供截图
+- 每次会话最多 10 个工单
+- 在 staging 或已部署的应用上测试，不要在本地开发环境中测试
+- 一个人设，一次会话，一份报告