trip-moments-skill 1.2.0 → 1.3.1

package/.agents/skills/trip-moments/scripts/agent_transport.py

@@ -355,7 +355,9 @@ def _claw_module():
 
 
 class OpenClawTransport:
-    """Persistent-session transport over ClawHive's chat-completions endpoint.
+    """Persistent-session transport over an OpenClaw gateway's chat-completions
+    endpoint — either ClawHive's embedded gateway or the OpenClaw desktop app's
+    WSL-backed one (both are `openclaw`, discovered by clawbridge).
 
     The gateway serves ONE turn per session lane (#235): `start()` is a full
     blocking agent turn, not a run-id handle. We still model it as
@@ -366,6 +368,13 @@ class OpenClawTransport:
     """
 
     provider = "openclaw"
+    # The WSL gateway's session book is SQLite inside the distro and the wsl$
+    # UNC paths are unreachable from Windows, so there is no "the conversation
+    # the user is looking at" to bind to there. This explicit key gives the
+    # workbench one stable thread instead: the gateway routes it to a session of
+    # its own (only `subagent:`/`cron:`/`acp:` are reserved) and repeated turns
+    # continue that conversation rather than starting fresh each time.
+    WORKBENCH_SESSION = "studio-workbench"
 
     def __init__(self, cwd=""):
         self.claw = _claw_module()
@@ -378,28 +387,45 @@ class OpenClawTransport:
     def probe(self):
         info = self.claw.discover(force=True)
         if not info.get("base"):
-            raise AgentError("未找到运行中的 ClawHive gateway：" + (info.get("why") or ""))
+            # A gateway that answered but has the opt-in endpoint disabled is NOT
+            # the same as no gateway: say which one it was and what to turn on,
+            # otherwise the only message the user gets is 「未找到」 while their
+            # OpenClaw is sitting right there on 18789.
+            why = info.get("why") or ""
+            if info.get("via"):
+                raise AgentError(f"{info.get('name') or 'OpenClaw'} 通道不可用：{why}")
+            raise AgentError("未找到运行中的 OpenClaw gateway：" + why)
         if not info.get("enabled"):
-            raise AgentError("ClawHive gateway 的 OpenAI 兼容端点未启用：" + (info.get("why") or ""))
+            raise AgentError("OpenClaw gateway 的 OpenAI 兼容端点未启用：" + (info.get("why") or ""))
         return {"ready": True, "provider": self.provider, "native_sessions": True,
                 "streaming": False, "steer": False, "approvals": False,
-                "port": info.get("port"), "agents": info.get("agents") or []}
+                "port": info.get("port"), "agents": info.get("agents") or [],
+                "gateway": info.get("name") or "", "via": info.get("via") or ""}
 
     def sessions(self):
-        # The desktop conversation list belongs to ClawHive's own UI; offering
+        # The desktop conversation list belongs to that app's own UI; offering
         # it here would invite binding to a session nobody is looking at.
         return []
 
     def create(self, title, cwd):
-        # There is no session-creation endpoint: we bind to the conversation
-        # the user has open right now (see bind).
+        # There is no session-creation endpoint on this API surface; the bind
+        # below decides which thread turns will land in.
         return ""
 
     def bind(self, sid):
-        key = sid or self.claw.active_session()
-        if not key:
-            raise AgentError("没有找到正在使用的 ClawHive 会话；先在 ClawHive 里打开一个对话")
-        return key
+        if sid:
+            return sid
+        key = self.claw.active_session()
+        if key:
+            return key                       # ClawHive: the open conversation
+        info = self.claw.discover()
+        if info.get("via"):
+            # Keyed off `via`, not `base`: a gateway that ANSWERED but has the
+            # endpoint disabled is still a gateway (that is the default state),
+            # and probe() already refused with the exact config key before we get
+            # here. Binding then succeeds and the first turn reports the truth.
+            return self.WORKBENCH_SESSION     # WSL gateway: our own thread
+        raise AgentError("没有找到正在使用的 ClawHive 会话；先在 ClawHive 里打开一个对话")
 
     # -- turns ---------------------------------------------------------------
     def start(self, sid, text, key):

package/.agents/skills/trip-moments/scripts/agent_ui.py

@@ -83,7 +83,7 @@ AGENT_SHELL = r"""
  <div class="ap-body" id="ap-body">
   <details class="ap-setup" id="ap-setup" open><summary>连接与会话绑定</summary>
    <label for="ap-kind">Agent 通道</label><select id="ap-kind" onchange="agentProviderHint()">
-    <option value="hermes">Hermes · 原生持续会话</option><option value="codex">Codex App Server · 工作台专用会话</option><option value="openclaw">OpenClaw (ClawHive) · 活跃会话直连</option></select>
+    <option value="hermes">Hermes · 原生持续会话</option><option value="codex">Codex App Server · 工作台专用会话</option><option value="openclaw">OpenClaw gateway · 整轮直连（ClawHive 或 WSL）</option></select>
    <div id="ap-hermes-fields"><label for="ap-url">本机 Hermes API 地址</label><input id="ap-url" value="http://127.0.0.1:8642">
     <label for="ap-key">API 密钥（留空读取本机 Hermes 配置）</label><input id="ap-key" type="password" autocomplete="off"></div>
    <p class="note" id="ap-hint" style="margin-top:8px"></p>
@@ -130,6 +130,7 @@ function deckControlsHtml() {
     <p class="note" id="wf-mode-note">${agent
       ? "用已绑定 Agent 的模型、工具与会话上下文；检查、处理、追问都在本卡完成。"
       : "用配置的模型网关；AI 分析会发送照片预览，不进入 Agent 会话。"}</p>
+    <p class="note" id="claw-note" style="display:none"></p>
   </div>`;
 }
 /* One input box serves both 「本步要求」 and 「继续追问」, so the session buttons
@@ -275,7 +276,7 @@ function agentProviderHint() {
     ? "绑定 Hermes 原生会话，后续回复与步骤按钮都延续该会话。连接密钥仅由本机服务使用。"
     : kind === "codex"
     ? "使用本机已登录的 Codex CLI，创建工作台专用的持续任务；不接管你当前 Codex 桌面聊天。工具批准仍需你确认。"
-    : "直连 ClawHive 内嵌的 OpenClaw gateway，绑定你正在看的那个会话；整轮执行，无中间批准。需在 openclaw.json 启用 chatCompletions 端点。";
+    : "直连 OpenClaw gateway —— ClawHive 内嵌的那个，或 OpenClaw 桌面版在 WSL 里跑的那个。整轮执行，无中间批准；需在该 gateway 的 openclaw.json 里启用 chatCompletions 端点。ClawHive 上会绑定你正在看的会话；WSL gateway 读不到会话簿，改用工作台专用会话。";
 }
 async function pollAgent() {
   if (AP.polling) return;

package/.agents/skills/trip-moments/scripts/clawbridge.py

@@ -10,20 +10,33 @@ So a click inside Studio can turn into a real agent turn, and the agent's own
 words can be shown back in the workbench — which is the whole point of the demo:
 showing curation *driven by* an agent, not a silent local script.
 
-Discovery is by filesystem, not hardcoded ports: ClawHive writes the live port
-to `…/openclaw/state/gateway-port.json` and the bearer token next to it as
-`gateway-token`. Account/tenant ids vary per install, so we glob.
-
-Everything degrades gracefully: if ClawHive is not running or the endpoint is
-disabled, `discover()` returns None and Studio simply hides the panel.
-"""
-from __future__ import annotations
-
-import glob
-import json
-import os
-import sys
-import time
+Discovery is by filesystem, not hardcoded ports — and there are TWO families of
+gateway to find, because "OpenClaw" ships in two very different shapes:
+
+1. ClawHive's embedded gateway. ClawHive writes the live port to
+   `…/openclaw/state/gateway-port.json` and the bearer token next to it as
+   `gateway-token`. Account/tenant ids vary per install, so we glob.
+2. The OpenClaw desktop app (`OpenClawTray`), which provisions its own WSL distro
+   (default `OpenClawGateway`) and runs `openclaw gateway --port 18789` inside it.
+   Nothing lands in a Windows-visible `~/.openclaw/state`; the app publishes the
+   gateway URL and shared token in `%APPDATA%/OpenClawTray/gateways.json`, and
+   Windows reaches the WSL listener through WSL2 localhost forwarding. Both
+   families multiplex WS + HTTP on the SAME port, and both serve the same
+   OpenAI-compatible surface — but only when it is enabled in that gateway's
+   `openclaw.json` (`gateway.http.endpoints.chatCompletions.enabled`).
+
+Everything degrades gracefully: if no gateway is running, or the endpoint is
+disabled, `discover()` returns a not-found info carrying an honest `why` and
+Studio simply hides the panel.
+"""
+from __future__ import annotations
+
+import glob
+import json
+import os
+import re
+import sys
+import time
 from pathlib import Path
 
 if sys.platform == "win32":
@@ -33,20 +46,106 @@ if sys.platform == "win32":
     except Exception:
         pass
 
-_APPDATA = os.environ.get("APPDATA") or str(Path.home() / "AppData" / "Roaming")
-_STATE_GLOBS = [
-    # ClawHive desktop (per account / per tenant)
-    os.path.join(_APPDATA, "ClawHiveApp", "accounts", "*", "tenants", "*",
-                 "openclaw", "state"),
-    # standalone OpenClaw installs
-    os.path.join(Path.home(), ".openclaw", "state"),
-    os.path.join(Path.home(), ".config", "openclaw", "state"),
-]
-
-_CACHE: dict = {"at": 0.0, "info": None}
-_CACHE_TTL = 20.0
-
-
+_APPDATA = os.environ.get("APPDATA") or str(Path.home() / "AppData" / "Roaming")
+_STATE_GLOBS = [
+    # ClawHive desktop (per account / per tenant)
+    os.path.join(_APPDATA, "ClawHiveApp", "accounts", "*", "tenants", "*",
+                 "openclaw", "state"),
+    # standalone OpenClaw installs
+    os.path.join(Path.home(), ".openclaw", "state"),
+    os.path.join(Path.home(), ".config", "openclaw", "state"),
+]
+_OPENCLAW_TRAY = os.path.join(_APPDATA, "OpenClawTray", "gateways.json")
+_LOCAL_HOST = re.compile(r"^(?:127\.0\.0\.1|localhost|\[::1\]):(\d{2,5})$")
+
+_CACHE: dict = {"at": 0.0, "info": None}
+_CACHE_TTL = 20.0
+
+
+def tray_gateways() -> list[dict]:
+    """Gateways published by the OpenClaw desktop app (the WSL-backed one).
+
+    `openclaw` 2026.x installs as a Windows tray app that creates its own WSL
+    distro and runs the gateway inside it (verified on this machine 2026-10-04:
+    distro `OpenClawGateway`, `node …/openclaw/dist/index.js gateway --port
+    18789`, `gateway.mode: local`, `bind: loopback`, `auth.mode: token`).
+    Windows reaches it because WSL2 forwards localhost; the app records the URL
+    and the shared token here, which happens to be the same value as
+    `gateway.auth.token` inside the distro. We never read the token out of WSL.
+
+    Only loopback URLs are accepted: a remote `sshTunnel`/LAN gateway in this
+    file is not something the workbench should silently send photos to.
+    """
+    try:
+        raw = json.loads(Path(_OPENCLAW_TRAY).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return []
+    out = []
+    for gw in (raw.get("gateways") or []):
+        if not isinstance(gw, dict):
+            continue
+        token = str(gw.get("sharedGatewayToken") or "").strip()
+        url = str(gw.get("url") or "").strip()
+        m = re.match(r"^wss?://([^/]+)/?$", url)
+        if not token or not m:
+            continue
+        host = m.group(1)
+        port = _LOCAL_HOST.match(host)
+        if not port:
+            continue                      # not loopback -> never used
+        out.append({"base": f"http://{host}", "token": token,
+                    "port": int(port.group(1)),
+                    "name": str(gw.get("friendlyName") or "OpenClaw"),
+                    "distro": str(gw.get("setupManagedDistroName") or "")})
+    return out
+
+
+def _probe_endpoint(entry: dict) -> dict:
+    """Fill `agents`/`endpoint`/`enabled` for an entry that already has base+token.
+
+    Both gateway families answer `/health` and multiplex HTTP on the WS port, so
+    one probe serves both. `/v1/models` is the cheapest possible check for the
+    opt-in OpenAI surface: it costs zero agent tokens when it is on, and returns
+    404 when it is off — which is NOT a failure to report as "no gateway found".
+    """
+    token = entry["token"]
+    try:
+        import requests
+
+        r = requests.get(f"{entry['base']}/health", timeout=2,
+                         proxies={"http": None, "https": None})
+        if r.status_code != 200:
+            entry["why"] = f"gateway /health -> HTTP {r.status_code}"
+            return entry
+    except Exception as exc:
+        entry["why"] = f"gateway 无响应: {type(exc).__name__}"
+        return entry
+
+    try:
+        import requests
+
+        r = requests.get(f"{entry['base']}/v1/models",
+                         headers={"Authorization": f"Bearer {token}"},
+                         timeout=4,
+                         proxies={"http": None, "https": None})
+        ct = (r.headers.get("Content-Type") or "")
+        if r.status_code == 200 and "json" in ct:
+            data = r.json().get("data") or []
+            entry["agents"] = [m.get("id") for m in data if isinstance(m, dict) and m.get("id")]
+            entry["endpoint"] = bool(entry["agents"])
+            if not entry["endpoint"]:
+                entry["why"] = "gateway 已启用端点，但 /v1/models 没列出任何 agent"
+        else:
+            entry["why"] = ("已找到 gateway（" + (entry.get("name") or entry["base"])
+                            + "），但 OpenAI 兼容端点未启用"
+                            "：在该 gateway 的 openclaw.json 里设置 "
+                            "gateway.http.endpoints.chatCompletions.enabled = true")
+    except Exception as exc:
+        entry["why"] = f"端点探测失败: {type(exc).__name__}"
+    entry["enabled"] = bool(entry["endpoint"])
+    return entry
+
+
 def _state_dirs() -> list[Path]:
     dirs = []
     for pat in _STATE_GLOBS:
@@ -60,8 +159,9 @@ def _state_dirs() -> list[Path]:
 def _probe_state(state: Path) -> dict:
     """Probe ONE ClawHive state dir. Returns an entry with `enabled` plus an
     honest `why` when it is not usable — the caller keeps trying the others."""
-    entry = {"base": "", "token": "", "port": 0, "state_dir": str(state),
-             "agents": [], "endpoint": False, "enabled": False, "why": ""}
+    entry = {"base": "", "token": "", "port": 0, "state_dir": str(state),
+             "agents": [], "endpoint": False, "enabled": False, "why": "",
+             "via": "clawhive", "name": "ClawHive"}
     try:
         port = int(json.loads((state / "gateway-port.json").read_text(
             encoding="utf-8"))["port"])
@@ -80,82 +180,83 @@ def _probe_state(state: Path) -> dict:
     if not token:
         entry["why"] = "gateway-token 为空"
         return entry
-    entry.update({"base": f"http://127.0.0.1:{port}", "token": token, "port": port})
-
-    try:
-        import requests
-
-        r = requests.get(f"{entry['base']}/health", timeout=2,
-                         proxies={"http": None, "https": None})
-        if r.status_code != 200:
-            entry["why"] = f"gateway /health -> HTTP {r.status_code}"
-            return entry
-    except Exception as exc:
-        entry["why"] = f"gateway 无响应: {type(exc).__name__}"
-        return entry
-
-    # the OpenAI-compatible surface is opt-in; /v1/models tells us whether
-    # it is on without spending a single agent token
-    try:
-        import requests
-
-        r = requests.get(f"{entry['base']}/v1/models",
-                         headers={"Authorization": f"Bearer {token}"},
-                         timeout=4,
-                         proxies={"http": None, "https": None})
-        ct = (r.headers.get("Content-Type") or "")
-        if r.status_code == 200 and "json" in ct:
-            data = r.json().get("data") or []
-            entry["agents"] = [m.get("id") for m in data if m.get("id")]
-            entry["endpoint"] = bool(entry["agents"])
-        else:
-            entry["why"] = ("已找到 gateway，但 OpenAI 兼容端点未启用"
-                            "（gateway.http.endpoints.chatCompletions.enabled）")
-    except Exception as exc:
-        entry["why"] = f"端点探测失败: {type(exc).__name__}"
-    entry["enabled"] = bool(entry["endpoint"])
-    return entry
+    entry.update({"base": f"http://127.0.0.1:{port}", "token": token, "port": port})
+    return _probe_endpoint(entry)
 
 
 def discover(force: bool = False) -> dict | None:
-    """Locate a live ClawHive gateway across ALL candidate tenants.
-
-    The first state dir that has a port+token used to win the loop outright —
-    a dead first tenant permanently shadowed a healthy second one. Now every
-    candidate is probed (cheap: /health + /v1/models) until one is actually
-    healthy, and the failures are carried in `tried` for diagnosis.
-
-    Returns {"base", "token", "port", "agents", "endpoint": bool, "why": str,
-    "tried": [...]} or a not-found info when nothing is reachable. Cached
-    briefly: this is called on every state refresh and probing each time would
-    be wasteful. `force=True` bypasses the TTL — that is for the user's
-    explicit refresh, not for background polling.
+    """Locate a live gateway across ALL candidate installs.
+
+    Two families are searched: ClawHive's embedded gateway (state dirs with
+    gateway-port.json) and the OpenClaw desktop app's WSL-backed gateway
+    (gateways.json). ClawHive is tried first — on it we can also target the
+    conversation the user is looking at, which the standalone gateway cannot
+    offer through this endpoint.
+
+    The first state dir that has a port+token used to win the loop outright —
+    a dead first tenant permanently shadowed a healthy second one. Now every
+    candidate is probed (cheap: /health + /v1/models) until one is actually
+    healthy, and the failures are carried in `tried` for diagnosis.
+
+    Returns {"base", "token", "port", "agents", "endpoint": bool, "why": str,
+    "tried": [...]} or a not-found info when nothing is reachable. Cached
+    briefly: this is called on every state refresh and probing each time would
+    be wasteful. `force=True` bypasses the TTL — that is for the user's
+    explicit refresh, not for background polling.
     """
     now = time.time()
     if not force and _CACHE["info"] is not None and now - _CACHE["at"] < _CACHE_TTL:
         return _CACHE["info"]
 
-    healthy = None
-    tried = []
-    for state in _state_dirs():
-        entry = _probe_state(state)
-        tried.append({"state_dir": entry["state_dir"], "port": entry["port"],
-                      "enabled": entry["enabled"], "why": entry["why"]})
-        if entry["enabled"]:
-            healthy = entry
-            break
-
-    if healthy is not None:
-        info = dict(healthy)
-        info["tried"] = tried
-    else:
-        whys = [t["why"] for t in tried if t.get("why")]
-        info = {"base": "", "token": "", "port": 0, "agents": [], "endpoint": False,
-                "enabled": False, "state_dir": "",
-                "why": ("；".join(whys)[:300] if whys
-                        else "未找到运行中的 ClawHive gateway"),
-                "tried": tried}
-    _CACHE.update({"at": now, "info": info})
+    healthy = None
+    tried = []
+    for state in _state_dirs():
+        entry = _probe_state(state)
+        tried.append({"state_dir": entry["state_dir"], "port": entry["port"],
+                      "enabled": entry["enabled"], "why": entry["why"],
+                      "via": entry.get("via") or "clawhive",
+                      "name": entry.get("name") or "ClawHive"})
+        if entry["enabled"]:
+            healthy = entry
+            break
+
+    # The OpenClaw desktop app's own gateway. Its OpenAI surface has to be
+    # enabled in ITS config, so a disabled one is reported with the exact key
+    # rather than being mistaken for "no gateway found" — the two look the same
+    # from the page otherwise, and the user has to know which knob to turn.
+    if healthy is None:
+        for gw in tray_gateways():
+            entry = _probe_endpoint(dict(gw, state_dir="", agents=[], endpoint=False,
+                                         enabled=False, why="", via="openclaw-tray"))
+            tried.append({"state_dir": entry["base"], "port": entry["port"],
+                          "enabled": entry["enabled"], "why": entry["why"],
+                          "via": "openclaw-tray",
+                          "name": entry.get("name") or "OpenClaw"})
+            if entry["enabled"]:
+                healthy = entry
+                break
+
+    if healthy is not None:
+        info = dict(healthy)
+        info["tried"] = tried
+    else:
+        whys = [t["why"] for t in tried if t.get("why")]
+        info = {"base": "", "token": "", "port": 0, "agents": [], "endpoint": False,
+                "enabled": False, "state_dir": "", "via": "", "name": "",
+                "why": ("；".join(whys)[:400] if whys
+                        else "未找到运行中的 ClawHive / OpenClaw gateway"),
+                "tried": tried}
+        # A gateway that ANSWERED but has the endpoint off is the common case (it
+        # is off by default) and it is not "nothing found". Carry its identity
+        # through so the page can name it: 「Local (OpenClawGateway) 通道未就绪
+        # （…chatCompletions.enabled…）」 is actionable, 「未找到 gateway」 is not.
+        for t in reversed(tried):
+            if t.get("port"):
+                info.update({"port": t["port"], "via": t.get("via") or "",
+                             "state_dir": t.get("state_dir") or "",
+                             "name": (t.get("name") or "")})
+                break
+    _CACHE.update({"at": now, "info": info})
     return info
 
 
@@ -172,6 +273,8 @@ def status(force: bool = False) -> dict:
         "agents": info.get("agents") or [],
         "why": info.get("why") or "",
         "state_dir": info.get("state_dir") or "",
+        "via": info.get("via") or "",
+        "name": info.get("name") or "",
         "tried": info.get("tried") or [],
         # the page needs to know this *before* the click: delegating into a
         # conversation that is mid-turn cannot be served (see session_busy)
@@ -320,11 +423,11 @@ def ask(message: str, agent: str = "", session: str = "trip-moments-studio",
     resolving sessions against "main" while talking to another agent used to
     post into a conversation nobody was looking at.
     """
-    info = discover()
-    if not info.get("base"):
-        raise RuntimeError(info.get("why") or "ClawHive gateway 不可用")
-    if not info.get("enabled"):
-        raise RuntimeError(info.get("why") or "ClawHive 的 OpenAI 兼容端点未启用")
+    info = discover()
+    if not info.get("base"):
+        raise RuntimeError(info.get("why") or "OpenClaw gateway 不可用")
+    if not info.get("enabled"):
+        raise RuntimeError(info.get("why") or "OpenClaw 的 OpenAI 兼容端点未启用")
 
     target = pick_agent(agent)
     payload = {
@@ -364,8 +467,8 @@ def ask(message: str, agent: str = "", session: str = "trip-moments-studio",
                       headers=headers, json=payload, timeout=timeout,
                       proxies={"http": None, "https": None})
     took = time.time() - t0
-    if r.status_code != 200:
-        raise RuntimeError(f"ClawHive 返回 HTTP {r.status_code}: {r.text[:200]}")
+    if r.status_code != 200:
+        raise RuntimeError(f"gateway 返回 HTTP {r.status_code}: {r.text[:200]}")
     data = r.json()
     try:
         text = data["choices"][0]["message"]["content"]

package/.agents/skills/trip-moments/scripts/imquality.py

@@ -8,11 +8,13 @@ from __future__ import annotations
 import base64
 import io
 import os
+import re
 import sys
+from functools import lru_cache
 from pathlib import Path
 
 import numpy as np
-from PIL import Image, ImageFilter, ImageOps, ImageFont
+from PIL import Image, ImageDraw, ImageFilter, ImageOps, ImageFont
 
 if sys.platform == "win32":
     try:
@@ -149,41 +151,152 @@ def palette(img: Image.Image, n: int = 5) -> list[tuple[int, int, int]]:
 
 
 # --- fonts (Cross-platform font paths; graceful fallback) ---------------------
-FONT_ZH_BOLD = ["msyhbd.ttc", "simhei.ttf", "msyh.ttc", "simsun.ttc", "NotoSansSC-Bold.otf", "PingFang.ttc"]
-FONT_ZH = ["msyh.ttc", "simsun.ttc", "simhei.ttf", "NotoSansSC-Regular.otf", "PingFang.ttc", "STHeiti.ttc"]
+# The names differ per platform because the *products* differ: Windows/macOS ship
+# their own CJK faces, while Debian/Ubuntu install the Noto **CJK** superfamily
+# (opentype/noto/NotoSansCJK-*.ttc) and Fedora/Arch often the SC subset instead.
+# Listing only the Windows names (plus NotoSansSC) meant a Linux server rendered
+# every Chinese glyph as the same .notdef box — measured in a python:3.11-slim
+# container: 「朋友圈旅行」 and 「敦煌戈壁滩」 produced byte-identical bitmaps both
+# before AND after `apt install fonts-noto-cjk`, because /usr/share/fonts was only
+# searched one level deep and the .ttc name was not a candidate at all.
+FONT_ZH_BOLD = [
+    "msyhbd.ttc", "simhei.ttf", "msyh.ttc", "simsun.ttc", "PingFang.ttc",
+    "NotoSansCJK-Bold.ttc", "NotoSansCJK-Regular.ttc", "NotoSansCJKsc-Bold.otf",
+    "NotoSansSC-Bold.otf", "SourceHanSansSC-Bold.otf", "wqy-zenhei.ttc",
+]
+FONT_ZH = [
+    "msyh.ttc", "simsun.ttc", "simhei.ttf", "PingFang.ttc", "STHeiti.ttc",
+    "NotoSansCJK-Regular.ttc", "NotoSansCJKsc-Regular.otf",
+    "NotoSansSC-Regular.otf", "SourceHanSansSC-Regular.otf", "NotoSerifCJK-Regular.ttc",
+    "wqy-zenhei.ttc",
+]
 FONT_EN = ["georgia.ttf", "times.ttf", "arial.ttf", "DejaVuSerif.ttf", "Helvetica.ttc"]
 
+# Any font on the box whose name looks CJK-capable is a valid last resort, which
+# is what makes this work on a distro whose naming we never anticipated.
+_CJK_NAME = re.compile(
+    r"(noto.{0,12}cjk|notosanssc|notoserifsc|sourcehan|wqy|droid.{0,8}fallback"
+    r"|msyh|simhei|simsun|pingfang|heiti|hiragino|uming|ukai)", re.IGNORECASE)
+_FONT_SUFFIXES = {".ttf", ".ttc", ".otf", ".otc"}
 
-def find_font(candidates: list[str], size: int) -> ImageFont.FreeTypeFont:
-    """Locate a usable font file across Windows, Linux, and macOS directories."""
-    search_dirs = [
-        Path(os.environ.get("WINDIR", "C:/Windows")) / "Fonts",
-        Path(os.environ.get("LOCALAPPDATA", "")) / "Microsoft" / "Windows" / "Fonts",
-        Path("/usr/share/fonts"),
-        Path("/usr/local/share/fonts"),
-        Path.home() / ".fonts",
-        Path.home() / ".local/share/fonts",
-        Path("/System/Library/Fonts"),
-        Path("/Library/Fonts"),
-    ]
-    for name in candidates:
-        for sdir in search_dirs:
-            if not sdir.exists():
+
+def _font_search_dirs() -> list[Path]:
+    """Font directories to scan, most specific first.
+
+    `TRIP_FONT_DIRS` (os.pathsep-separated) REPLACES the list when set: that is
+    the seam the selftest uses to isolate a Debian-like layout from whatever
+    fonts this machine happens to own. (A prepend would not isolate anything —
+    the machine's own CJK font would still win and hide the bug being tested.)
+    """
+    override = os.environ.get("TRIP_FONT_DIRS")
+    if override:
+        return [Path(p.strip()) for p in override.split(os.pathsep) if p.strip()]
+    dirs: list[Path] = []
+    win = os.environ.get("WINDIR") or "C:/Windows"
+    local = os.environ.get("LOCALAPPDATA")
+    dirs.append(Path(win) / "Fonts")
+    if local:
+        dirs.append(Path(local) / "Microsoft" / "Windows" / "Fonts")
+    dirs += [Path("/usr/share/fonts"), Path("/usr/local/share/fonts"),
+             Path.home() / ".fonts", Path.home() / ".local/share/fonts",
+             Path("/System/Library/Fonts"), Path("/Library/Fonts")]
+    return dirs
+
+
+@lru_cache(maxsize=8)
+def _font_index(dirs: tuple[str, ...]) -> dict[str, str]:
+    """name -> path for every font file under those dirs, searched RECURSIVELY.
+
+    Recursion is the whole point: Debian keeps Noto at
+    /usr/share/fonts/opentype/noto/..., so a one-level lookup finds nothing.
+    """
+    index: dict[str, str] = {}
+    for entry in dirs:
+        root = Path(entry)
+        try:
+            if not root.is_dir():
                 continue
-            p = sdir / name
-            if p.exists():
-                try:
-                    return ImageFont.truetype(str(p), size)
-                except OSError:
-                    continue
+            for path in root.rglob("*"):
+                if path.suffix.lower() in _FONT_SUFFIXES and path.is_file():
+                    index.setdefault(path.name, str(path))
+        except OSError:
+            continue
+    return index
+
+
+def _renders_cjk(font) -> bool:
+    """Does this font actually have CJK glyphs, or would it just draw tofu?
+
+    A font without CJK coverage maps every ideograph to the same .notdef box, so
+    two unrelated characters come out byte-identical. That is the check — the
+    same one that caught the Linux bug, kept here so it cannot come back.
+    """
+    def ink(text: str) -> bytes:
+        img = Image.new("L", (72, 72), 255)
+        ImageDraw.Draw(img).text((3, 3), text, font=font, fill=0)
+        return img.tobytes()
+
+    try:
+        return ink("朋") != ink("北")
+    except Exception:
+        return False
+
+
+def find_font(candidates: list[str], size: int) -> ImageFont.FreeTypeFont:
+    """Locate a usable font file across Windows, Linux, and macOS directories.
+
+    Prefers a font that can actually draw Chinese; falls back to a Latin face and
+    then to Pillow's own default (which has no CJK at all). The scanned dirs come
+    first and bare names are the last resort — bare names still cover setups our
+    scan cannot see (Windows' own font dir is on Pillow's search path, and
+    fontconfig-only Linux installs may hide faces behind aliases).
+
+    When `TRIP_FONT_DIRS` is set the search set is EXACTLY those directories and
+    no bare-name lookup happens, which is what lets the selftest reproduce a
+    Debian-like box instead of this machine's fonts.
+    """
+    override = bool(os.environ.get("TRIP_FONT_DIRS"))
+    dirs = tuple(str(d) for d in _font_search_dirs())
+    index = _font_index(dirs)
+    latin_fallback = None
+    # Any CJK-looking font present in the search set is a better answer than a
+    # Latin fallback, however the distro happens to name it.
+    names = list(candidates) + [n for n in index if _CJK_NAME.search(n)]
+
+    def consider(font):
+        nonlocal latin_fallback
+        if _renders_cjk(font):
+            return font
+        if latin_fallback is None:
+            latin_fallback = font
+        return None
+
+    for name in names:                                   # 1) the scanned dirs
+        path = index.get(name)
+        if not path:
+            continue
         try:
-            return ImageFont.truetype(name, size)
+            picked = consider(ImageFont.truetype(path, size))
         except OSError:
-            pass
+            continue
+        if picked is not None:
+            return picked
+
+    if not override:                                     # 2) Pillow's own search
+        for name in names:
+            try:
+                picked = consider(ImageFont.truetype(name, size))
+            except OSError:
+                continue
+            if picked is not None:
+                return picked
 
+    if latin_fallback is not None:                       # 3) no CJK anywhere
+        return latin_fallback
     for fallback in ["arial.ttf", "DejaVuSans.ttf"]:
+        path = index.get(fallback)
         try:
-            return ImageFont.truetype(fallback, size)
+            return ImageFont.truetype(path or fallback, size)
         except OSError:
             pass
     return ImageFont.load_default()

package/.agents/skills/trip-moments/scripts/selftest.py

@@ -2952,6 +2952,12 @@ def t_claw_grade_candidates_and_output_visibility():
     assert "inline=1" in html and "function saveUrl" in html, \
         "页面没有 fetch+blob 的保存路径（attachment 被浏览器拦时会静默失败）"
     assert "data.build" in html, "页面没有随服务端构建号自刷新的逻辑"
+    # 通道状态必须能被看见：旧的 #exec-bar 从六步重构起就一直是 display:none，
+    # 于是「ClawHive/OpenClaw 通道未就绪（为什么）」从来没显示过。现在同一行也
+    # 写进操作台（#claw-note），否则 OpenClaw WSL gateway 的“端点没开”提示
+    # 等于没写。
+    assert 'id="claw-note"' in html, "操作台没有通道状态行（未就绪/忙碌说明无处可显）"
+    assert '$("claw-note")' in html, "通道状态行没有被写入"
 
 
 def t_agent_model_grade_candidates():
@@ -3160,10 +3166,233 @@ def t_agent_model_grade_candidates():
         "agent 只把文案写在会话里时页面不说明"
 
 
+def t_tray_gateway_discovery():
+    """OpenClaw 桌面版（WSL）自己的 gateway 也要能被发现，而且要能区分
+    「没找到 gateway」与「找到了但端点没开」—— 后者才是用户实际踩到的状态。
+
+    2026-10-04 实机：用户的 OpenClaw 不是 ClawHive 内嵌的那个，而是 OpenClaw Tray
+    装的 WSL 发行版（OpenClawGateway），`openclaw gateway --port 18789`，
+    `auth.mode=token`，gateway URL 与共享令牌写在
+    %APPDATA%/OpenClawTray/gateways.json；WS 与 HTTP 同端口多路复用，
+    /health 活着但 /v1/models -> 404，因为 OpenAI 兼容端点默认关闭。
+    旧实现只看 ClawHive 的 gateway-port.json，于是把这种情况误报成“没找到”。
+
+    这里起真实 HTTP 假 gateway，把 gateways.json 指向它，走真实 discover()。
+    """
+    import http.server
+    import json as _json
+    import tempfile as _tf
+    import threading as _th
+    from pathlib import Path as _P
+
+    import clawbridge
+
+    state = {"models": 404, "hits": []}
+
+    class Fake(http.server.BaseHTTPRequestHandler):
+        def log_message(self, *a):
+            pass
+
+        def _send(self, code, payload):
+            body = _json.dumps(payload).encode("utf-8")
+            self.send_response(code)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def do_GET(self):
+            state["hits"].append((self.path,
+                                  (self.headers.get("Authorization") or "")))
+            if self.path == "/health":
+                return self._send(200, {"ok": True, "status": "live"})
+            if self.path == "/v1/models":
+                if state["models"] == 404:
+                    self.send_response(404)
+                    self.send_header("Content-Type", "text/plain")
+                    self.end_headers()
+                    self.wfile.write(b"Not Found")
+                    return
+                return self._send(200, {"data": [{"id": "openclaw/default"}]})
+            self._send(404, {"error": "nope"})
+
+    srv = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Fake)
+    port = srv.server_address[1]
+    _th.Thread(target=srv.serve_forever, daemon=True).start()
+
+    old_path = clawbridge._OPENCLAW_TRAY
+    old_cache = dict(clawbridge._CACHE)
+    with _tf.TemporaryDirectory() as tmp:
+        cfg = _P(tmp) / "gateways.json"
+        cfg.write_text(_json.dumps({"gateways": [
+            {"friendlyName": "Local (OpenClawGateway)",
+             "url": f"ws://127.0.0.1:{port}",
+             "sharedGatewayToken": "tok-abc",
+             "setupManagedDistroName": "OpenClawGateway"},
+            # 局域网/远程 gateway 不得被静默使用（照片只会发到本机 gateway）
+            {"friendlyName": "Office box", "url": "ws://192.168.1.5:18789",
+             "sharedGatewayToken": "tok-lan"},
+        ]}), encoding="utf-8")
+        clawbridge._OPENCLAW_TRAY = str(cfg)
+        clawbridge._CACHE.update({"at": 0.0, "info": None})
+        try:
+            found = clawbridge.tray_gateways()
+            assert [g["port"] for g in found] == [port], \
+                f"只应接受 loopback gateway，实际 {[g.get('base') for g in found]}"
+            assert found[0]["name"] == "Local (OpenClawGateway)", found[0]
+
+            # ① 端点没开：必须报「找到了但端点未启用」+ 具体的配置键，
+            #    而不是含糊的「没找到 gateway」；同时要带上是谁没就绪
+            clawbridge._CACHE.update({"at": 0.0, "info": None})
+            info = clawbridge.discover(force=True)
+            assert info["enabled"] is False, info
+            assert info["via"] == "openclaw-tray", info
+            assert info["port"] == port, info
+            assert "OpenClawGateway" in (info["name"] or ""), info
+            assert "chatCompletions" in info["why"], \
+                f"没说清要开哪个开关：{info['why']}"
+            assert "未找到" not in info["why"], info["why"]
+            # 探测必须带 Bearer 令牌：无鉴权探测在 token 模式下会被拒
+            assert any(h[0] == "/v1/models" and h[1] == "Bearer tok-abc"
+                       for h in state["hits"]), state["hits"]
+
+            # ② 端点开了：发现成功并列出 agent 目标
+            state["models"] = 200
+            clawbridge._CACHE.update({"at": 0.0, "info": None})
+            info2 = clawbridge.discover(force=True)
+            assert info2["enabled"] is True, info2
+            assert info2["agents"] == ["openclaw/default"], info2
+            assert clawbridge.pick_agent("") == "openclaw/default", clawbridge.pick_agent("")
+            st = clawbridge.status(True)
+            assert st["ready"] and st["via"] == "openclaw-tray" and st["name"], st
+            assert "tok-abc" not in _json.dumps(st), "status() 不能泄露令牌"
+
+            # ③ 端点没开时，status() 也要能报出「是谁没就绪」
+            state["models"] = 404
+            clawbridge._CACHE.update({"at": 0.0, "info": None})
+            st2 = clawbridge.status(True)
+            assert st2["ready"] is False and st2["via"] == "openclaw-tray", st2
+            assert st2["name"] and "OpenClawGateway" in st2["name"], st2
+            assert "chatCompletions" in st2["why"], st2["why"]
+        finally:
+            clawbridge._OPENCLAW_TRAY = old_path
+            clawbridge._CACHE.update(old_cache)
+            srv.shutdown()
+            srv.server_close()
+
+
+def t_font_selection_has_cjk():
+    """字体选择必须真的能画中文 —— 在服务器（Debian 布局）上曾经画成方块。
+
+    2026-10-04 在 python:3.11-slim 容器里实测：装不装 fonts-noto-cjk，「朋友圈旅行」
+    与「敦煌戈壁滩」都渲染成完全相同的位图（都是 .notdef 方块），因为
+    (a) /usr/share/fonts 只查了一层，而 Debian 把 Noto 放在 opentype/noto/ 下，
+    (b) 候选名单里写的是 NotoSansSC-*，Debian 只提供 NotoSansCJK-*。
+
+    本用例不依赖具体操作系统：用 TRIP_FONT_DIRS 造一个 Debian 式目录，看选择器能不能
+    递归找到它、并宁可选一个没列进名单但带中文的字体，也不返回列表更靠前却画不出中文的。
+    """
+    import shutil as _sh
+    import tempfile as _tf
+    from pathlib import Path as _P
+
+    import imquality as iq
+
+    dirs = tuple(str(d) for d in iq._font_search_dirs())
+    index = iq._font_index(dirs)
+    cjk_src = next((p for n, p in index.items() if iq._CJK_NAME.search(n)
+                    and iq._renders_cjk(iq.ImageFont.truetype(p, 32))), "")
+    latin_src = ""
+    for name in ("arial.ttf", "DejaVuSans.ttf", "georgia.ttf", "times.ttf", "Helvetica.ttc"):
+        path = index.get(name)
+        if not path:
+            continue
+        try:
+            font = iq.ImageFont.truetype(path, 32)
+        except OSError:
+            continue
+        if not iq._renders_cjk(font):
+            latin_src = path
+            break
+
+    # 反方向：缺字检测必须能认出“画不出中文”的字形 —— 用 Pillow 自带嵌入字体，
+    # 它没有 CJK 字形，且任何机器上都在（不让用例依赖本机凑巧装了某种拉丁字体）。
+    assert not iq._renders_cjk(iq.ImageFont.load_default()), \
+        "无 CJK 字形的字体被判为能画中文 —— 缺字检测失效，服务器上会静默画出方块"
+    if cjk_src:
+        assert iq._renders_cjk(iq.ImageFont.truetype(cjk_src, 32)), \
+            f"已知中文字体 {cjk_src} 被判为画不出中文"
+
+    if not cjk_src:
+        # 本机压根没装中文字体：反向判据已验，不再拿找不到的字体硬凑。
+        print("        (本机无中文字体，只验证了缺字检测不误报)")
+        return
+
+    old_env = os.environ.get("TRIP_FONT_DIRS")
+    with _tf.TemporaryDirectory() as tmp:
+        root = _P(tmp)
+        os.environ["TRIP_FONT_DIRS"] = str(root)
+        iq._font_index.cache_clear()
+        try:
+            # Debian 式布局：嵌套两层 + 名单外的名字，必须被递归找到并选中
+            (root / "opentype" / "noto").mkdir(parents=True)
+            wanted = root / "opentype" / "noto" / "NotoSansCJKjp-Light.ttc"
+            _sh.copyfile(cjk_src, wanted)
+            iq._font_index.cache_clear()
+            picked = iq.find_font(iq.FONT_ZH_BOLD, 32)
+            assert iq._renders_cjk(picked), \
+                f"递归目录里明明有中文字体，却选回了画不出中文的：{getattr(picked, 'path', picked)}"
+            assert str(getattr(picked, "path", "")).endswith("NotoSansCJKjp-Light.ttc"), \
+                ("应该选嵌套两层、名单外的那个中文字体（这才是「不靠硬编码名字」），"
+                 f"实际选了 {getattr(picked, 'path', picked)}")
+
+            # 像素级：两个不同汉字必须画出不同位图
+            def ink(text):
+                img = iq.Image.new("L", (80, 80), 255)
+                iq.ImageDraw.Draw(img).text((3, 3), text, font=picked, fill=0)
+                return img.tobytes()
+            assert ink("朋") != ink("北"), "两个不同汉字画出同一张图 —— 就是缺字方块"
+
+            # 搜索集里只有画不出中文的字体时，宁可降级也不能假装能画。
+            # 必须用一个全新的目录：刚才那个临时目录里已经放了中文字体。
+            if latin_src:
+                os.environ["TRIP_FONT_DIRS"] = str(root / "only-latin")
+                (root / "only-latin").mkdir()
+                _sh.copyfile(latin_src, root / "only-latin" / "latin-only.ttf")
+                iq._font_index.cache_clear()
+                only = iq.find_font(iq.FONT_ZH_BOLD, 32)
+                assert not iq._renders_cjk(only), \
+                    "搜索集里只有拉丁字体，却被报告为能画中文（选字逻辑在蒙）"
+            else:
+                print("        (本机无拉丁字体文件，略过“只有拉丁字体”的降级子用例)")
+        finally:
+            iq._font_index.cache_clear()
+            if old_env is None:
+                os.environ.pop("TRIP_FONT_DIRS", None)
+            else:
+                os.environ["TRIP_FONT_DIRS"] = old_env
+
+
+def t_linux_font_layout_declared():
+    """font 目录必须递归搜索：Debian 把 Noto 放在 opentype/noto/ 下。
+
+    这条不依赖机器上有没有中文字体，只查源码契约：搜素用 rglob 而不是直接拼一层；
+    候选名单里必须包含各发行版真实使用的 Noto CJK 文件名。
+    """
+    src = (Path(__file__).parent / "imquality.py").read_text(encoding="utf-8")
+    assert "rglob" in src, "字体目录退回单层扫描 —— Debian 的 opentype/noto/ 会找不到"
+    for name in ("NotoSansCJK-Bold.ttc", "NotoSansCJK-Regular.ttc", "NotoSansCJKsc-Regular.otf"):
+        assert name in src, f"候选名单缺少发行版实际使用的字体名：{name}"
+    assert "_renders_cjk" in src and "load_default" in src, "缺少「画不出中文就继续找」的判据"
+
+
 CASES = {
     "打包交付与下载(zip/预览/越权拦截)": t_finish_deliverables_and_download,
     "AI 结果可见性+三套候选(每步输出框/agent轨道)": t_claw_grade_candidates_and_output_visibility,
     "Agent自带模型轨道也给三档候选(预览/采用)": t_agent_model_grade_candidates,
+    "字体选择真的能画中文(递归+缺字检测)": t_font_selection_has_cjk,
+    "字体目录递归与发行版字体名": t_linux_font_layout_declared,
+    "OpenClaw WSL gateway 发现(端点未启用的诚实报告)": t_tray_gateway_discovery,
     "存活探测不误杀冷实例/代理环境": t_liveness_probe_is_cheap_and_proxy_safe,
     "审片页 STUDIO 链接跟随在跑实例": t_review_studio_link_follows_instance,
     "canon 命名归一化": t_canon,

package/.agents/skills/trip-moments/scripts/studio_ui.py

@@ -3098,21 +3098,52 @@ function syncExecutor() {
     b.classList.toggle("on", b.dataset.exec === cur);
     b.classList.toggle("agent", b.dataset.exec === "clawhive" && b.classList.contains("on"));
   });
-  const n = $("exec-note");
-  if (!n) return;
-  if (!st.ready) {
-    n.innerHTML = `ClawHive 通道未就绪（${H(st.why || "")}），现在只能用本地网关`;
-  } else if (cur === "local") {
-    n.innerHTML = "用工作台自己的视觉 API 看片出参数：快，但过程不会进入 ClawHive 会话";
-  } else if (st.busy) {
-    // A session serves one turn at a time: delegating into a conversation that
-    // is mid-turn cannot come back (it queues until a timeout). Say so BEFORE
-    // the click instead of letting the button look dead for seven minutes.
-    n.innerHTML = `<b>ClawHive 正在跑上一轮</b>，一个会话一次只做一件事：` +
-      `现在派回去只会排队到超时。等它空下来，或切到「本地」用本地网关做这一步。`;
-  } else {
-    const agent = (st.agents || []).find((a) => a.includes("main")) || (st.agents || [])[0] || "agent";
-    n.innerHTML = `<b>${H(agent)}</b> 会自己看照片、定参数、直接改工作台；它的回答会出现在你的 ClawHive 会话里`;
+  const n = $("exec-note");
+  if (!n) return;
+  // Two gateway families are discoverable now: ClawHive's embedded one and the
+  // OpenClaw desktop app's WSL-backed one. They differ in what the workbench can
+  // promise, so the note names the family instead of always saying "ClawHive".
+  const tray = st.via === "openclaw-tray";
+  const gwName = H(st.name || (tray ? "OpenClaw" : "ClawHive"));
+  let msg = "";
+  let warn = false;
+  if (st.hidden) {
+    // 「连接已隐藏」 is a user preference, not a fault: stay quiet instead of
+    // printing a not-ready warning at the top of every step.
+    msg = "";
+  } else if (!st.ready) {
+    msg = `${gwName} 通道未就绪（${H(st.why || "")}）`;
+    warn = true;
+  } else if (cur === "local") {
+    msg = `用工作台自己的视觉 API 看片出参数：快，但过程不会进入 ${tray ? "OpenClaw" : "ClawHive"} 会话`;
+  } else if (st.busy) {
+    // A session serves one turn at a time: delegating into a conversation that
+    // is mid-turn cannot come back (it queues until a timeout). Say so BEFORE
+    // the click instead of letting the button look dead for seven minutes.
+    msg = `<b>${gwName} 正在跑上一轮</b>，一个会话一次只做一件事：` +
+      `现在派回去只会排队到超时。等它空下来，或切到「本地」用本地网关做这一步。`;
+    warn = true;
+  } else if (tray) {
+    // The WSL gateway keeps its session book in SQLite inside the distro, which
+    // Windows cannot read (the wsl$ UNC paths are not reachable from here), so
+    // the workbench cannot target the conversation the user is looking at — and
+    // it cannot pre-detect a mid-turn session either. Promise less, be honest.
+    const agent = (st.agents || [])[0] || "openclaw/default";
+    msg = `<b>${H(agent)}</b> 会自己看照片、定参数、直接改工作台（OpenClaw WSL gateway）；` +
+      `会话由工作台自己建，无法绑定你正在看的那个。`;
+  } else {
+    const agent = (st.agents || []).find((a) => a.includes("main")) || (st.agents || [])[0] || "agent";
+    msg = `<b>${H(agent)}</b> 会自己看照片、定参数、直接改工作台；它的回答会出现在你的 ClawHive 会话里`;
+  }
+  n.innerHTML = msg;
+  // The bar holding #exec-note has been display:none since the six-step rewrite,
+  // so everything above was invisible in practice — including 「通道未就绪」.
+  // The deck is where the user actually looks, so the same line goes there.
+  const deckNote = $("claw-note");
+  if (deckNote) {
+    deckNote.innerHTML = msg;
+    deckNote.style.display = msg ? "" : "none";
+    deckNote.style.color = warn ? "#8a3b2f" : "";
   }
   const btnSel = $("btn-reselect9");
   const hintSel = $("reselect9-hint");

package/bin/install.js

@@ -16,7 +16,7 @@ const path = require('path');
 const os = require('os');
 const { execSync, spawnSync } = require('child_process');
 
-const VERSION = '1.2.0';
+const VERSION = '1.3.1';
 const SKILL_NAME = 'trip-moments';
 
 const c = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trip-moments-skill",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "AI 朋友圈旅行出图助手 (trip-moments skill) — 工业级全流程旅行摄影智能出图与朋友圈九宫格套件",
   "main": "bin/install.js",
   "bin": {