trip-moments-skill 1.1.0 → 1.1.2

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

@@ -8,7 +8,8 @@ import time
 import uuid
 from pathlib import Path
 
-from agent_transport import AgentError, CodexTransport, HermesTransport, local_url
+from agent_transport import (AgentError, CodexTransport, HermesTransport,
+                             OpenClawTransport, local_url)
 
 ACTIVE = {"starting", "running", "waiting_for_approval", "waiting_for_input", "stopping", "reconnecting"}
 
@@ -79,17 +80,22 @@ class AgentSession:
             if self.status in ACTIVE:
                 raise AgentError("请先结束当前运行，再更换 Agent 连接")
             provider = str(body.get("provider") or self.config.get("provider") or "hermes")
-            if provider not in {"hermes", "codex"}:
-                raise AgentError("请选择 Hermes 或 Codex App Server")
+            if provider not in {"hermes", "codex", "openclaw"}:
+                raise AgentError("请选择 Hermes、Codex 或 OpenClaw")
             base = local_url(body.get("base_url") or self.config.get("base_url") or "http://127.0.0.1:8642")
             key = str(body.get("key") or "").strip()
             if not key and self.token_path.is_file():
                 key = self.token_path.read_text(encoding="utf-8").strip()
-            client = HermesTransport(base, key) if provider == "hermes" else CodexTransport(self.ws.photos_dir)
+            if provider == "hermes":
+                client = HermesTransport(base, key)
+            elif provider == "codex":
+                client = CodexTransport(self.ws.photos_dir)
+            else:
+                client = OpenClawTransport(self.ws.photos_dir)
             try:
                 result = client.probe()
                 old = self.config
-                sid = old.get("session_id", "") if old.get("provider") == provider and (provider == "codex" or old.get("base_url") == base) else ""
+                sid = old.get("session_id", "") if old.get("provider") == provider and (provider in {"codex", "openclaw"} or old.get("base_url") == base) else ""
                 if sid:
                     if provider == "codex" and not old.get("owned"):
                         raise AgentError("不能接管其他 Codex 桌面任务，请创建工作台专用会话")
@@ -128,6 +134,10 @@ class AgentSession:
             if create:
                 title = str(body.get("title") or "Trip Moments · " + self.ws.photos_dir.name)[:100]
                 sid = self.client.create(title, self.ws.photos_dir)
+                if self.config.get("provider") == "openclaw" and not sid:
+                    # No session-creation endpoint: bind to the conversation
+                    # the user currently has open in ClawHive instead.
+                    sid = self.client.bind("")
             else:
                 if not sid:
                     raise AgentError("请明确选择一个会话")

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

@@ -341,3 +341,118 @@ class CodexTransport:
             self.process.wait(timeout=8)
         except (OSError, subprocess.TimeoutExpired):
             self.process.terminate()
+
+# ---------------------------------------------------------------------------
+# OpenClaw (ClawHive) — the desktop agent's OpenAI-compatible endpoint.
+# Reuses clawbridge discovery; NEVER imports it here (clawbridge imports stay
+# local so transports remain importable without ClawHive installed).
+# ---------------------------------------------------------------------------
+
+
+def _claw_module():
+    import clawbridge
+    return clawbridge
+
+
+class OpenClawTransport:
+    """Persistent-session transport over ClawHive's chat-completions endpoint.
+
+    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
+    start/status/events so AgentSession keeps a single code path — events
+    replays the single reply, and status walks the turn to completion.
+    Approvals/steer do not exist on this endpoint; the whole turn is the
+    agent's own.
+    """
+
+    provider = "openclaw"
+
+    def __init__(self, cwd=""):
+        self.claw = _claw_module()
+        self.lock = threading.RLock()
+        self._thread = []          # [(role, text)] replayed as history
+        self._done = threading.Event()
+        self._events_queue = queue.Queue()
+
+    # -- connection ---------------------------------------------------------
+    def probe(self):
+        info = self.claw.discover(force=True)
+        if not info.get("base"):
+            raise AgentError("未找到运行中的 ClawHive gateway：" + (info.get("why") or ""))
+        if not info.get("enabled"):
+            raise AgentError("ClawHive 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 []}
+
+    def sessions(self):
+        # The desktop conversation list belongs to ClawHive'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).
+        return ""
+
+    def bind(self, sid):
+        key = sid or self.claw.active_session()
+        if not key:
+            raise AgentError("没有找到正在使用的 ClawHive 会话；先在 ClawHive 里打开一个对话")
+        return key
+
+    # -- turns ---------------------------------------------------------------
+    def start(self, sid, text, key):
+        # One request == one whole turn. Run it on this thread and let
+        # AgentSession's status() poll see "running" until _done is set.
+        agent = self.claw._agent_dir_name(self.claw.pick_agent(""))
+        session_key = self.claw.active_session(agent) if not sid else sid
+        if self.claw.session_busy(session_key, agent):
+            raise self.claw.ClawBridgeBusy(self.claw.BUSY_HINT)
+        self._done.clear()
+        threading.Thread(target=self._turn, args=(agent, session_key, text),
+                         daemon=True).start()
+        return session_key or "openclaw"
+
+    def _turn(self, agent, session_key, text):
+        try:
+            out = self.claw.ask(text, agent=agent, session_key=session_key,
+                                timeout=420)
+            self._reply = out.get("text") or ""
+            self.emit({"type": "assistant.message", "text": self._reply})
+            self.emit({"type": "run.completed", "output": self._reply})
+        except Exception as exc:  # noqa: BLE001 - surfaced verbatim in the UI
+            msg = str(exc)[:400]
+            self.emit({"type": "run.failed", "error": msg})
+        finally:
+            self._done.set()
+
+    def status(self, rid):
+        with self.lock:
+            finished = self._done.is_set()
+        return {"status": "completed" if finished else "running"}
+
+    def events(self, rid, emit):
+        # ClawBridgeBusy must surface, not loop: AgentError propagates like the
+        # other transports; the gateway lane check already refused in start().
+        while True:
+            evt = self._events_queue.get(timeout=30)
+            if evt is None:
+                if not self._done.is_set():
+                    continue
+                return
+            emit(evt)
+            if evt.get("type") in {"run.completed", "run.failed", "run.cancelled",
+                                   "run.interrupted"}:
+                return
+
+    def emit(self, event):
+        self._events_queue.put(event)
+
+    # -- not supported by the endpoint ---------------------------------------
+    def control(self, sid, rid, action, body):
+        raise AgentError("OpenClaw 通道不支持该操作（整轮执行，无可中断/批准的中间态）")
+
+    def close(self):
+        self._done.set()
+        self._events_queue.put(None)

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

@@ -50,7 +50,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></select>
+    <option value="hermes">Hermes · 原生持续会话</option><option value="codex">Codex App Server · 工作台专用会话</option><option value="openclaw">OpenClaw (ClawHive) · 活跃会话直连</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>
@@ -223,12 +223,15 @@ function openAgentPanel() {
 }
 function closeAgentPanel() { AP.open = false; $("agent-panel").hidden = true; }
 function agentProviderHint() {
-  const hermes = $("ap-kind").value !== "codex";
+  const kind = $("ap-kind").value;
+  const hermes = kind === "hermes";
   $("ap-hermes-fields").style.display = hermes ? "" : "none";
   $("ap-existing").style.display = hermes ? "" : "none";
   $("ap-hint").textContent = hermes
     ? "绑定 Hermes 原生会话，后续回复与步骤按钮都延续该会话。连接密钥仅由本机服务使用。"
-    : "使用本机已登录的 Codex CLI，创建工作台专用的持续任务；不接管你当前 Codex 桌面聊天。工具批准仍需你确认。";
+    : kind === "codex"
+    ? "使用本机已登录的 Codex CLI，创建工作台专用的持续任务；不接管你当前 Codex 桌面聊天。工具批准仍需你确认。"
+    : "直连 ClawHive 内嵌的 OpenClaw gateway，绑定你正在看的那个会话；整轮执行，无中间批准。需在 openclaw.json 启用 chatCompletions 端点。";
 }
 async function pollAgent() {
   if (AP.polling) return;
@@ -256,7 +259,8 @@ function paintAgent(data) {
     starting:"正在发起本轮", running:"Agent 正在处理这一轮", waiting_for_approval:"等待你批准当前工具操作",
     waiting_for_input:"Agent 有问题需要你回答", stopping:"正在停止，尚未确认结束",
     reconnecting:"事件连接中断，正在核对真实运行状态", stopped:"本轮已停止", failed:"本轮失败，可继续在同一会话说明要求" };
-  const provider = data.provider === "codex" ? "Codex App Server" : "Hermes";
+  const provider = data.provider === "codex" ? "Codex App Server"
+    : data.provider === "openclaw" ? "OpenClaw (ClawHive)" : "Hermes";
   $("ap-provider").textContent = provider + " · 连接与会话绑定";
   $("ap-session").textContent = data.session_id ? "绑定会话：" + data.session_id : "尚未绑定会话";
   $("ap-status").textContent = (states[data.status] || data.status) + (data.error ? " · " + data.error : "");

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

@@ -591,13 +591,22 @@ def _studio_instruction_impl(action: str, ctx: dict, state: dict, base: str = ""
                 "   （也可逐格调用 POST /api/framing；ratio 为 null 表示保留原图）\n"
                 "4. 只回几行：列出你把哪几格定成了什么画幅、保留了哪几格原图。")
 
-    if action == "caption":
-        return (head + "\n请做：为这组九宫格写朋友圈文案。\n"
-                + _slot_lines(slots) + "\n\n"
-                "写 3 版不同语气（文艺诗意 / 纪实行记 / 松弛日常），每版 1-3 句、可直接发。\n"
-                "**只写画面里真实存在的东西**；括号里是选片时的标注，必要时核图确认。"
-                "如果哪几张的标注和画面不符，在最后用一行提醒我。\n"
-                "不要写文件，直接在这个会话里给出三版。")
+    if action == "caption":
+        return (head + "\n请做：为这组九宫格写朋友圈文案。\n"
+                + _slot_lines(slots) + "\n\n"
+                "写 3 版不同语气（文艺诗意 / 纪实行记 / 松弛日常），每版 1-3 句、可直接发。\n"
+                "**只写画面里真实存在的东西**；括号里是选片时的标注，必要时核图确认。"
+                "如果哪几张的标注和画面不符，在最后用一行提醒我。\n"
+                "写好后**必须登记到工作台**：只说在会话里不算完成，用户在工作台文案面板上"
+                "会一直看到「还没有文案」，打包时也拿不到：\n"
+                f"   POST {base}/api/caption\n"
+                '   {"narrative": "一句话叙事线（可留空）",\n'
+                '    "versions": [{"style": "文艺诗意", "text": "…"},\n'
+                '                 {"style": "纪实行记", "text": "…"},\n'
+                '                 {"style": "松弛日常", "text": "…"}],\n'
+                '    "tags": ["可选标签"]}\n'
+                "（versions 至少一版；登记后工作台会立即显示并可逐版复制）\n"
+                "最后只回一两句：三版各是什么语气。不要复述全文，用户在工作台上就能看到。")
 
     if action == "title":
         return (head + f"\n请做：给第 {slot_no} 格拟标题。\n"

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

@@ -1687,6 +1687,130 @@ def t_claw_discovery_routing():
         httpd.server_close()
 
 
+def t_openclaw_transport_channel():
+    """第三条 Agent 通道 OpenClaw (ClawHive)：transport 契约真实 HTTP 验证。
+
+    连接 = 发现 gateway + /v1/models 端点开启；绑定 = ClawHive 当前活跃会话；
+    start = 整轮 chat-completions（后台线程），events 重放回复并以 run.completed
+    收尾；忙会话在 start 即拒绝（不排队到超时）；控制操作（批准/steer）不支持。
+    """
+    import threading
+    import time as _time
+    from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+    import agent_transport
+    import clawbridge
+
+    class FakeGw(BaseHTTPRequestHandler):
+        hits = {"models": 0, "chat": 0}
+        timeout = 10
+
+        def log_message(self, *a):
+            pass
+
+        def _json(self, obj, code=200):
+            body = json.dumps(obj).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):
+            if self.path == "/health":
+                self._json({"ok": True})
+            elif self.path == "/v1/models":
+                FakeGw.hits["models"] += 1
+                self._json({"data": [{"id": "openclaw/main"}]})
+            else:
+                self._json({}, 404)
+
+        def do_POST(self):
+            FakeGw.hits["chat"] += 1
+            length = int(self.headers.get("Content-Length") or 0)
+            payload = json.loads(self.rfile.read(length) or b"{}")
+            FakeGw.payload = payload
+            FakeGw.headers_in = dict(self.headers)
+            self._json({"choices": [{"message": {"content": "已把第 3 格调色。"}}],
+                        "model": "openclaw/main", "usage": {"total_tokens": 7}})
+
+    httpd = ThreadingHTTPServer(("127.0.0.1", 0), FakeGw)
+    gw_port = httpd.server_address[1]
+    threading.Thread(target=httpd.serve_forever, daemon=True).start()
+    try:
+        import requests as _rq_wait
+        for _ in range(60):
+            try:
+                if _rq_wait.get(f"http://127.0.0.1:{gw_port}/health",
+                                timeout=1).status_code == 200:
+                    break
+            except Exception:
+                pass
+            _time.sleep(0.05)
+        with tempfile.TemporaryDirectory() as td:
+            state = Path(td) / "openclaw" / "state"
+            state.mkdir(parents=True)
+            (state / "gateway-port.json").write_text(json.dumps({"port": gw_port}), encoding="utf-8")
+            (state / "gateway-token").write_text("tok-oc", encoding="utf-8")
+            sess = state / "agents" / "main" / "sessions"
+            sess.mkdir(parents=True)
+            (sess / "sessions.json").write_text(json.dumps({
+                "agent:main:clawhive:live": {"lastInteractionAt": 999, "status": "done",
+                                              "sessionId": "live"},
+            }), encoding="utf-8")
+
+            real_globs = clawbridge._STATE_GLOBS
+            clawbridge._STATE_GLOBS = [str(state)]
+            clawbridge._CACHE.update({"at": 0.0, "info": None})
+            try:
+                client = agent_transport.OpenClawTransport("")
+                # 1) probe：端点开启才算就绪
+                caps = client.probe()
+                assert caps["ready"] and caps["provider"] == "openclaw", caps
+                assert "openclaw/main" in caps["agents"], caps
+                # 2) bind：取最近活跃会话；无活跃会话必须报错而不是静默空绑定
+                assert client.bind("") == "agent:main:clawhive:live"
+                # 3) start：整轮执行，回复经 events 回放，run.completed 收尾
+                events = []
+                rid = client.start("agent:main:clawhive:live", "请调色", "k1")
+                client.events(rid, events.append)
+                types = [e.get("type") for e in events]
+                assert "assistant.message" in types and types[-1] == "run.completed", types
+                reply = next(e["text"] for e in events if e.get("type") == "assistant.message")
+                assert reply == "已把第 3 格调色。", reply
+                assert FakeGw.payload["model"] == "openclaw/main", FakeGw.payload
+                # HTTP header names are case-insensitive; urllib3 normalizes
+                # x-openclaw-session-key -> X-Openclaw-Session-Key on the wire.
+                hdrs = {k.lower(): v for k, v in FakeGw.headers_in.items()}
+                assert hdrs.get("x-openclaw-session-key") == "agent:main:clawhive:live", hdrs
+                # 4) 控制操作不支持：整轮执行没有中间态可批准/中断
+                try:
+                    client.control("s", "r", "approve", {"request_id": "x"})
+                    raise AssertionError("approve 不应被支持")
+                except agent_transport.AgentError:
+                    pass
+                client.close()
+            finally:
+                clawbridge._STATE_GLOBS = real_globs
+                clawbridge._CACHE.update({"at": 0.0, "info": None})
+
+            # 5) 白名单：connect 接受 openclaw、拒绝未知 provider
+            import agent_session as _as
+            src = Path(_as.__file__).read_text(encoding="utf-8")
+            assert '"openclaw"' in src and "OpenClawTransport" in src, \
+                "agent_session 未接入 openclaw 通道"
+
+            # 6) UI：下拉必须有第三项，提示文案不泄露密钥
+            import agent_ui as _aui
+            ui = _aui.AGENT_SHELL + _aui.AGENT_SCRIPT
+            assert 'value="openclaw"' in ui, "Agent 通道下拉缺 OpenClaw 选项"
+            assert "OpenClaw (ClawHive)" in ui, "OpenClaw 显示名缺失"
+            assert 'data.provider === "openclaw"' in ui, "provider 显示名分支缺失"
+    finally:
+        httpd.shutdown()
+        httpd.server_close()
+
+
 def t_claw_busy_guard():
     """忙着的会话不能被派活：必须毫秒级拒绝，而不是排队到超时。
 
@@ -2805,9 +2929,216 @@ def t_claw_grade_candidates_and_output_visibility():
     assert "data.build" in html, "页面没有随服务端构建号自刷新的逻辑"
 
 
+def t_agent_model_grade_candidates():
+    """Agent 自带模型轨道：每一步的结果都要落到工作台上，不能只在会话里说。
+
+    2026-10-04 用户实测两处空白：
+      a) 挂着 Agent 会话点「生成调色方案」，页面既没有 克制/标准/浓郁 三行，也没有每行的
+         预览/采用 按钮。三处协同缺口：简报把「工作台会自动生成三套候选」改写掉了、
+         agent_turn 的 work() 不像 clawhive 轨道那样从落地的配方推导候选、前端又在
+         useAgentModel() 下把候选面板整个隐藏。
+      b) 点「生成 3 版文案」后，文案面板仍然回「还没有文案」——因为 Agent 根本没有能
+         登记文案的接口（选片/裁切/调色/修图/出片都有，只有文案没有）。
+
+    这里用真实 HTTP 跑 /api/agent/send，会话的 run() 换成「通过工作台自己的接口落地结果」
+    ——真实 agent 就是这么做的——然后断言：三档候选真的随任务结果回到页面；Agent 只说不
+    做时不拿旧配方冒充本轮方案；文案登记后 state 真的带得回来、空数组会被拒。
+    """
+    import tempfile as _tf
+    import threading
+    import time as _time
+    import urllib.error
+    import urllib.request
+    from pathlib import Path as _P
+
+    import agent_session
+    import clawbridge
+    import studio
+    import studio_ui
+
+    missing = object()
+    real_run = agent_session.AgentSession.run
+    old_ws = getattr(studio.StudioHandler, "ws", missing)
+    old_jobs = getattr(studio.StudioHandler, "jobs", missing)
+    old_started = getattr(studio.StudioHandler, "started", None)
+    box = {}
+
+    def post(path, payload):
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{box['port']}{path}",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=30) as r:
+            return r.status, json.loads(r.read())
+
+    def fake_run(self, message, progress=None, cancelled=None):
+        # A real agent on this track lands its result through the workbench's own
+        # endpoint, so everything downstream must be derived from APPLIED state.
+        mode = box.get("mode")
+        text = "这一轮我没动工作台。"
+        if mode == "grade":
+            status, _ = post("/api/grade", {"slot": 5, "preset": "cine",
+                                             "grade": {"exposure": 0.2, "highlights": -20,
+                                                       "shadows": 15, "dehaze": 12}})
+            assert status == 200, f"agent 落地配方失败: HTTP {status}"
+            text = "第 5 格我上了电影青橙。"
+        elif mode == "caption":
+            status, _ = post("/api/caption", {
+                "narrative": "沿着海岸线走了一天",
+                "versions": [{"style": "文艺诗意", "text": "潮声比人声多"},
+                             {"style": "纪实行记", "text": "今天走了两万步"},
+                             {"style": "松弛日常", "text": "风大，头发乱"}],
+                "tags": ["海边"]})
+            assert status == 200, f"agent 登记文案失败: HTTP {status}"
+            text = "三版写好了，已登记到工作台。"
+        # Mirror how the real run() ends: the terminal event is what takes the
+        # session out of ACTIVE, so the next turn is allowed to start.
+        self.live_text = text
+        self.emit({"type": "run.completed", "output": text})
+        return {"ok": True, "provider": self.config.get("provider", "openclaw"),
+                "session_id": self.config.get("session_id", ""), "run_id": "run-1",
+                "text": text}
+
+    with _tf.TemporaryDirectory() as tmp:
+        tmp = _P(tmp)
+        photos, out = tmp / "photos", tmp / "out"
+        photos.mkdir()
+        out.mkdir()
+        ws = studio.Workspace(photos, out)
+        Image.new("RGB", (900, 1200), (70, 100, 130)).save(photos / "p1.jpg", quality=92)
+        ws.slots["5"] = {"source": "p1.jpg", "ratio": None, "anchor": [0.5, 0.5],
+                         "grade": {}, "preset": "none", "history": []}
+        ws.extra["agent_connection"] = {"provider": "openclaw",
+                                        "base_url": "http://127.0.0.1:42000",
+                                        "session_id": "sess-1", "owned": True}
+        ws.save()
+        link = agent_session.AgentSession(ws)
+        link.ready, link.status = True, "awaiting_user"
+        link.client = type("DummyClient", (), {"provider": "openclaw",
+                                              "close": lambda self: None})()
+        ws.agent_session = link
+
+        agent_session.AgentSession.run = fake_run
+        studio.StudioHandler.ws = ws
+        studio.StudioHandler.jobs = studio.JobQueue(workers=1)
+        studio.StudioHandler.started = _time.time()
+        httpd = studio.StudioServer(("127.0.0.1", 0), studio.StudioHandler)
+        port = httpd.server_address[1]
+        box["port"] = port
+        threading.Thread(target=httpd.serve_forever, daemon=True).start()
+        try:
+            def send_turn(step="grade", operation="grade_plan"):
+                req = urllib.request.Request(
+                    f"http://127.0.0.1:{port}/api/agent/send",
+                    data=json.dumps({"step": step, "action": "work_step",
+                                     "operation": operation, "slot": 5,
+                                     "message": "请用你自己的模型处理这一步"}).encode("utf-8"),
+                    headers={"Content-Type": "application/json"}, method="POST")
+                with urllib.request.urlopen(req, timeout=60) as r:
+                    assert r.status == 202, f"Agent 回合没进任务队列: HTTP {r.status}"
+                    return json.loads(r.read())["job"]["id"]
+
+            def wait_job(jid):
+                for _ in range(150):
+                    with urllib.request.urlopen(f"http://127.0.0.1:{port}/api/jobs", timeout=30) as r:
+                        jobs = json.loads(r.read())["jobs"]
+                    job = next((j for j in jobs if j["id"] == jid), None)
+                    if job and job["status"] in ("done", "failed"):
+                        return job
+                    _time.sleep(0.1)
+                raise AssertionError(f"agent_turn 没跑完: {jid}")
+
+            # ① agent 通过工作台接口落了配方 -> 必须带三档候选
+            box["mode"] = "grade"
+            job = wait_job(send_turn())
+            assert job["status"] == "done", f"agent 回合失败: {job.get('error') or job}"
+            res = (job.get("result") or {}).get("result") or {}
+            cands = res.get("candidates") or []
+            labels = [c.get("label") for c in cands]
+            assert len(cands) == 3, f"Agent 自带模型轨道没给出三套候选: {sorted(res)}"
+            assert "克制" in labels and "浓郁" in labels, f"候选档位不对: {labels}"
+            plan = next(c for c in cands if c["key"] == "plan")
+            soft = next(c for c in cands if c["key"] == "soft")
+            assert int(plan["params"]["highlights"]) == -20, plan["params"]
+            assert abs(float(soft["params"]["highlights"]) - round(-20 * 0.55)) < 1.01, \
+                f"克制档不是按落地参数派生的: {soft['params']}"
+            assert res.get("slot") == 5, "候选没带上是哪一格"
+            assert (res.get("text") or ""), "agent 的话也要在同一个结果里"
+
+            # ② 一轮什么都不改的 agent -> 不得拿旧配方冒充本轮方案
+            box["mode"] = "none"
+            job2 = wait_job(send_turn())
+            res2 = (job2.get("result") or {}).get("result") or {}
+            assert not (res2.get("candidates") or []), \
+                "agent 没动工作台却给了候选（旧配方被冒充成本轮方案）"
+
+            # ③ 文案：agent 登记后必须进 workspace（能刷新回来、算作本步已完成）
+            box["mode"] = "caption"
+            job3 = wait_job(send_turn(step="caption", operation="caption"))
+            assert job3["status"] == "done", f"文案回合失败: {job3.get('error') or job3}"
+            with urllib.request.urlopen(f"http://127.0.0.1:{port}/api/state", timeout=30) as r:
+                state = json.loads(r.read())
+            caps = (state.get("captions") or {}).get("versions") or []
+            assert len(caps) == 3, f"agent 登记的文案没进 workspace: {state.get('captions')}"
+            assert caps[0]["style"] == "文艺诗意" and caps[0]["text"], caps
+            assert (state.get("captions") or {}).get("narrative") == "沿着海岸线走了一天"
+
+            # ④ 空文案必须被拒：不能把「没写」当成「已登记」
+            try:
+                post("/api/caption", {"versions": []})
+                raise AssertionError("空 versions 不应被接受")
+            except urllib.error.HTTPError as exc:
+                assert exc.code == 400, f"空文案应回 400，实际 {exc.code}"
+            try:
+                post("/api/caption", {"versions": ["   "]})
+                raise AssertionError("全空白文案不应被接受")
+            except urllib.error.HTTPError as exc:
+                assert exc.code == 400, f"全空白文案应回 400，实际 {exc.code}"
+
+            # ⑤ 简报必须告诉 agent 登记哪个接口，否则它只会写在会话里
+            brief = clawbridge.studio_instruction(
+                "caption", {"slots": [1]}, state, f"http://127.0.0.1:{port}")
+            assert "/api/caption" in brief, "文案简报没给出登记接口"
+            assert "POST" in brief and "versions" in brief, "文案简报没有可照抄的请求体"
+        finally:
+            agent_session.AgentSession.run = real_run
+            httpd.shutdown()
+            httpd.server_close()
+            for attr, old in (("ws", old_ws), ("jobs", old_jobs)):
+                if old is missing:
+                    try:
+                        delattr(studio.StudioHandler, attr)
+                    except AttributeError:
+                        pass
+                else:
+                    setattr(studio.StudioHandler, attr, old)
+            if old_started is not None:
+                studio.StudioHandler.started = old_started
+
+    # 前端：候选面板不再按模型来源隐藏，且 agent_turn 完成后真的把候选交给页面
+    js = studio_ui.STUDIO_HTML
+    cand_line = next((l for l in js.splitlines() if "S.aiCandidateSlot === S.sel" in l), "")
+    assert cand_line and "useAgentModel" not in cand_line, \
+        "候选面板仍在 useAgentModel() 下被隐藏（Agent 自带模型轨道看不到三档）"
+    idx = js.index('if (j.kind === "agent_turn")')
+    branch = js[idx:js.index("return;", idx) + 400]
+    assert "S.aiCandidates" in branch, \
+        "agent_turn 完成后没把三档候选交给页面（用户看不到 预览/采用）"
+    assert "renderInspector()" in branch, "agent_turn 完成后没有重画本步面板"
+    assert "没产出可选的调色方案" in branch, \
+        "agent 只说不做时页面又保持沉默（用户分不清是 bug 还是没改动）"
+    assert "S.aiCandidates = null" in branch, \
+        "agent 没落地配方时没有清掉上一轮的候选（旧方案会被当成本轮产物）"
+    assert "akind === \"caption\"" in branch, \
+        "agent_turn 完成后没有处理文案（面板又会一直回「还没有文案」）"
+    assert "没把文案登记到工作台" in branch, \
+        "agent 只把文案写在会话里时页面不说明"
+
+
 CASES = {
     "打包交付与下载(zip/预览/越权拦截)": t_finish_deliverables_and_download,
     "AI 结果可见性+三套候选(每步输出框/agent轨道)": t_claw_grade_candidates_and_output_visibility,
+    "Agent自带模型轨道也给三档候选(预览/采用)": t_agent_model_grade_candidates,
     "存活探测不误杀冷实例/代理环境": t_liveness_probe_is_cheap_and_proxy_safe,
     "审片页 STUDIO 链接跟随在跑实例": t_review_studio_link_follows_instance,
     "canon 命名归一化": t_canon,
@@ -2850,6 +3181,7 @@ CASES = {
     "换位元数据随照片走+预览缓存源版本": t_swap_metadata_and_preview_cache,
     "任务队列并发上限+修订号+过期保护": t_jobqueue_and_revision,
     "ClawHive 发现与会话路由(多tenant/TTL/会话模式)": t_claw_discovery_routing,
+    "OpenClaw第三通道(probe/绑定活跃会话/整轮回放/无中间态)": t_openclaw_transport_channel,
     "忙会话拒派活(409/不排队/陈旧锁放行)": t_claw_busy_guard,
     "ClawHive 结果如实报告+用户意图入简报": t_claw_applies_once_and_intent,
     "选片标准与评分健壮性(偏好/严格解析/锚点)": t_select9_curation_robustness,

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

@@ -2146,7 +2146,8 @@ class StudioHandler(BaseHTTPRequestHandler):
                 "/api/reset": self._api_reset,
                 "/api/undo": self._api_undo,
                 "/api/edit-source": self._api_edit_source,
-                "/api/edit-result": self._api_edit_result,
+                "/api/edit-result": self._api_edit_result,
+                "/api/caption": self._api_caption,
                 "/api/edit-scan": self._api_edit_scan,
                 "/api/art": self._api_art,
                 "/api/art-preview": self._api_art_preview,
@@ -2172,8 +2173,8 @@ class StudioHandler(BaseHTTPRequestHandler):
             if fn is None:
                 self.send_json({"ok": False, "error": f"未知接口 {path}"}, 404)
                 return
-            if path in {"/api/framing", "/api/grade", "/api/swap", "/api/replace",
-                        "/api/reset", "/api/undo", "/api/edit-source"}:
+            if path in {"/api/framing", "/api/grade", "/api/swap", "/api/replace",
+                        "/api/reset", "/api/undo", "/api/edit-source", "/api/caption"}:
                 # Snapshot + mutation + render must be atomic even when an
                 # agent and a browser edit the same workspace concurrently.
                 with self.ws._lock:
@@ -2301,10 +2302,11 @@ class StudioHandler(BaseHTTPRequestHandler):
                         ctx["built"] = artposter.build(str(src), style, opts, use_vision=False)
                         ctx["photo_full"] = str(src)
                         ctx["dst"] = str(self.ws.outdir / "art" / f"art_{artposter.STYLES[style]['suffix']}_{slot:02d}_{src.stem}.jpg")
+                    # The brief KEEPS the workbench's promise of 克制/标准/浓郁
+                    # variants: this track now derives them from the recipe the
+                    # agent actually applied (see the grade branch in work()
+                    # below), so the sentence the agent reads is true here too.
                     contract = clawbridge.studio_instruction(operation, ctx, snapshot, base).replace("ClawHive", "已连接的 Agent")
-                    contract = contract.replace(
-                        "工作台会自动基于你的配方生成克制/标准/浓郁三套候选供用户微调。",
-                        "请说明实际应用的配方与理由，等待用户在本步反馈区继续确认。")
                     context += contract + "\n"
                 if operation in {"art", "finish"} and body.get("no_text", self.ws.extra.get("no_text", False)) is True:
                     context += "本次出片不新增任何文字：不要标题、字幕、日期、页码、署名、水印或装饰字；原照片原有文字不擦除。\n"
@@ -2320,6 +2322,23 @@ class StudioHandler(BaseHTTPRequestHandler):
                 result = link.run(outbound, lambda text, pct: (setattr(job, "detail", text), setattr(job, "progress", pct)),
                                   cancelled=lambda: job.cancelled)
                 changed = slot_changes({str(s["slot"]): s for s in snapshot["slots"]}, self.ws.state())
+                # 三套候选 also on the agent-model track. The brief the agent just
+                # read promises 克制/标准/浓郁, and this track used to drop that
+                # promise in two places at once (the sentence was rewritten out of
+                # the brief AND the chooser was hidden in the page), leaving the
+                # user with one opaque recipe they never got to choose. Derive the
+                # three from the params the agent really applied — only when it
+                # changed a slot this turn, so a stale recipe from an earlier edit
+                # is never dressed up as this turn's plan.
+                if operation in ("grade_plan", "grade_all") and changed:
+                    n = slot if slot in changed else changed[0]
+                    cur = self.ws.slots.get(str(n)) or {}
+                    params = grade.normalize(cur.get("grade") or {})
+                    if any(abs(float(v or 0)) > 1e-9 for v in params.values()):
+                        result["candidates"] = grade.candidates(
+                            {"params": params, "preset": cur.get("preset") or None})
+                        result["slot"] = n
+                        result["summary"] = self.ws.grade_summary(cur)
                 return {"ok": result["ok"], "result": result, "changed_slots": changed,
                         "applied": bool(changed)}
             try:
@@ -2930,6 +2949,41 @@ class StudioHandler(BaseHTTPRequestHandler):
                         "summary": self.ws.grade_summary(slot),
                         "state": self.ws.state()["slots"][n - 1]})
 
+    def _api_caption(self, body: dict) -> None:
+        """Persist caption versions produced outside the workbench (both agent tracks).
+
+        The local gateway track has always written captions into the workspace
+        (see _api_ai), but an agent had no equivalent endpoint: it could only say
+        the three versions in the conversation, so the 文案 step kept showing
+        「还没有文案」 — on the very screen where the user had just asked for them —
+        and the set never counted as finished. Registration stores exactly what
+        the caller sends; nothing is invented here.
+        """
+        raw = body.get("versions")
+        if not isinstance(raw, list):
+            self.send_json({"ok": False, "error": "versions 必须是数组"}, 400)
+            return
+        versions = []
+        for item in raw:
+            if isinstance(item, str):
+                text, style = item.strip(), ""
+            elif isinstance(item, dict):
+                text = str(item.get("text") or "").strip()
+                style = str(item.get("style") or "").strip()
+            else:
+                continue
+            if text:
+                versions.append({"style": style or f"版本 {len(versions) + 1}",
+                                 "text": text[:4000]})
+        if not versions:
+            self.send_json({"ok": False, "error": "至少需要一版非空文案"}, 400)
+            return
+        tags = [str(t).strip() for t in (body.get("tags") or []) if str(t).strip()][:12]
+        saved = self.ws.save_captions({"narrative": str(body.get("narrative") or "")[:600],
+                                       "versions": versions, "tags": tags})
+        self.send_json({"ok": True, "captions": saved, "versions": saved["versions"],
+                        "revision": self.ws.revision})
+
     def _api_edit_result(self, body: dict) -> None:
         """Register a retouch result produced outside the workbench.
 

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

@@ -399,15 +399,15 @@ input[type=range]::-moz-range-thumb{width:12px;height:12px;border-radius:50%;bac
   padding:10px 11px;font-family:var(--mono);font-size:10.5px;line-height:1.6;resize:vertical;
   background:#FCFCFE;color:var(--ink-2)}
 .prompt-box .pb-foot{display:flex;gap:6px;padding:7px 9px;border-top:1px solid #E7EAF2;background:#FAFBFD;flex-wrap:wrap}
-.cand{display:grid;gap:6px;margin-top:4px}
-.cand .c{border:1px solid var(--line);border-radius:7px;padding:8px 10px;background:#fff;cursor:pointer;
-  transition:all .18s var(--ease);display:flex;gap:10px;align-items:center}
-.cand .c:hover{border-color:var(--gold);box-shadow:var(--sh-1)}
-.cand .c img{width:44px;height:44px;border-radius:4px;object-fit:cover;flex:none;border:1px solid var(--line)}
-.cand .c .cx{flex:1;min-width:0}
-.cand .c .cx b{font-size:11.5px;display:block}
-.cand .c .cx s{font-size:9.5px;color:var(--sub);text-decoration:none;display:block;
-  white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.cand{display:grid;gap:6px;margin-top:4px;grid-template-columns:minmax(0,1fr)}
+.cand .c{border:1px solid var(--line);border-radius:7px;padding:8px 10px;background:#fff;cursor:pointer;
+  transition:all .18s var(--ease);display:flex;gap:10px;align-items:center;min-width:0;max-width:100%}
+.cand .c:hover{border-color:var(--gold);box-shadow:var(--sh-1)}
+.cand .c img{width:44px;height:44px;border-radius:4px;object-fit:cover;flex:none;border:1px solid var(--line)}
+.cand .c .cx{flex:1;min-width:0}
+.cand .c .cx b{font-size:11.5px;display:block}
+.cand .c .cx s{font-size:9.5px;color:var(--sub);text-decoration:none;display:block;
+  overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .note{font-size:10.5px;color:var(--sub);line-height:1.6}
 .note.warn{color:var(--warn)}
 .note.err{color:var(--err)}
@@ -1599,7 +1599,11 @@ function renderInspector(passive = true) {
   const editPresets = (S.data.ai.edit_presets || []).map((p) =>
     `<button class="btn btn-sm" data-edit="${p.key}" title="${H(p.instruction)}">${H(p.label)}</button>`).join("");
 
-  const cand = !useAgentModel() && S.aiCandidateSlot === S.sel && (!S.aiCandidateSource || S.aiCandidateSource === s.source)
+  // The candidate chooser is not gateway-only. The agent-model track derives the
+  // same 克制/标准/浓郁 from the recipe its agent applied, so suppressing the
+  // chooser here meant the agent's promise of 「三套候选」 produced no visible
+  // choice and no 预览/采用 entry at all on that track.
+  const cand = S.aiCandidateSlot === S.sel && (!S.aiCandidateSource || S.aiCandidateSource === s.source)
     ? (S.aiCandidates || []) : [];
   const candHtml = cand.length ? `<div class="cand">${cand.map((c) => `
     <div class="c">
@@ -2196,7 +2200,71 @@ function jobStep(j) {
 }
 
 async function handleJobDone(j) {
-  if (j.kind === "agent_turn") { await refresh(true); if (AP.open || useAgentModel()) await pollAgent(); return; }
+  if (j.kind === "agent_turn") {
+    await refresh(true);
+    if (AP.open || useAgentModel()) await pollAgent();
+    // An agent turn that landed a grading recipe carries the same three derived
+    // candidates the ClawHive track shows; without this branch the page refreshed
+    // and stayed silent, so the user never saw the plan they were promised.
+    const ar = (j.result || {}).result || {};
+    const akind = (j.meta || {}).operation || "";
+    if (["grade_plan", "grade_all"].includes(akind) && (ar.candidates || []).length) {
+      const s = slotByIdx(ar.slot || (j.meta || {}).slot);
+      S.aiCandidates = ar.candidates.map((c) => ({
+        key: c.key, label: c.label, params: c.params,
+        preset: c.preset || "none",
+        summary: c.summary || describeParams(c.params),
+        thumb: s ? s.raw_thumb : "",
+      }));
+      S.aiCandidateSlot = s ? s.slot : 0;
+      S.aiCandidateSource = s?.source || "";
+      S.aiPlan = ar;
+      renderInspector();
+      toast(`Agent 落的这版配好三档：${S.aiCandidates.map((c) => c.label).join(" / ")}，点一下换档`,
+            "ai", 6000);
+    } else if (["grade_plan", "grade_all"].includes(akind)) {
+      // Say it out loud instead of staying silent: the agent talked but left the
+      // workbench untouched, so there is no recipe to derive three variants from.
+      // Silence here is what made 「没看到三个选项」 indistinguishable from a bug.
+      // Painted directly: renderAiOut() still refuses to draw on the agent track.
+      const step = (j.meta || {}).step || jobStep(j);
+      const why = j.result?.applied ? "本轮改动没有落到调色参数上" : "Agent 只给了说明，没有改动工作台";
+      // Drop any earlier turn's chooser first: keeping it would present a stale
+      // recipe as if this turn had produced it.
+      if (S.aiCandidates) {
+        S.aiCandidates = null; S.aiCandidateSlot = 0; S.aiCandidateSource = "";
+        renderInspector();
+      }
+      const box = step === S.step ? outBox() : null;
+      if (box) {
+        box.innerHTML = `<div class="note" style="margin-top:10px"><b>Agent 这一轮没产出可选的调色方案</b><br>
+          ${H(why)}。回答在下方「本步回复与反馈」里；要三档候选，请让 Agent 通过工作台落地配方
+          （<code>POST /api/grade</code>），或改用「模型网关」直接生成方案。</div>`;
+      }
+      toast("Agent 没改动工作台，所以还没有三档候选可选", "err", 7000);
+    } else if (akind === "caption") {
+      // 文案 is the one step with no adopt concept: it lands in the workspace and
+      // the user copies a version. Before /api/caption existed an agent could
+      // only say the three versions in the conversation, so this very panel kept
+      // answering 「还没有文案」 right after the user asked for them.
+      const caps = (S.data.captions && S.data.captions.versions) || [];
+      if (caps.length) {
+        renderCaptions();
+        toast(`Agent 已登记 ${caps.length} 版文案，在文案面板逐版复制`, "ai", 6000);
+      } else {
+        const step = (j.meta || {}).step || jobStep(j);
+        const box = step === S.step ? outBox() : null;
+        if (box) {
+          box.innerHTML = `<div class="note" style="margin-top:10px"><b>Agent 没把文案登记到工作台</b><br>
+            三版文案可能只写在会话里了，所以本步仍是空的、打包也拿不到。
+            回答在下方「本步回复与反馈」里；可让 Agent 重新调用 <code>POST /api/caption</code>
+            登记，或改用「模型网关」生成。</div>`;
+        }
+        toast("Agent 没有登记文案，文案面板仍是空的", "err", 7000);
+      }
+    }
+    return;
+  }
   if (j.kind === "journey_index") { await loadJourney(); return; }
   if (j.result?.result?.proposal && showComposeProposal(j)) return;
   const resultStep = jobStep(j);

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.0.0';
+const VERSION = '1.1.2';
 const SKILL_NAME = 'trip-moments';
 
 const c = {

package/package.json

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