@optima-chat/dev-skills 0.16.2 → 0.16.4

package/.codex/skills/yzsgo-e2e/judge_outcome.js

@@ -0,0 +1,11 @@
+// yzsgo-e2e 三态裁决纯函数（node --test 覆盖）。逻辑与 judge_workflow.js 内联副本保持一致。
+function decideOutcome(votes) {
+  const good = (votes || []).filter(Boolean);
+  const n = good.length;
+  const refuted = good.filter((v) => v.refuted).length;
+  if (n === 0) return "needs_review";
+  if (refuted === n) return "rejected";
+  if (refuted > n / 2) return "needs_review";
+  return "confirmed";
+}
+module.exports = { decideOutcome };

package/.codex/skills/yzsgo-e2e/judge_workflow.js

@@ -0,0 +1,100 @@
+// .claude/skills/yzsgo-e2e/judge_workflow.js
+// 改编自 optima-gateway conversation-iq/workflow.js（见 SYNC.md）。
+// 输入 args: { base, sids, knownIssues }（备料稿目录 / 待判对话文件名列表 / gh 实时拉的开着 issue 文本）。
+
+export const meta = {
+  name: "yzsgo-e2e-judge",
+  description: "读 e2e 备料稿（wire + 前端证据）逐对话判缺陷，对抗验证出三态",
+  phases: [
+    { title: "Judge", detail: "每对话一个 agent 读备料稿判缺陷（含前后端一致性）" },
+    { title: "Verify", detail: "每条 novel finding 3 个 skeptic 读 runtime 源码反驳，三态裁决" },
+  ],
+};
+
+// decideOutcome 与 judge_outcome.js 同步（后者有 node 单测）
+function decideOutcome(votes) {
+  const good = (votes || []).filter(Boolean);
+  const n = good.length;
+  const refuted = good.filter((v) => v.refuted).length;
+  if (n === 0) return "needs_review";
+  if (refuted === n) return "rejected";
+  if (refuted > n / 2) return "needs_review";
+  return "confirmed";
+}
+
+const A = typeof args === "string" ? JSON.parse(args) : args || {};
+
+const STABLE_NORMAL = `## 正常现象（不是缺陷，别报）：
+- compaction 摘要调用、abort、max_tokens 截断本身；
+- 前端 new_conversation 后主区只有本轮（预期）。`;
+
+const JUDGE_SCHEMA = {
+  type: "object",
+  properties: {
+    impression: { type: "string" },
+    findings: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          what: { type: "string" },
+          evidence: { type: "string" },
+          knownIssue: { type: "string" },
+        },
+        required: ["what", "evidence"],
+      },
+    },
+  },
+  required: ["impression", "findings"],
+};
+
+const VERDICT_SCHEMA = {
+  type: "object",
+  properties: { refuted: { type: "boolean" }, reason: { type: "string" } },
+  required: ["refuted", "reason"],
+};
+
+function judgePrompt(path) {
+  return `读备料稿 ${path}（含 wire transcript + 「前端所见」证据）。判这次端到端对话有没有网关/agent 缺陷。
+重点核对：① wire 里 agent 真实产出 vs 前端渲染是否一致（丢内容/半截/前端报错但 wire 成功、或反之）；
+② 悬空 tool_use / max_tokens 截断 / error / abort 是否造成用户可感问题；③ 回答是否编数据/答非所问/活没干完。
+${STABLE_NORMAL}
+已知开着的 issue（命中就在 knownIssue 里标 #号，仅打标签、不要因此不报）：
+${A.knownIssues || "(无)"}
+默认健康：证据不足别硬报。输出 impression + findings。`;
+}
+
+function verifyPrompt(f, path) {
+  return `有人在 ${path} 报了缺陷：「${f.what}」，证据：${f.evidence}。
+你是 skeptic：读**真实 runtime 源码**（optima-gateway / agent-runtime）核对机制，尽力反驳。默认判假（refuted=true），
+只有确凿证明该缺陷真实存在才 refuted=false。输出 refuted + reason。`;
+}
+
+const results = await pipeline(
+  A.sids,
+  (sid) =>
+    agent(judgePrompt(`${A.base}/${sid}.md`), {
+      label: `judge:${sid}`,
+      phase: "Judge",
+      schema: JUDGE_SCHEMA,
+    }).then((judge) => ({ sid, judge })),
+  async (prev) => {
+    if (!prev || !prev.judge) return { sid: prev?.sid, confirmed: [], needsReview: [], rejected: [] };
+    const path = `${A.base}/${prev.sid}.md`;
+    const novel = prev.judge.findings || [];
+    if (novel.length === 0)
+      return { sid: prev.sid, impression: prev.judge.impression, confirmed: [], needsReview: [], rejected: [] };
+    const verified = await parallel(
+      novel.map((f) => async () => {
+        const votes = await parallel(
+          [0, 1, 2].map(() => () => agent(verifyPrompt(f, path), { label: `verify:${prev.sid}`, phase: "Verify", schema: VERDICT_SCHEMA }))
+        );
+        return { finding: f, outcome: decideOutcome(votes) };
+      })
+    );
+    const by = (o) => verified.filter(Boolean).filter((v) => v.outcome === o);
+    return { sid: prev.sid, impression: prev.judge.impression, confirmed: by("confirmed"), needsReview: by("needs_review"), rejected: by("rejected") };
+  }
+);
+
+return { results: results.filter(Boolean) };

package/.codex/skills/yzsgo-e2e/preflight.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""yzsgo-e2e 环境自检。探测函数有副作用（读端口/文件），汇总用纯函数 summarize_preflight。
+缺项只指路（不替用户做一次性登录/充值），准备步骤见 store-skills 的 setting-up-yzsgo-test-env。"""
+import os, shutil, socket, sys
+
+def _port_open(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(1.0)
+        return s.connect_ex(("127.0.0.1", port)) == 0
+
+def probe(env: str = "cn-prod") -> list[dict]:
+    return [
+        {"name": "chrome-9222", "ok": _port_open(9222),
+         "hint": '起调试端口 Chrome：open -na "Google Chrome" --args --remote-debugging-port=9222 '
+                 '--user-data-dir=/tmp/yzsgo-chrome https://www.yzsgo.com（手动登测试账号）'},
+        {"name": "buildbox-pw", "ok": os.path.exists(os.path.expanduser("~/.buildbox_pw")),
+         "hint": "拉 wire 需 buildbox 口令文件 ~/.buildbox_pw（见 setting-up-yzsgo-test-env）"},
+        {"name": "sshpass", "ok": shutil.which("sshpass") is not None,
+         "hint": "brew install hudochenkov/sshpass/sshpass"},
+        {"name": "playwright", "ok": _has_playwright(),
+         "hint": "pip install playwright && playwright install chromium"},
+    ]
+
+def _has_playwright() -> bool:
+    try:
+        import playwright  # noqa: F401
+        return True
+    except Exception:
+        return False
+
+def summarize_preflight(checks: list) -> dict:
+    ok = all(c["ok"] for c in checks)
+    missing = [c["name"] for c in checks if not c["ok"]]
+    rows = []
+    for c in checks:
+        mark = "✅" if c["ok"] else "❌"
+        rows.append(f"{mark} {c['name']}" + ("" if c["ok"] else f"\n    → {c['hint']}"))
+    return {"ok": ok, "missing": missing, "report": "\n".join(rows)}
+
+if __name__ == "__main__":
+    env = sys.argv[1] if len(sys.argv) > 1 else "cn-prod"
+    r = summarize_preflight(probe(env))
+    print(r["report"])
+    sys.exit(0 if r["ok"] else 1)

package/.codex/skills/yzsgo-e2e/prep_conversation.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""yzsgo-e2e 备料层：wire 侧备料稿（复用 pull_wire.render_conversation）+ 合并浏览器侧证据。
+改编自 optima-gateway conversation-iq/prep_session.py（备料思路）与 pull_wire（渲染）。见 SYNC.md。"""
+import json
+
+def merge_browser_evidence(wire_md: str, browser_turns: list) -> str:
+    lines = [wire_md.rstrip(), "",
+             "## 前端所见（浏览器侧证据；与上面 wire 对照）",
+             "> 判定要求：逐轮核对**前端渲染的**与**wire 里 agent 真实产出的**是否一致——"
+             "前端丢内容/半截/报错但 wire 成功（或反之）即为缺陷。", ""]
+    for i, t in enumerate(browser_turns):
+        lines.append(f"### 轮 #{i}  发送: {t.get('sent','')!r}")
+        lines.append(f"- state: {t.get('state','')}  timed_out: {t.get('timed_out', False)}")
+        tt = t.get("tool_trace")
+        if tt:
+            lines.append(f"- tool_trace: {json.dumps(tt, ensure_ascii=False)[:1500]}")
+        lines.append("- 前端整轮渲染:")
+        lines.append("```")
+        lines.append((t.get("transcript") or "(空)")[:6000])
+        lines.append("```")
+    return "\n".join(lines)

package/.codex/skills/yzsgo-e2e/pull_wire.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""拉取 + 渲染 yzsgo 会话的 Wire（Optima Gateway #2261 落盘的完整 LLM 上下文）。
+
+Wire = 每个 runtime session 的完整 LLM 调用记录，存境内 buildbox 的 NAS：
+  /mnt/nas-cn-prod/workspaces/cn-prod/<userId>/.agent/llm-wire/<sessionId>/
+    records.jsonl   —— 每行一条 {kind:request/response/error, callId, seq, ts, body{system,tools,messages}, finalMessage...}
+    blobs/          —— 大内容按 {"$blob": "<hash>"} 引用，deref 时读这里
+TTL 14 天。经 buildbox（47.94.105.163，口令 ~/.buildbox_pw）拉。
+
+⚠️ warm-pool 会把**同一账号顺序跑的多个 web 对话聚在一个 runtime session** 里 —— 一个
+records.jsonl 常含几十个对话。切分靠 seq 复位：agent 每轮 req 的 messages 递增(2,4,6…)、
+seq 递增(1,3,5…)，**seq==1（msgs==2）= 新对话开始**。本脚本据此切分，每个对话取「末 req 的
+全历史 + 末 response」= 该对话的完整 transcript（含推理/工具调用/工具结果/最终回复）。
+
+用法：
+  # 拉 + 渲染（默认测试账号，近 1 天）
+  pull_wire.py --user <userId> --since 1 --out e2e/wire
+  # 已拉过、只重渲染本地数据（迭代用，不再 SSH）
+  pull_wire.py --local e2e/wire/raw/llm-wire --out e2e/wire
+
+参考 optima-gateway 的 conversation-iq/prep_session.py（同一 Wire 数据源）。
+"""
+import argparse
+import json
+import os
+import subprocess
+import sys
+
+BUILDBOX = os.environ.get("OPTIMA_BUILDBOX_HOST", "root@47.94.105.163")
+PW_FILE = os.path.expanduser(os.environ.get("OPTIMA_BUILDBOX_PW", "~/.buildbox_pw"))
+NAS = os.environ.get("OPTIMA_NAS_CN", "/mnt/nas-cn-prod/workspaces/cn-prod")
+
+
+def ssh(cmd):
+    return subprocess.run(
+        ["sshpass", "-f", PW_FILE, "ssh", "-o", "StrictHostKeyChecking=no",
+         "-o", "ConnectTimeout=25", BUILDBOX, cmd],
+        capture_output=True, text=True)
+
+
+def pull(user, since_days, out):
+    """SSH buildbox：打包该 user 近 since_days 天有更新的 wire session，scp 回 out/raw/。"""
+    raw = os.path.join(out, "raw")
+    os.makedirs(raw, exist_ok=True)
+    base = f"{NAS}/{user}/.agent/llm-wire"
+    # 只打包近 since_days 天有更新的 session（records.jsonl mtime）
+    remote_tar = "/tmp/optima_wire_pull.tgz"
+    pack = (f"cd {NAS}/{user}/.agent 2>/dev/null && "
+            f"sids=$(find {base}/*/records.jsonl -mtime -{since_days} 2>/dev/null "
+            f"| sed 's#/records.jsonl##' | sed 's#.*/##') && "
+            f"[ -z \"$sids\" ] && echo NO_SESSIONS && exit 0; "
+            f"tar czf {remote_tar} $(for s in $sids; do echo llm-wire/$s; done) && "
+            f"echo PACKED $(echo \"$sids\" | wc -w)")
+    r = ssh(pack)
+    if "NO_SESSIONS" in r.stdout:
+        print(f"[pull] {user} 近 {since_days} 天无 wire session（TTL 14 天，或该账号没跑过）")
+        return None
+    if "PACKED" not in r.stdout:
+        print("[pull] 打包失败：", r.stdout, r.stderr, file=sys.stderr)
+        return None
+    print(f"[pull] 远端打包 {r.stdout.strip().splitlines()[-1]} session")
+    local_tar = os.path.join(raw, "wire.tgz")
+    subprocess.run(["sshpass", "-f", PW_FILE, "scp", "-o", "StrictHostKeyChecking=no",
+                    f"{BUILDBOX}:{remote_tar}", local_tar], check=True)
+    subprocess.run(["tar", "xzf", local_tar, "-C", raw], check=True)
+    ssh(f"rm -f {remote_tar}")
+    return os.path.join(raw, "llm-wire")
+
+
+# ── 渲染（源自 conversation-iq/prep_session.py，扩展为「一个 session 切多个对话」）──
+
+def make_deref(session_dir):
+    def deref(v):
+        if isinstance(v, dict) and "$blob" in v:
+            try:
+                return json.load(open(os.path.join(session_dir, "blobs", v["$blob"])))
+            except Exception:
+                return v
+        return v
+    return deref
+
+
+def first_user_text(req, deref):
+    for m in (deref(req.get("body", {}).get("messages")) or []):
+        m = deref(m)
+        if m.get("role") == "user":
+            c = m.get("content")
+            if isinstance(c, str):
+                return c
+            if isinstance(c, list):
+                for b in c:
+                    b = deref(b)
+                    if isinstance(b, dict) and b.get("type") == "text":
+                        return b.get("text", "")
+    return "(无 user 消息)"
+
+
+# 渲染截断上限（审查要逐格核数字 → tool_result 尽量全；截断处标真实长度，别让审查以为"就这些"）
+CAP_TEXT = 6000
+CAP_THINK = 3000
+CAP_TOOL_IN = 6000
+CAP_TOOL_OUT = 16000
+
+
+def _clip(s, cap):
+    s = str(s)
+    return s if len(s) <= cap else s[:cap] + f" …[截断，共 {len(s)} 字]"
+
+
+def render_block(b, deref):
+    b = deref(b)
+    if not isinstance(b, dict):
+        return "    " + _clip(b, CAP_TOOL_OUT)
+    t = b.get("type")
+    if t == "text":
+        return "    [text] " + _clip(b.get("text") or "", CAP_TEXT)
+    if t == "thinking":
+        return "    [thinking] " + _clip(b.get("thinking") or "", CAP_THINK)
+    if t == "tool_use":
+        return f"    [tool_use {b.get('name')}] " + _clip(json.dumps(deref(b.get("input")), ensure_ascii=False), CAP_TOOL_IN)
+    if t == "tool_result":
+        c = deref(b.get("content"))
+        if isinstance(c, list):
+            c = " ".join(json.dumps(deref(x), ensure_ascii=False) for x in c)
+        return f"    [tool_result err={b.get('is_error')}] " + _clip(c, CAP_TOOL_OUT)
+    if t == "image":
+        return "    [image]"
+    return "    [?] " + _clip(json.dumps(b, ensure_ascii=False), CAP_TOOL_OUT)
+
+
+def segment(reqs, deref):
+    """按 seq==1（新对话起点）把 requests 切成多段对话。返回 [[req,...], ...]（各段按 ts 有序）。"""
+    reqs = sorted(reqs, key=lambda r: r.get("ts", ""))
+    convs, cur = [], []
+    for r in reqs:
+        if r.get("seq", 1) == 1 and cur:
+            convs.append(cur)
+            cur = []
+        cur.append(r)
+    if cur:
+        convs.append(cur)
+    return convs
+
+
+def render_conversation(conv, resps, deref, idx):
+    """一个对话 = 一串 req（末 req 含全历史）。渲染事实卡 + 完整 transcript。"""
+    last = conv[-1]
+    prompt = first_user_text(conv[0], deref)
+    ts0 = conv[0].get("ts", "")
+    # 事实卡
+    n_turns = len(conv)
+    errs = [resps.get(r["callId"]) for r in conv
+            if resps.get(r["callId"]) and resps[r["callId"]].get("kind") == "error"]
+    maxtok = sum(1 for r in conv
+                 if (resps.get(r["callId"]) or {}).get("kind") == "response"
+                 and ((resps[r["callId"]].get("finalMessage") or {}).get("stopReason") == "max_tokens"))
+    # 悬空 tool_use（末 req 全历史）
+    msgs = [deref(m) for m in (deref(last["body"].get("messages")) or [])]
+    use_ids, res_ids = {}, set()
+    for m in msgs:
+        c = m.get("content")
+        if isinstance(c, list):
+            for b in c:
+                b = deref(b)
+                if isinstance(b, dict):
+                    if b.get("type") == "tool_use":
+                        use_ids[b.get("id")] = b.get("name")
+                    if b.get("type") == "tool_result":
+                        res_ids.add(b.get("tool_use_id"))
+    dangling = [(u, n) for u, n in use_ids.items() if u not in res_ids]
+
+    L = [f"# 对话 #{idx}  {ts0}",
+         "", f"**prompt**: {prompt[:200]}", "",
+         "## 事实卡（代码算的确定信息）",
+         f"- LLM 轮数(req) {n_turns}",
+         f"- error 响应 {len(errs)}" + (f"：{[json.dumps(deref(e.get('error') or {}),ensure_ascii=False)[:120] for e in errs]}" if errs else ""),
+         f"- stop_reason=max_tokens 的响应 {maxtok}",
+         f"- 悬空 tool_use（无匹配 result）{len(dangling)}: {dangling[:5]}",
+         "", "## 完整 transcript（末 req 全历史 + 末 response）", ""]
+    # 末 response 拼到历史尾
+    lastresp = resps.get(last["callId"])
+    if lastresp and lastresp.get("kind") == "response":
+        fm = lastresp.get("finalMessage") or {}
+        msgs.append({"role": "assistant", "content": fm.get("content", [])})
+    for i, m in enumerate(msgs):
+        role = m.get("role")
+        c = m.get("content")
+        L.append(f"\n--- #{i} [{role}] ---")
+        if isinstance(c, str):
+            L.append("    " + _clip(c, CAP_TEXT))
+        elif isinstance(c, list):
+            for b in c:
+                L.append(render_block(b, deref))
+    return prompt, ts0, len(errs), len(dangling), "\n".join(L)
+
+
+def render_all(wire_root, out):
+    conv_dir = os.path.join(out, "conversations")
+    os.makedirs(conv_dir, exist_ok=True)
+    index = ["# Wire 会话索引", ""]
+    sessions = sorted(d for d in os.listdir(wire_root)
+                      if os.path.isdir(os.path.join(wire_root, d)))
+    gidx = 0
+    for sid in sessions:
+        sdir = os.path.join(wire_root, sid)
+        recf = os.path.join(sdir, "records.jsonl")
+        if not os.path.exists(recf):
+            continue
+        deref = make_deref(sdir)
+        recs = [json.loads(l) for l in open(recf, encoding="utf-8") if l.strip()]
+        reqs = [r for r in recs if r.get("kind") == "request"]
+        resps = {r.get("callId"): r for r in recs if r.get("kind") in ("response", "error")}
+        convs = segment(reqs, deref)
+        index.append(f"\n## session `{sid}` — {len(convs)} 对话 / {len(reqs)} req\n")
+        for conv in convs:
+            gidx += 1
+            prompt, ts0, n_err, n_dang, md = render_conversation(conv, resps, deref, gidx)
+            fn = f"{gidx:03d}.md"
+            open(os.path.join(conv_dir, fn), "w", encoding="utf-8").write(md)
+            flag = (" ⚠️err" if n_err else "") + (" ⚠️dangling" if n_dang else "")
+            index.append(f"- [{fn}](conversations/{fn}) [{len(conv):>2} req] {prompt[:64]}{flag}")
+    idxpath = os.path.join(out, "index.md")
+    open(idxpath, "w", encoding="utf-8").write("\n".join(index))
+    print(f"[render] {gidx} 个对话 → {conv_dir}/  索引 → {idxpath}")
+    return idxpath
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--user", help="userId（拉该账号的 wire）")
+    ap.add_argument("--since", type=int, default=1, help="拉近 N 天有更新的 session（默认 1）")
+    ap.add_argument("--out", default="e2e/wire", help="输出目录（默认 e2e/wire）")
+    ap.add_argument("--local", help="跳过 SSH，直接渲染这个本地 llm-wire 目录（迭代用）")
+    a = ap.parse_args()
+
+    if a.local:
+        render_all(a.local, a.out)
+        return
+    if not a.user:
+        ap.error("需 --user <userId>（或 --local <dir> 只渲染已拉数据）")
+    wire_root = pull(a.user, a.since, a.out)
+    if wire_root:
+        render_all(wire_root, a.out)
+
+
+# ── yzsgo-e2e 增补：结构化对话索引 + 本次对话定位 ──
+
+def emit_conversation_index(wire_root):
+    """遍历 wire_root 下各 session，切分对话，产出与 render_all 同序的结构化索引。"""
+    out = []
+    gidx = 0
+    sessions = sorted(d for d in os.listdir(wire_root)
+                      if os.path.isdir(os.path.join(wire_root, d)))
+    for sid in sessions:
+        sdir = os.path.join(wire_root, sid)
+        recf = os.path.join(sdir, "records.jsonl")
+        if not os.path.exists(recf):
+            continue
+        deref = make_deref(sdir)
+        recs = [json.loads(l) for l in open(recf, encoding="utf-8") if l.strip()]
+        reqs = [r for r in recs if r.get("kind") == "request"]
+        for conv in segment(reqs, deref):
+            gidx += 1
+            out.append({"gidx": gidx, "sid": sid,
+                        "ts": conv[0].get("ts", ""),
+                        "prompt": first_user_text(conv[0], deref)})
+    return out
+
+
+def _ts_key(ts):
+    """把 wire 的 ...Z 与 datetime.isoformat 的 ...+00:00 归一成可比较的 aware datetime；解析不了回 None。"""
+    from datetime import datetime
+    if not ts:
+        return None
+    try:
+        return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def locate_conversation(index, started_ts, first_message):
+    """按 (started_ts, first_message) 定位本次对话；禁用 ls -t。规则见 plan Task 3 Interfaces。
+    时间比较先把两侧 ISO（Z / +00:00、小数位宽不同）归一成 datetime，避免依赖字典序=数值序的脆弱假设。"""
+    key = (first_message or "").strip()[:40]
+    cands = []
+    for it in index:
+        p = (it.get("prompt") or "").strip()
+        if not p or not key:
+            continue
+        if p[:40].startswith(key) or key.startswith(p[:40]):
+            cands.append(it)
+    if not cands:
+        return None
+    from datetime import datetime, timezone
+    FAR = datetime.max.replace(tzinfo=timezone.utc)
+    cands.sort(key=lambda x: _ts_key(x.get("ts", "")) or FAR)
+    st = _ts_key(started_ts)
+    after = []
+    for c in cands:
+        ck = _ts_key(c.get("ts", ""))
+        if st is not None and ck is not None:
+            if ck >= st:
+                after.append(c)
+        elif c.get("ts", "") >= (started_ts or ""):   # 任一解析不了 → 退字符串比较保底
+            after.append(c)
+    if after:
+        return after[0]
+    return cands[-1]
+
+
+if __name__ == "__main__":
+    main()

package/.codex/skills/yzsgo-e2e/run_e2e.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""yzsgo-e2e 编排：驱动对话 → 拉 wire → 定位本次对话 → 备料（含浏览器证据）→ 出备料稿+元数据。
+judge 由 Claude 用 judge_workflow.js 跑；提 issue 由 Claude 依 SKILL.md 用 gh 做。用户不敲本脚本。"""
+import argparse, json, os, sys
+from datetime import datetime, timezone
+
+def render_report(result: dict) -> str:
+    L = [f"# yzsgo-e2e 报告 · {result['env']} · {result['started_ts']}", ""]
+    if result.get("blocked"):
+        L.append(f"> ⚠️ blocked: {result['blocked']}（环境问题，非缺陷，未提 issue）")
+        L.append("")
+    L += ["## 本次端到端问题（按严重度）", "", "| 状态 | 问题 | 证据 |", "|---|---|---|"]
+    for f in result.get("confirmed", []):
+        L.append(f"| confirmed | {f['what']} | {f['evidence']} |")
+    for f in result.get("needs_review", []):
+        L.append(f"| needs_review | {f['what']} | {f['evidence']} |")
+    if not result.get("confirmed") and not result.get("needs_review"):
+        L.append("| — | 无 confirmed/needs_review | — |")
+    L += ["", "## 覆盖边界", result.get("coverage", "-"),
+          "", "## 判断修正", "（如判定过程中修正过结论，如实记此；无则写'无'）"]
+    return "\n".join(L)
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+def _parse_answers(pairs):
+    out = []
+    for p in pairs or []:
+        if "=" in p:
+            k, v = p.split("=", 1)
+            out.append({"match": k, "answer": v})
+        else:
+            print(f"[warn] 忽略格式不对的 --answer {p!r}（应为 关键词=答案）", file=sys.stderr)
+    return out
+
+def select_conversation_in_session(convs, deref, hit):
+    """在同一 session 的 convs 里按 (ts, prompt) 重新定位本次对话；找不到回退末个。
+    不能用跨 session 的全局 gidx 去索引 session-local 列表。"""
+    import pull_wire
+    for c in convs:
+        if not c:
+            continue
+        if c[0].get("ts", "") == hit.get("ts") and pull_wire.first_user_text(c[0], deref) == hit.get("prompt"):
+            return c
+    return convs[-1] if convs else None
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--env", default="cn-prod", choices=["cn-prod", "cn-stage"])
+    ap.add_argument("--message", action="append", required=True, help="逐轮发送的消息（可多次）")
+    ap.add_argument("--answer", action="append", help="反问预设答案 关键词=答案（可多次）")
+    ap.add_argument("--expect", default="", help="关注点，喂给判定层")
+    ap.add_argument("--user", required=True, help="测试账号 userId（拉 wire 用）")
+    ap.add_argument("--out", default="e2e-out")
+    ap.add_argument("--timeout", type=int, default=180,
+                    help="每轮等回复超时秒；长任务（简报/多工具）调大到 500+")
+    ap.add_argument("--since", type=int, default=1, help="拉 wire 的天数窗口（默认 1）")
+    ap.add_argument("--issue-repo", default="Optima-Chat/optima-gateway")
+    args = ap.parse_args()
+
+    if args.env == "cn-stage":
+        print("[warn] cn-stage 的 wire 取法未验证（spec §8 待核实）；仅 cn-prod 全链路已打通。", file=sys.stderr)
+
+    os.makedirs(args.out, exist_ok=True)
+    import preflight, chat_driver, pull_wire, prep_conversation
+    pf = preflight.summarize_preflight(preflight.probe(args.env))
+    if not pf["ok"]:
+        print(pf["report"]); print("\n[preflight 未通过，先按提示准备环境]"); sys.exit(2)
+
+    started_ts = _utc_now()
+    answers = _parse_answers(args.answer)
+    d = chat_driver.ChatDriver().attach()
+    try:
+        d.new_conversation()
+        turns = []
+        for msg in args.message:
+            r = d.send_and_wait(msg, answers=answers, timeout=args.timeout)
+            turns.append({"sent": msg, "state": r.get("state"), "transcript": r.get("transcript", ""),
+                          "tool_trace": r.get("tool_trace"), "timed_out": r.get("timed_out", False)})
+    finally:
+        d.close()
+
+    wire_root = pull_wire.pull(args.user, since_days=args.since, out=args.out)
+    meta = {"env": args.env, "started_ts": started_ts, "first_message": args.message[0],
+            "expect": args.expect, "issue_repo": args.issue_repo, "turns": turns,
+            "located": None, "located_reason": None}
+    wrote_prepped = False
+    if not wire_root:
+        meta["located_reason"] = "no_wire_session"
+    if wire_root:
+        index = pull_wire.emit_conversation_index(wire_root)
+        hit = pull_wire.locate_conversation(index, started_ts, args.message[0])
+        meta["located"] = hit
+        if hit:
+            sdir = os.path.join(wire_root, hit["sid"])
+            deref = pull_wire.make_deref(sdir)
+            with open(os.path.join(sdir, "records.jsonl"), encoding="utf-8") as f:
+                recs = [json.loads(l) for l in f if l.strip()]
+            reqs = [x for x in recs if x.get("kind") == "request"]
+            resps = {x.get("callId"): x for x in recs if x.get("kind") in ("response", "error")}
+            convs = pull_wire.segment(reqs, deref)
+            conv = select_conversation_in_session(convs, deref, hit)
+            if conv is not None:
+                _, _, _, _, wire_md = pull_wire.render_conversation(conv, resps, deref, hit["gidx"])
+                prepped = prep_conversation.merge_browser_evidence(wire_md, turns)
+                with open(os.path.join(args.out, "prepped.md"), "w", encoding="utf-8") as f:
+                    f.write(prepped)
+                wrote_prepped = True
+        else:
+            meta["located_reason"] = "no_match"
+    with open(os.path.join(args.out, "meta.json"), "w", encoding="utf-8") as f:
+        f.write(json.dumps(meta, ensure_ascii=False, indent=2))
+    if wrote_prepped:
+        print(f"[done] 备料稿 → {args.out}/prepped.md  元数据 → {args.out}/meta.json")
+        print("下一步：Claude 用 judge_workflow.js 判定，confirmed 提 issue 到", args.issue_repo)
+    else:
+        reason = "未拉到本账号 wire session（TTL/该窗口没跑过）" if not wire_root else "未能在 wire 里定位到本次对话（ts/prompt 未匹配）"
+        print(f"[warn] 只写了 {args.out}/meta.json，未生成 prepped.md：{reason}")
+        print("       检查测试账号 userId / --since 窗口 / 前端是否真落 wire。")
+
+if __name__ == "__main__":
+    main()

package/.codex/skills/yzsgo-e2e/verify_drift.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""比对 vendored 文件与上游是否漂移。上游 repo 不在本机则跳过（不破坏自包含）。"""
+import os, subprocess
+
+# adapted=True 的文件在上游基础上有本地改动/追加，diff 必然 ≠0 → ⚠️ 是「去看上游有无新变更」而非缺陷；
+# adapted=False 是逐字 vendored，应与上游一致，⚠️ 才是真漂移。
+VENDORED = [
+    {"file": "chat_driver.py", "repo": "store-skills", "adapted": False,
+     "upstream": "~/optima-store-skills/.claude/skills/operating-yzsgo-chat/chat_driver.py"},
+    {"file": "pull_wire.py", "repo": "store-skills", "adapted": True,   # 追加了 emit_conversation_index/locate_conversation
+     "upstream": "~/optima-store-skills/.claude/skills/pulling-yzsgo-session-wire/pull_wire.py"},
+    {"file": "prep_conversation.py", "repo": "gateway", "adapted": True,
+     "upstream": "~/optima-gateway/.claude/skills/conversation-iq/prep_session.py"},
+    {"file": "judge_workflow.js", "repo": "gateway", "adapted": True,
+     "upstream": "~/optima-gateway/.claude/skills/conversation-iq/workflow.js"},
+]
+
+def plan_drift_checks(present: dict) -> list:
+    out = []
+    for v in VENDORED:
+        out.append({"file": v["file"], "upstream": v["upstream"],
+                    "adapted": v.get("adapted", False),
+                    "checkable": bool(present.get(v["repo"], False))})
+    return out
+
+def _present() -> dict:
+    return {"store-skills": os.path.isdir(os.path.expanduser("~/optima-store-skills")),
+            "gateway": os.path.isdir(os.path.expanduser("~/optima-gateway"))}
+
+if __name__ == "__main__":
+    here = os.path.dirname(os.path.abspath(__file__))
+    for c in plan_drift_checks(_present()):
+        if not c["checkable"]:
+            print(f"⏭  {c['file']}：上游不在本机，跳过"); continue
+        up = os.path.expanduser(c["upstream"])
+        r = subprocess.run(["diff", "-q", os.path.join(here, c["file"]), up], capture_output=True, text=True)
+        if r.returncode == 0:
+            print(f"✅ {c['file']} 与上游一致")
+        elif c.get("adapted"):
+            print(f"⚠️(改编·预期) {c['file']}：与上游有差异属正常，去看上游有无值得同步的新变更")
+        else:
+            print(f"⚠️ 漂移 {c['file']} vs {c['upstream']}（逐字 vendored，应一致 → 去同步）")