Duplicate from cklxx/laya-browser

Co-authored-by: chenkailun <cklxx@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,39 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+v10s/tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+assets/laya_browser_demo.gif filter=lfs diff=lfs merge=lfs -text
+assets/laya_browser_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+v11s/tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,132 @@
+---
+license: apache-2.0
+base_model: convaiinnovations/laya
+language:
+- en
+- multilingual
+tags:
+- laya
+- system-1
+- browser-agent
+- web-navigation
+- decision-model
+- modernbert
+- mind2web
+- tilelang
+datasets:
+- osunlp/Mind2Web
+---
+
+# laya-browser — laya fine-tuned as a browser-agent decision head (drop-in replacement for TypeSafe Jev)
+
+![laya driving a real browser: 6 tasks, 12 decisions, median 22 ms per decision](assets/laya_browser_demo.gif)
+
+*46-second demo ([mp4](assets/laya_browser_demo.mp4)): v10s drives headless Chromium through jev-ultrafast, one encoder pass per step; recorded with `code/apps/make_demo.py`.*
+
+**laya** ([convaiinnovations/laya](https://huggingface.co/convaiinnovations/laya)) is a non-autoregressive "System 1" decision model:
+one bidirectional encoder pass answers several typed questions (`choice` / `score` / `noul`) with calibrated probabilities, no text generation.
+Out of the box it is near chance at browser decisions ("which element should I click for this goal?" — top-1 0.10 among ~45 candidates).
+
+This repo is what it took to turn it into a usable decision head for [browser-use/jev-ultrafast](https://github.com/browser-use/jev-ultrafast),
+whose `/v1/systemone` request format is identical to laya's `predict(state, questions)`. Everything was done locally on one RTX 4070 Ti SUPER (16 GB),
+no paid API: the text helper and the DAgger teacher are a local Qwen3-8B-AWQ served by sglang.
+
+## What changed relative to the original laya
+
+| | original laya (typed-decisions) | this repo |
+|---|---|---|
+| browser decision quality (16 real tasks × 3 runs, corrected checks) | 0 % | **v10s: 62 %**, v11s: 56 %, v10: 50 % (10 tasks pass 3/3, 6 fail 3/3; see below) |
+| element top-1 on held-out pages (2,734 decisions, ~45 candidates) | 0.10 | **0.66** (v10), 0.63 (v10s), 0.62 (v11s) |
+| operation accuracy (CLICK / TYPE_TEXT / SELECT / DONE) | 0.54 | 0.88–0.89 |
+| latency per browser step (3 questions, 30–65 candidates) | 50–200 ms | 41–50 ms (v10), **17–23 ms** (v10s / v11s) |
+| backbone | ModernBERT-large 421M | v10: same; v10s / v11s: mmBERT-base 322M |
+| input format | jev's state verbatim (element table as JSON inside the state, truncated by the 1024-token window) | **format v2/v3**: elements live only in the option list (full label + role + current value), state keeps title / URL / history / 1.2–1.5k chars of text, `head_max_len` 512 → 768 |
+| training data | LocalLLaMA/typed-decisions | 5,244 reverse-generated goals on 421 crawled pages (Qwen writes "the goal a user would state to need this element"), 700 real DONE states (clicks actually executed), 659 step-2 negatives, [Mind2Web](https://huggingface.co/datasets/osunlp/Mind2Web) train (7,296 steps, candidates re-rendered as an element table), 177 on-policy DAgger corrections |
+| training | — | laya's RLCD recipe (noisy-logit policy gradient + soft CE), single GPU, no gradient checkpointing, 4 epochs (~2 h for v10, ~1 h for v10s), post-hoc temperature |
+| inference | HF eager + autocast | optional TileLang fast path ([PR #25 to laya](https://github.com/NandhaKishorM/laya/pull/25)): fused GEMM/GEGLU/LayerNorm/RoPE, sliding-window flash attention, bf16-resident weights, CUDA graphs — 4–5× lower per-call latency, identical answers |
+
+### Things that did **not** work (so you don't repeat them)
+- Templated DONE goals ("Open the page titled X, stop once it is open") leak phrasing: the model learns *stop when ⇒ DONE*. DONE samples must be real landing pages after an executed action.
+- If every DONE sample has exactly one prior action and every click sample has none, the model learns *any history ⇒ DONE*. Add mid-task negatives (step-2 goals on landing pages).
+- Mind2Web alone kills DONE / TYPE_TEXT (no DONE there, CLICK dominates): re-weight rare operations (DONE ×4, TYPE_TEXT/SELECT ×3).
+- Cutting page text to 3,000 chars saved nothing (the sequence is dominated by the head) and cost 0.04 top-1.
+- `torch.compile` on variable-length batches recompiles per shape: 6× slower.
+- Confidence-gated escalation to Qwen3-8B (System 2) made things *worse* (58 % → 42 %): on these pages the fine-tuned 322M/421M model is a better decider than an 8B general LLM. Use a stronger System 2 or none.
+- jev's DOM reader hides password fields by design (login tasks are impossible) and never sees collapsed menus (Wikipedia's "Random article").
+
+### What still fails
+The suite is bimodal: 10 tasks pass 3/3 (category / tab / page navigation, checkbox, `<select>`, HN pages, DuckDuckGo search in some runs) and 6 fail 3/3:
+"type then submit / pick a suggestion" flows (Wikipedia search ×2, arXiv), pagination that needs a scroll first (the model clicks the first
+visible item instead), and Google Flights. v11s added 682 scripted scroll / search-submit / select trajectories (`code/finetune/rollouts.py`):
+SELECT and DuckDuckGo improved, the scroll case did not — run-to-run variance on live sites (HN front page changes, DDG 50x pages) is larger
+than the v10s ↔ v11s difference, so treat the two as equivalent.
+
+### Teachers vs the fine-tuned student (80 held-out decisions, same element tables)
+| decider | op acc | target top-1 | s / decision |
+|---|---|---|---|
+| Ternary-Bonsai-2-27B (local, thinking off) | 0.825 | 0.554 | 1.56 |
+| Bonsai-27B, thinking budget 300 tokens | 0.861 | 0.603 | 4.7 |
+| Bonsai-27B, thinking unrestricted | 0.625 | 0.474 | 11 |
+| Qwen3-8B-AWQ (35 % of requests failed, survivors only) | 0.904 | 0.617 | 0.38 |
+| **laya v11s (322M, this repo; full 2,734-case set)** | **0.890** | **0.623** | **0.021** |
+
+A 27B general model with a short thinking budget matches the 322M fine-tuned student at 200× the latency; neither 8B nor 27B is a useful
+DAgger teacher or System-2 fallback here. Further gains need a stronger teacher or more targeted trajectories.
+
+## Files
+
+```
+v10/     ModernBERT-large 421M, format v2, head_max_len 768   (best held-out top-1)
+v10s/    mmBERT-base 322M,      format v3, head_max_len 768   (17–23 ms per step; best on the live suite)
+v11s/    v10s data + 682 scripted scroll / search-submit / select trajectories (equivalent to v10s within noise)
+code/    finetune pipeline, laya systemone server, task suite, TileLang kernels, jev-ultrafast patch
+results/ per-run suite JSONs and logs behind every number above
+```
+Each checkpoint is a laya checkpoint directory (`model.safetensors`, `encoder/`, `tokenizer/`, `rl_agent_config.json`); the config records
+`laya_fmt` and `head_max_len_train` so the server applies the matching input format automatically.
+
+## Use
+
+```bash
+huggingface-cli download cklxx/laya-browser --local-dir laya-browser
+cd laya-browser/code && uv sync --extra fast     # pinned uv.lock (Python 3.12, torch 2.11, tilelang 0.1.14)
+uv run python verify.py v10s                     # downloads v10s if needed, answers one recorded browser step
+uv run python verify.py v10s --fast              # same through the TileLang fast path
+```
+Verified from a clean environment on 2026-09-21 (RTX 4070 Ti SUPER): `TYPE_TEXT → [2] Search Wikipedia (searchbox)`, 35 ms per step
+stock / 28 ms with the fast path on a 65-option, 2.5k-token step. Extras: `--extra data` (Mind2Web conversion, dataset eval),
+`--extra browser` (live suite / crawling; also needs jev-ultrafast with `code/jev-ultrafast.patch` applied and a Chromium with
+`--remote-debugging-port=9222`).
+
+```python
+import laya
+agent = laya.load("laya-browser/v10s")                 # a local laya checkpoint dir
+agent.cfg["head_max_len"] = agent.cfg["head_max_len_train"]
+# state / questions exactly as jev-ultrafast's model.choose() builds them, after the format-v3 transform in code/apps/systemone_server.py
+result = agent.predict(state, questions)
+```
+
+As a TypeSafe replacement for jev-ultrafast:
+
+```bash
+# in code/: laya systemone-compatible server (format transform + optional gating + DAgger logging)
+python apps/systemone_server.py 8791 /path/to/laya-browser/v10s 999
+# in jev-ultrafast (apply code/jev-ultrafast.patch): TYPESAFE_BASE_URL=http://127.0.0.1:8791
+```
+
+`code/apps/browser_suite.py` runs the 16-task real-browser suite with automatic outcome checks (`REPEATS=3`).
+
+## Reproduce
+
+`code/finetune/README.md` documents every step (crawl → reverse-generate goals → execute clicks for DONE → step-2 → Mind2Web conversion →
+DAgger → build → train → calibrate → eval → suite) with the exact scripts (`run_v10.sh`, `run_v10s.sh`, `run_final.sh`) and all intermediate
+numbers from v1 to v10s.
+
+## GPU cost
+
+v10s: ~0.65 GB weights, ~1.5 GB VRAM resident with CUDA graphs, 17–23 ms per 3-question browser step, 3 ms for a single-question call.
+v10: ~0.85 GB weights, ~1.8 GB VRAM, 41–50 ms per step. The Qwen text helper (only needed for TYPE_TEXT values) is separate.
+
+## License
+
+Apache-2.0, same as laya. Mind2Web is used under its own license for training only.

assets/laya_browser_demo.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7eaddd1fd8ac8e49ef219a2224b51800f5d7153e0493e42d5e51ab96ab9a9c0c
+size 888825

code/.python-version

@@ -0,0 +1 @@
+3.12

code/README.md

@@ -0,0 +1,35 @@
+# Laya 本机加速 + 应用
+
+[convaiinnovations/laya](https://huggingface.co/convaiinnovations/laya)：非自回归“System 1”决策模型（ModernBERT/mmBERT 编码器 + 决策头），
+一次前向同时回答多个 `choice / score / noul` 问题，输出校准概率，不生成文本。
+
+## 环境
+
+```fish
+source env.sh            # HF 镜像 + 清华 PyPI + 关闭代理
+.venv/bin/python ...     # Python 3.12, torch 2.11+cu130, tilelang 0.1.14
+```
+
+## 应用（apps/）
+
+| 脚本 | 说明 |
+|---|---|
+| `apps/inbox_triage.py [正文]` | 多语言工单分诊：部门 / 紧急度 / 流失风险 / 情绪 |
+| `apps/moderator.py [file]` | 评论审核台：有害 / 垃圾 / 主题 / 严重度，按风险排序 |
+| `apps/hn_radar.py [N]` | 拉 Hacker News 热帖实时打标签 |
+| `apps/web_console.py [port]` | 零依赖 Web 决策台，自定义问题 JSON，实时概率条 |
+
+在任何应用里加两行即可启用加速：
+```python
+import sys; sys.path.insert(0, "kernels")
+from fast_laya import accelerate; accelerate(agent)
+```
+
+## TileLang 加速（kernels/）
+
+* `tl_kernels.py` — GEMM(+bias/act 融合)、GEMM+GEGLU 融合、残差+LayerNorm 融合、原地 RoPE、
+  带 padding 掩码与滑动窗口的 flash attention。行数 M 为运行时符号，每个 kernel 只编译一次。
+* `fast_laya.py` — 用上述 kernel 重写整个编码器 + 决策头前向，bf16 权重常驻，按 (batch, L) 桶捕获 CUDA Graph。
+  `accelerate(agent)` 原地替换 `agent.model.forward`。
+* `test_kernels.py` / `verify_and_bench.py` — 单 kernel 对拍、端到端数值一致性与延迟对比。
+* `tune.py` — tile 参数扫描。

code/apps/BROWSER_AGENT.md

@@ -0,0 +1,34 @@
+# laya 作为浏览器 agent 的决策模型（替代 TypeSafe Jev）
+
+[jev-ultrafast](https://github.com/browser-use/jev-ultrafast) 的 `/v1/systemone` 请求/响应格式与 `laya.predict(state, questions)` 完全一致，
+所以本地 laya（+TileLang 加速）可以直接替代 TypeSafe API。克隆在 `../jev-ultrafast`，`model.py` 已打补丁支持
+`TYPESAFE_BASE_URL` 和 `TEXT_MODEL_EXTRA_JSON`。
+
+```fish
+# 1. 无头 Chromium（远程调试端口 9222）
+chromium --headless=new --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-profile about:blank &
+# 2. 本地 laya systemone 服务（typed | multilingual | english；第 3 个参数是选项分块宽度）
+source env.sh; .venv/bin/python apps/systemone_server.py 8791 typed 12 &
+# 3. TYPE_TEXT 用本地 sglang + Qwen（可选）
+HF_HUB_OFFLINE=1 ~/sglang-venv/bin/python -m sglang.launch_server --model-path Qwen/Qwen3-8B-AWQ --port 30000 \
+    --mem-fraction-static 0.5 --context-length 8192 --reasoning-parser qwen3 &
+# 4. 跑任务
+cd ../jev-ultrafast; .venv/bin/python ../laya/apps/browser_task.py "https://en.wikipedia.org/wiki/Main_Page" "Click the 'Random article' link."
+# 诊断：真实元素表上直接问 laya 该点哪个（格式 jev|compact，后面是打乱平均次数）
+.venv/bin/python ../laya/apps/browser_diag.py compact 4
+```
+
+`systemone_server.py` 做了两件适配：把 jev 的 dict 型元素描述压成一行字符串；超过 N 个选项的 choice 问题
+分块粗筛 + 决赛（两次前向），53 个元素约 150 ms。
+
+## 结论（2026-09-20，零样本，Wikipedia 首页 46 个可点元素）
+
+| checkpoint | jev 原格式 top-1 | 精简格式 top-1 | 精简+4 次打乱平均 top-1 | 平均排名 |
+|---|---|---|---|---|
+| laya (english) | 0/3 | 0/3 | 1/3 | 2.7 / 46 |
+| laya-multilingual | 0/3 | 0/3 | 0/3 | 5.3 / 46 |
+| laya-typed-decisions | 0/3 | 1/3 | 1/3 | 3.7 / 46 |
+
+管线（Chromium → browser-harness → jev 循环 → 本地 laya）跑通且每步 60-150 ms，但三个 checkpoint 零样本都
+无法可靠选中目标元素（强烈偏向第 1 个选项），端到端任务全部失败。这与 laya 自己的说明一致：typed-decisions
+零样本 0.36，需要针对任务微调。要真正替代 Jev，下一步是用 Qwen 当 teacher 在录制的页面状态上生成决策数据，微调 laya。

code/apps/browser_diag.py

@@ -0,0 +1,56 @@
+"""Direct diagnostic: can laya pick the right element on a real Wikipedia element table, under different prompt formats?"""
+import json, os, random, sys, time
+import httpx
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast")
+os.environ["BU_CDP_URL"] = "http://127.0.0.1:9222"
+from jev_ultrafast.browser import Browser
+from jev_ultrafast.model import action_space
+from jev_ultrafast.questions import NEXT_ACTION, TARGET
+
+S1 = "http://127.0.0.1:8791/v1/systemone"
+page = None
+def get_page():
+    global page
+    if page is None:
+        b = Browser("https://en.wikipedia.org/wiki/Main_Page"); page = b.observe(screenshot=False); b.close()
+    return page
+
+GOALS = [("Click the 'Random article' link in the navigation.", "Random article"),
+         ("Open the site's search box so a query can be typed.", "Search"),
+         ("Log in to Wikipedia.", "Log in"),
+         ("Open the Talk page for the main page.", "Talk"),
+         ("Read the community portal.", "Community portal")]
+
+def ask(state, questions):
+    r = httpx.post(S1, json={"model": "x", "state": state, "questions": questions}, timeout=120).json()
+    return r["answers"]
+
+def run(fmt, K=1):
+    p = get_page(); elements, targets, controls = action_space(p["actions"])
+    cands = targets["CLICK"]
+    hits, ranks = 0, []
+    for goal, want in GOALS:
+        gold = [i for i, a in cands.items() if a["label"].split(" → ")[0].strip().lower() == want.lower()]
+        if not gold: print("  no gold for", want); continue
+        if fmt == "jev":
+            crit = {i: {"element": f"[{i}] {a['label']}", "current_value": a.get("current_value", a.get("value", "")), **{k: a[k] for k in ("role", "checked", "selected", "expanded") if k in a}} for i, a in cands.items()}
+            state = {"page": {k: p[k] for k in ("url", "title", "text")}, "elements": elements, "recent_actions": []}
+            ins = {"goal": goal, "operation": "CLICK", "rules": [NEXT_ACTION, TARGET]}
+        else:
+            crit = {i: a["label"].split(" → ")[0][:60] for i, a in cands.items()}
+            state = {"goal": goal, "page_title": p["title"], "url": p["url"]}
+            ins = f"Goal: {goal}  Which element should be clicked next?"
+        probs = {i: 0.0 for i in crit}
+        for k in range(K):
+            keys = list(crit); random.Random(k).shuffle(keys) if K > 1 else None
+            a = ask(state, {"t": {"type": "choice", "instructions": ins, "criteria": {i: crit[i] for i in keys}}})["t"]
+            for i, v in a["probabilities"].items(): probs[i] += v / K
+        order = sorted(probs, key=probs.get, reverse=True)
+        rank = min(order.index(g) for g in gold) + 1
+        ranks.append(rank); hits += rank == 1
+        print(f"  {want:18s} gold={gold} top={order[:3]} p_gold={max(probs[g] for g in gold):.3f} rank={rank}")
+    print(f"  => top1 {hits}/{len(ranks)}  mean rank {sum(ranks)/len(ranks):.1f} of {len(cands)}")
+
+fmt = sys.argv[1]; K = int(sys.argv[2]) if len(sys.argv) > 2 else 1
+print(f"== format={fmt} permutations={K}  variant={httpx.get('http://127.0.0.1:8791/').json()['variant']}")
+run(fmt, K)

code/apps/browser_suite.py

@@ -0,0 +1,92 @@
+"""Real-task suite for the browser agent with automatic outcome checks (URL / title / page text).
+
+    python apps/browser_suite.py [name-filter]       (services: chromium 9222, laya systemone 8791, sglang 30000)
+
+Prints one line per task: PASS/FAIL, steps, wall time, and a summary table.
+"""
+import json, os, re, sys, time
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast")
+os.environ.update(BU_CDP_URL="http://127.0.0.1:9222", TYPESAFE_BASE_URL="http://127.0.0.1:8791", TYPESAFE_API_KEY="local",
+                  TEXT_MODEL_API_KEY="local", TEXT_MODEL_BASE_URL="http://127.0.0.1:30000/v1", TEXT_MODEL="Qwen/Qwen3-8B-AWQ",
+                  TEXT_MODEL_EXTRA_JSON='{"chat_template_kwargs": {"enable_thinking": false}}')
+from jev_ultrafast import Agent
+
+# (name, url, goal, check(url, title, text) -> bool)
+TASKS = [
+    # NOTE: Wikipedia's 'Random article' link sits in a collapsed menu that the DOM reader never observes -> search task instead
+    ("wiki-einstein", "https://en.wikipedia.org/wiki/Main_Page", "Open the Wikipedia article about Albert Einstein.",
+     lambda u, t, x: "Albert_Einstein" in u),
+    ("wiki-search", "https://en.wikipedia.org/wiki/Main_Page", "Search Wikipedia for 'Python programming language' and open the article about the Python language.",
+     lambda u, t, x: "Python" in t),
+    ("hn-new", "https://news.ycombinator.com/", "Open the 'new' page that lists the newest submissions.",
+     lambda u, t, x: u.rstrip("/").endswith("/newest")),
+    ("hn-login-page", "https://news.ycombinator.com/", "Go to the login page.",
+     lambda u, t, x: "login" in u),
+    ("gh-issues", "https://github.com/tile-ai/tilelang", "Open the Issues tab of this repository.",
+     lambda u, t, x: "/issues" in u),
+    ("py-downloads", "https://www.python.org/", "Go to the Downloads page.",
+     lambda u, t, x: "/downloads" in u),
+    ("books-travel", "https://books.toscrape.com/", "Open the 'Travel' category.",
+     lambda u, t, x: "travel" in u),
+    ("books-open-book", "https://books.toscrape.com/", "Open the product page of the book 'A Light in the Attic'.",
+     lambda u, t, x: "a-light-in-the-attic" in u),
+    # NOTE: jev's snapshot.js hides password fields by design, so password logins are impossible in this framework.
+    ("internet-dropdown", "https://the-internet.herokuapp.com/dropdown", "Select 'Option 2' in the dropdown.",
+     lambda u, t, x: False),  # checked via page state below
+    ("internet-checkbox", "https://the-internet.herokuapp.com/checkboxes", "Tick the first checkbox.",
+     lambda u, t, x: False),
+    ("books-page2", "https://books.toscrape.com/", "Go to page 2 of the catalogue.",
+     lambda u, t, x: "page-2" in u),
+    ("quotes-tag-love", "https://quotes.toscrape.com/", "Show the quotes tagged 'love'.",
+     lambda u, t, x: "/tag/love" in u),
+    ("hn-past", "https://news.ycombinator.com/", "Open the 'past' page (front pages from previous days).",
+     lambda u, t, x: "/front" in u),
+    ("ddg-search", "https://duckduckgo.com/", "Search for 'tilelang github' and show the results.",
+     lambda u, t, x: "q=" in u and "tilelang" in u.lower()),
+    ("arxiv-search", "https://arxiv.org/", "Search arXiv for 'flash attention' papers and show the results list.",
+     lambda u, t, x: "search" in u and "flash" in u.lower()),
+    ("flights", "https://www.google.com/travel/flights?hl=en", "Find one-way flights from Zurich to London on September 28, 2026, for one adult in economy. Stop when matching flight options are visible.",
+     lambda u, t, x: ("ZRH" in x or "Zurich" in x or "Zürich" in x) and "London" in x and re.search(r"\b\d{1,2}:\d{2}\b", x) is not None and "one way" in x.lower()),
+]
+
+def run(name, url, goal, check, max_steps=20):
+    t0 = time.time(); steps = 0; status = "error"; page = None
+    try:
+        with Agent(url, goal) as agent:
+            page = agent.state["page"]
+            for state in agent.run():
+                steps = len(state["history"]); status = state["status"]; page = state["page"]
+                if steps >= max_steps: break
+            time.sleep(1.5)                                  # let a slow navigation (GitHub's Turbo, etc.) land before judging
+            try:
+                page = agent.browser.observe(screenshot=False)
+            except Exception:
+                pass
+    except Exception as e:
+        status = f"error:{type(e).__name__}"
+    wall = time.time() - t0
+    ok = bool(page and check(page["url"], page["title"], page.get("text", "")))
+    if page and name == "internet-dropdown":
+        ok = any(a.get("kind") == "select" and str(a.get("current_value", "")).strip() in ("2", "Option 2") for a in page["actions"])
+    if page and name == "internet-checkbox":
+        cbs = [a for a in page["actions"] if a.get("role") == "checkbox"]
+        ok = bool(cbs) and bool(cbs[0].get("checked"))
+    return ok, steps, status, wall, (page or {}).get("url", "")
+
+if __name__ == "__main__":
+    flt = sys.argv[1] if len(sys.argv) > 1 else ""
+    repeats = int(os.environ.get("REPEATS", "1"))
+    rows = []
+    for name, url, goal, check in TASKS:
+        if flt and flt not in name: continue
+        for rep in range(repeats):
+            ok, steps, status, wall, final = run(name, url, goal, check)
+            rows.append((name, ok, steps, status, wall))
+            print(f"{'PASS' if ok else 'FAIL'}  {name:16s} steps={steps:2d} status={status:9s} {wall:5.1f}s  {final[:70]}", flush=True)
+    n = sum(r[1] for r in rows)
+    print(f"\n== {n}/{len(rows)} passed ({100*n/len(rows):.0f}%, {repeats} run(s) per task) | median wall {sorted(r[4] for r in rows)[len(rows)//2]:.1f}s")
+    if repeats > 1:
+        per = {}
+        for r in rows: per.setdefault(r[0], []).append(r[1])
+        print("   per task: " + "  ".join(f"{k}={sum(v)}/{len(v)}" for k, v in per.items()))
+    json.dump([dict(zip(("name", "pass", "steps", "status", "wall"), r)) for r in rows], open(os.environ.get("SUITE_OUT", "/tmp/suite.json"), "w"), indent=1)

code/apps/browser_task.py

@@ -0,0 +1,18 @@
+import os, sys, json, time
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast")
+os.environ.update(BU_CDP_URL="http://127.0.0.1:9222", TYPESAFE_BASE_URL="http://127.0.0.1:8791", TYPESAFE_API_KEY="local",
+                  TEXT_MODEL_API_KEY="local", TEXT_MODEL_BASE_URL="http://127.0.0.1:30000/v1", TEXT_MODEL="Qwen/Qwen3-4B-AWQ",
+                  TEXT_MODEL_EXTRA_JSON='{"chat_template_kwargs": {"enable_thinking": false}}')
+from jev_ultrafast import Agent
+url = sys.argv[1]; goal = sys.argv[2]
+t = time.time()
+with Agent(url, goal) as agent:
+    print("elements on first page:", len(agent.snapshot()["elements"]), "| title:", agent.state["page"]["title"])
+    for state in agent.run():
+        h = state["history"][-1] if state["history"] else None
+        d = state["decisions"][-1] if state["decisions"] else None
+        print(f"{state['elapsed_ms']:6d} ms  status={state['status']:9s}  op={d['operation'] if d else None:9s} "
+              f"conf={d['confidence'] if d else 0:.2f} model={d['latency_ms'] if d else 0:4d}ms  "
+              f"action={h['action'][:60] if h else None}  text={h['text'] if h else None}")
+        if len(state["history"]) > 25: break
+    print("FINAL:", state["status"], "| url:", state["page"]["url"], "| title:", state["page"]["title"], "| wall", round(time.time() - t, 1), "s")

code/apps/common.py

@@ -0,0 +1,61 @@
+"""Shared helpers: model loading + pretty printing."""
+import os, sys, time
+os.environ.setdefault("USE_TF", "0")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+_AGENTS = {}
+
+def get_agent(variant="english"):
+    """variant: english | multilingual | typed"""
+    if variant in _AGENTS:
+        return _AGENTS[variant]
+    import laya
+    t = time.time()
+    if os.path.isdir(variant):
+        a = laya.load(variant)
+    elif variant == "english":
+        # download only the root checkpoint (the other subfolders are several GB each)
+        from huggingface_hub import snapshot_download
+        path = snapshot_download("convaiinnovations/laya", ignore_patterns=["multilingual/*", "typed-decisions/*"])
+        a = laya.load(path)
+    elif variant == "multilingual":
+        a = laya.load("convaiinnovations/laya", subfolder="multilingual")
+    else:
+        from huggingface_hub import snapshot_download
+        path = snapshot_download("convaiinnovations/laya", allow_patterns=["typed-decisions/*"])
+        a = laya.load(path, subfolder="typed-decisions")
+    print(f"[laya] loaded {variant} in {time.time()-t:.1f}s", file=sys.stderr)
+    if os.environ.get("LAYA_FAST", "1") == "1":
+        try:
+            sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "kernels"))
+            try:
+                from fast_laya import accelerate      # laya/kernels layout
+                accelerate(a)
+            except ImportError:
+                from fast import FastLaya             # code/kernels layout (this repo)
+                fl = FastLaya(a.model, max_len=a.cfg.get("max_len", 1024)); a._fast = fl; a.model.forward = fl.forward
+            print("[laya] TileLang fast path enabled (LAYA_FAST=0 to disable)", file=sys.stderr)
+        except Exception as e:
+            print(f"[laya] fast path unavailable: {e}", file=sys.stderr)
+    _AGENTS[variant] = a
+    return a
+
+def bar(p, width=20):
+    n = int(round(p * width))
+    return "█" * n + "░" * (width - n)
+
+def show(result, indent="  "):
+    """Pretty-print a laya predict() result."""
+    for name, a in result["answers"].items():
+        t = a["type"]
+        if t == "choice":
+            print(f"{indent}{name}: {a['choice']}  (conf {a['confidence']:.2f})")
+            for k, v in sorted(a["probabilities"].items(), key=lambda kv: -kv[1]):
+                print(f"{indent}    {bar(v)} {v:5.2f}  {k}")
+        elif t == "score":
+            print(f"{indent}{name}: score={a['score']:.2f}  (conf {a['confidence']:.2f})")
+            for k, v in a["probabilities"].items():
+                print(f"{indent}    {bar(v)} {v:5.2f}  {a['legend'][k]}")
+        else:
+            p = a["noul"]
+            print(f"{indent}{name}: P(true)={p:.2f}  {bar(p)}")

code/apps/fast_batch.py

@@ -0,0 +1,89 @@
+"""One-shot batched predict for laya: tokenize the shared state once, build every question's sequence from cached ids,
+single forward, vectorised post-processing.  Same outputs as agent.predict() (up to float rounding).
+
+    from fast_batch import predict_fast, profile_step
+"""
+import json, time
+import numpy as np, torch
+from laya.common import QTYPES, collate_items, confidence_from_probs, render_options, serialize_state, temp_bucket
+
+
+def build_items(agent, state, questions):
+    tok = agent.tok
+    max_len, head_max_len = agent.cfg.get("max_len", 512), agent.cfg.get("head_max_len", 192)
+    mask_tok, mask_id = tok.mask_token, tok.mask_token_id
+    st_ids = None                                        # shared state tokens, computed lazily once
+    items, meta = [], []
+    for qid, qdef in questions.items():
+        q = agent._to_internal(qdef)
+        opts = render_options(q)
+        ins = str(q["ins"]).replace(mask_tok, " ")
+        head_ids = tok("%s question: %s" % (q["t"], ins), add_special_tokens=False)["input_ids"]
+        opt_txt = [" " + o.replace(mask_tok, " ") for o in opts]
+        opt_enc = tok(opt_txt, add_special_tokens=False)["input_ids"]     # one batched tokenizer call for all options
+        opt_ids = [[mask_id] + o[:48] for o in opt_enc]
+        opt_budget = head_max_len - sum(len(o) for o in opt_ids)
+        if opt_budget < 16:
+            per = max(4, (head_max_len - 16) // max(1, len(opt_ids)))
+            opt_ids = [o[:per] for o in opt_ids]
+            opt_budget = head_max_len - sum(len(o) for o in opt_ids)
+        head_ids = head_ids[: max(8, opt_budget)]
+        ids = [tok.cls_token_id] + head_ids + [tok.sep_token_id]
+        markers = []
+        for o in opt_ids:
+            markers.append(len(ids)); ids.extend(o)
+        ids.append(tok.sep_token_id)
+        room = max(0, max_len - len(ids) - 1)
+        if st_ids is None:
+            st_ids = tok(serialize_state(state).replace(mask_tok, " "), add_special_tokens=False)["input_ids"]
+        ids = (ids + st_ids[:room] + [tok.sep_token_id])[:max_len]
+        markers = [m for m in markers if m < max_len]
+        if len(markers) != len(opts):
+            raise ValueError("question %r options exceed head_max_len=%d" % (qid, head_max_len))
+        items.append({"ids": ids, "markers": markers, "qtype": QTYPES[q["t"]]})
+        meta.append((qid, q, len(markers)))
+    return items, meta
+
+
+@torch.no_grad()
+def predict_fast(agent, state, questions, timing=None):
+    t0 = time.perf_counter()
+    items, meta = build_items(agent, state, questions)
+    b = collate_items([items], agent.tok.pad_token_id)
+    t1 = time.perf_counter()
+    dev = agent.device
+    with torch.autocast(device_type=dev.type, dtype=agent.dtype, enabled=dev.type == "cuda"):
+        logits, act = agent.model(b["input_ids"].to(dev, non_blocking=True), b["attention_mask"].to(dev, non_blocking=True),
+                                  b["marker_pos"].to(dev, non_blocking=True), b["marker_mask"].to(dev, non_blocking=True), b["qtype"].to(dev, non_blocking=True))
+    logits = logits.float().cpu().numpy(); act = torch.softmax(act.float(), -1).cpu().numpy()
+    t2 = time.perf_counter()
+    answers = {}
+    for r, (qid, q, k) in enumerate(meta):
+        qt = QTYPES[q["t"]]
+        t_scale = agent.temperature_by_options.get(temp_bucket(qt, k), agent.temperature[qt])
+        z = logits[r, :k] / max(1e-3, float(t_scale)); p = np.exp(z - z.max()); p /= p.sum()
+        conf = round(confidence_from_probs(p, k), 4); ext = {"act_probability": round(float(act[r, 0]), 4)}
+        if q["t"] == "choice":
+            keys = list(q["crit"].keys())
+            answers[qid] = {"type": "choice", "choice": keys[int(p.argmax())], "probabilities": {kk: round(float(v), 4) for kk, v in zip(keys, p)}, "confidence": conf, "action": ext}
+        elif q["t"] == "score":
+            answers[qid] = {"type": "score", "score": round(float((np.arange(k) * p).sum()), 4), "legend": {str(i): c for i, c in enumerate(q["crit"])},
+                            "probabilities": {str(i): round(float(v), 4) for i, v in enumerate(p)}, "confidence": conf, "action": ext}
+        else:
+            answers[qid] = {"type": "noul", "noul": round(float(p[1]), 4), "confidence": round(max(float(p[1]), 1 - float(p[1])), 4), "action": ext}
+    t3 = time.perf_counter()
+    if timing is not None:
+        timing.update(tokenize_ms=(t1 - t0) * 1e3, forward_ms=(t2 - t1) * 1e3, post_ms=(t3 - t2) * 1e3, tokens=int(b["attention_mask"].sum()))
+    return {"model": "laya-rl-agent", "answers": answers, "usage": {"input_tokens": int(b["attention_mask"].sum()), "output_tokens": 0}}
+
+
+def profile_step(agent, state, questions, n=20):
+    """Compare agent.predict vs predict_fast on one recorded browser step."""
+    for _ in range(3): agent.predict(state, questions); predict_fast(agent, state, questions)
+    torch.cuda.synchronize(); t = time.perf_counter()
+    for _ in range(n): agent.predict(state, questions)
+    torch.cuda.synchronize(); slow = (time.perf_counter() - t) / n * 1e3
+    tm = {}; torch.cuda.synchronize(); t = time.perf_counter()
+    for _ in range(n): predict_fast(agent, state, questions, tm)
+    torch.cuda.synchronize(); fast = (time.perf_counter() - t) / n * 1e3
+    return {"predict_ms": slow, "predict_fast_ms": fast, **tm}

code/apps/hn_radar.py

@@ -0,0 +1,44 @@
+"""Hacker News 雷达：拉取实时热帖标题，用 laya 给每条打 主题/是否硬核技术/是否值得读 标签。
+用法: python apps/hn_radar.py [N=30]
+"""
+import os, sys, json, time, urllib.request
+from common import get_agent, bar
+
+QUESTIONS = {
+    "topic": {"type": "choice", "instructions": "What is this Hacker News story about?",
+              "criteria": {"ai": "machine learning, LLMs, models", "systems": "OS, compilers, databases, hardware, GPUs",
+                           "web": "frontend, browsers, web frameworks", "security": "vulnerabilities, hacking, privacy",
+                           "business": "startups, funding, layoffs, policy", "science": "physics, biology, space, math",
+                           "other": "anything else"}},
+    "technical_depth": {"type": "score", "instructions": "How technically deep is this likely to be?",
+                        "criteria": ["fluff", "medium", "deep dive"]},
+    "showhn": {"type": "noul", "instructions": "Is this a project someone built and is showing off?"},
+}
+
+def fetch(n):
+    """One request to the HN Algolia API (front page)."""
+    r = json.load(urllib.request.urlopen(f"https://hn.algolia.com/api/v1/search?tags=front_page&hitsPerPage={n}", timeout=20))
+    return [{"title": h["title"], "url": h.get("url") or "", "score": h.get("points", 0)} for h in r["hits"] if h.get("title")]
+
+def main():
+    n = int(sys.argv[1]) if len(sys.argv) > 1 else 30
+    print(f"fetching {n} HN top stories...")
+    items = fetch(n)
+    agent = get_agent(os.environ.get("LAYA_VARIANT", "multilingual"))
+    t = time.time()
+    res = [agent.predict({"title": it["title"], "url": it.get("url", "")}, QUESTIONS) for it in items]
+    dt = time.time() - t
+    print(f"classified {len(items)} in {dt*1000:.0f} ms\n")
+    by_topic = {}
+    for it, r in zip(items, res):
+        a = r["answers"]
+        by_topic.setdefault(a["topic"]["choice"], []).append((round(a["technical_depth"]["score"],1), a["showhn"]["noul"], it))
+    for topic, lst in sorted(by_topic.items(), key=lambda kv: -len(kv[1])):
+        print(f"## {topic}  ({len(lst)})")
+        for depth, show_p, it in sorted(lst, key=lambda x: -(x[0] or 0)):
+            tag = " [show]" if show_p > 0.5 else ""
+            print(f"  depth={depth} ↑{it.get('score',0):<4} {it['title'][:70]}{tag}")
+        print()
+
+if __name__ == "__main__":
+    main()

code/apps/inbox_triage.py

@@ -0,0 +1,43 @@
+"""多语言工单/邮件分诊：一次前向传播同时回答 部门 / 紧急度 / 流失风险 / 情绪。
+用法: python apps/inbox_triage.py            # 跑内置样例（中/英/日/西/印地语）
+      python apps/inbox_triage.py "你的邮件正文"
+"""
+import sys, json, time
+from common import get_agent, show
+
+QUESTIONS = {
+    "department": {"type": "choice", "instructions": "Which team should handle this message?",
+                   "criteria": {"billing": "invoices, payments, refunds, double charge",
+                                "technical": "bugs, crashes, outages, login failures",
+                                "sales": "pricing, quotes, upgrades, enterprise plans",
+                                "shipping": "delivery, tracking, lost or damaged package"}},
+    "urgency": {"type": "score", "instructions": "How urgent is this?",
+                "criteria": ["not urgent", "soon", "blocking"]},
+    "churn_risk": {"type": "noul", "instructions": "Does the user threaten to cancel or leave?"},
+    "sentiment": {"type": "choice", "instructions": "What is the customer's tone?",
+                  "criteria": {"angry": "furious, threatening, insulting",
+                               "frustrated": "annoyed but civil", "neutral": "matter of fact",
+                               "happy": "grateful, positive"}},
+}
+
+SAMPLES = [
+    {"subject": "Duplicate charge on invoice 4411",
+     "body": "We were billed twice for March. Please refund the duplicate or we're moving to a competitor."},
+    {"subject": "登录一直失败", "body": "从昨天开始整个团队都登录不了后台，报 502，我们的上线被卡住了，急！"},
+    {"subject": "見積もりのお願い", "body": "エンタープライズプランの料金と年間契約の割引について教えてください。"},
+    {"subject": "Paquete perdido", "body": "El rastreo dice entregado pero no recibí nada. Llevo una semana esperando, estoy muy molesto."},
+    {"subject": "धन्यवाद", "body": "आपकी टीम ने मेरी समस्या बहुत जल्दी हल कर दी। बहुत बहुत धन्यवाद!"},
+]
+
+def main():
+    agent = get_agent("multilingual")
+    states = [{"subject": "(cli)", "body": " ".join(sys.argv[1:])}] if len(sys.argv) > 1 else SAMPLES
+    for s in states:
+        t = time.time()
+        r = agent.predict(s, QUESTIONS)
+        dt = (time.time() - t) * 1000
+        print(f"\n=== {s['subject']}  [{dt:.0f} ms]\n    {s['body'][:80]}")
+        show(r)
+
+if __name__ == "__main__":
+    main()

code/apps/make_demo.py

@@ -0,0 +1,112 @@
+"""Record a short demo video of laya driving a real browser through jev-ultrafast.
+
+    python apps/make_demo.py out_dir          (services: chromium :9222, laya systemone :8791; no text model needed)
+
+Runs a few click-only tasks with frame recording, overlays goal / laya's decision / per-step latency, renders MP4 + GIF via ffmpeg.
+"""
+import base64, json, os, shutil, subprocess, sys, time
+from pathlib import Path
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast")
+os.environ.update(BU_CDP_URL="http://127.0.0.1:9222", TYPESAFE_BASE_URL="http://127.0.0.1:8791", TYPESAFE_API_KEY="local", TEXT_MODEL_API_KEY="local")
+from PIL import Image, ImageDraw, ImageFont
+from jev_ultrafast import Agent
+
+TASKS = [
+    ("https://books.toscrape.com/", "Open the 'Travel' category."),
+    ("https://books.toscrape.com/", "Open the product page of the book 'A Light in the Attic'."),
+    ("https://www.python.org/", "Go to the Downloads page."),
+    ("https://quotes.toscrape.com/", "Show the quotes tagged 'love'."),
+    ("https://news.ycombinator.com/", "Open the 'past' page (front pages from previous days)."),
+    ("https://the-internet.herokuapp.com/checkboxes", "Tick the first checkbox."),
+]
+W, H = 1120, 780; BAR_T, BAR_B = 64, 96; FPS = 24
+F_REG = "/usr/share/fonts/TTF/DejaVuSans.ttf"; F_BOLD = "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf"; F_MONO = "/usr/share/fonts/TTF/DejaVuSansMono.ttf"
+def font(n, bold=False): return ImageFont.truetype(F_BOLD if bold else F_REG, n)
+def mono(n): return ImageFont.truetype(F_MONO, n)
+BG, INK, MUTED, GREEN, BLUE = "#0f1115", "#e8e8e8", "#8b93a1", "#3ddc84", "#4f8cff"
+
+def canvas(page_img=None):
+    im = Image.new("RGB", (W, BAR_T + H + BAR_B), BG)
+    if page_img is not None: im.paste(page_img.resize((W, H)), (0, BAR_T))
+    return im
+
+def frame(page_img, goal, step_txt, decision_txt, lat_txt, elapsed_txt, status=None):
+    im = canvas(page_img); d = ImageDraw.Draw(im)
+    d.text((16, 12), "laya-browser", font=font(22, True), fill=GREEN); d.text((190, 16), "System-1 decision head · 322M · local RTX 4070", font=font(15), fill=MUTED)
+    d.text((16, 38), "goal: " + goal, font=font(16), fill=INK)
+    y = BAR_T + H + 12
+    d.text((16, y), step_txt, font=font(15, True), fill=MUTED)
+    d.text((16, y + 24), decision_txt, font=mono(19), fill=INK)
+    d.text((16, y + 54), lat_txt, font=mono(15), fill=BLUE); d.text((W - 200, y + 54), elapsed_txt, font=mono(15), fill=MUTED)
+    if status: d.text((W - 200, y), status, font=font(17, True), fill=GREEN if status == "DONE" else "#ff6b6b")
+    return im
+
+def title_card(lines, sub):
+    im = canvas(); d = ImageDraw.Draw(im); y = 260
+    for i, l in enumerate(lines):
+        d.text((60, y), l, font=font(40 if i == 0 else 26, i == 0), fill=GREEN if i == 0 else INK); y += 64 if i == 0 else 40
+    y += 20
+    for l in sub: d.text((60, y), l, font=font(20), fill=MUTED); y += 32
+    return im
+
+def run_task(url, goal, rec):
+    frames, decisions = [], []
+    with Agent(url, goal, record_dir=str(rec), screenshots=True) as agent:
+        t0 = time.time(); page0 = agent.state["page"]
+        frames.append((0, Image.open(rec / "000000.jpg").convert("RGB"), None))
+        while agent.state["status"] not in ("done", "blocked") and len(agent.state["history"]) < 8:
+            st = agent.command("tick")
+            d = st["decisions"][-1] if st["decisions"] else None
+            h = st["history"][-1] if st["history"] else None
+            lat = d["latency_ms"] if d else 0
+            label = (h["action"] if h and d and h.get("latency_ms") == lat else None)
+            dec = {"op": d["operation"] if d else "?", "target": label or (d.get("target") if d else ""), "conf": d["confidence"] if d else 0, "lat": lat,
+                   "elapsed": st["elapsed_ms"], "status": st["status"]}
+            decisions.append(dec)
+            shots = sorted(p for p in rec.glob("*.jpg") if p.stem != "000000")
+            img = Image.open(shots[-1]).convert("RGB") if shots else frames[-1][1]
+            frames.append((st["elapsed_ms"], img, dec))
+        final = agent.state
+    return frames, decisions, final
+
+def main():
+    out = Path(sys.argv[1]); shutil.rmtree(out, ignore_errors=True); (out / "frames").mkdir(parents=True)
+    n = 0
+    def emit(im, secs):
+        nonlocal n
+        for _ in range(int(secs * FPS)):
+            im.save(out / "frames" / f"{n:06d}.png"); n += 1
+    emit(title_card(["laya-browser", "one bidirectional encoder pass per step -> operation + target + calibrated confidence",
+                     "no text generation, ~20 ms per decision on an RTX 4070, 1.5 GB VRAM"],
+                    ["fine-tuned from convaiinnovations/laya on crawled pages + Mind2Web + on-policy corrections",
+                     "driving browser-use/jev-ultrafast through its TypeSafe-compatible /v1/systemone API"]), 3.5)
+    totals = {"steps": 0, "lat": [], "wall": 0.0, "tasks_ok": 0}
+    for i, (url, goal) in enumerate(TASKS):
+        rec = out / f"rec{i}"; rec.mkdir()
+        try:
+            t = time.time(); frames, decisions, final = run_task(url, goal, rec); wall = time.time() - t
+        except Exception as e:
+            print("task failed:", goal, type(e).__name__, str(e)[:60]); continue
+        ok = final["status"] == "done"
+        totals["steps"] += len(decisions); totals["lat"] += [d["lat"] for d in decisions]; totals["wall"] += wall; totals["tasks_ok"] += ok
+        print(f"{goal[:50]:50s} steps={len(decisions)} status={final['status']} wall={wall:.1f}s decisions={[ (d['op'], d['lat']) for d in decisions]}", flush=True)
+        # observed page, then each decision: show the page it decided on with the decision, then the resulting page
+        emit(frame(frames[0][1], goal, "step 0 · observe page", "laya reads the element table ...", "", "t = 0 ms"), 1.2)
+        for k, (ms, img, dec) in enumerate(frames[1:], 1):
+            prev = frames[k - 1][1]
+            dtxt = f"{dec['op']}  ->  {str(dec['target'])[:48]}" if dec["op"] not in ("DONE", "BLOCKED") else dec["op"]
+            emit(frame(prev, goal, f"step {k} · decide", dtxt, f"laya: {dec['lat']} ms  (confidence {dec['conf']:.2f})", f"t = {dec['elapsed']} ms"), 1.3)
+            if dec["op"] not in ("DONE", "BLOCKED"):
+                emit(frame(img, goal, f"step {k} · executed", dtxt, f"laya: {dec['lat']} ms", f"t = {dec['elapsed']} ms"), 1.0)
+            else:
+                emit(frame(img, goal, f"step {k}", dtxt, f"laya: {dec['lat']} ms", f"t = {dec['elapsed']} ms", status=dec["op"]), 1.6)
+    lat = sorted(totals["lat"]); med = lat[len(lat) // 2] if lat else 0
+    emit(title_card(["that's laya as a browser agent's System 1", f"{totals['tasks_ok']}/{len(TASKS)} tasks · {totals['steps']} decisions · median {med} ms per decision",
+                     f"total wall time {totals['wall']:.1f} s including page loads"],
+                    ["model + code + numbers: huggingface.co/cklxx/laya-browser", "TileLang fused kernels + CUDA graphs: github.com/NandhaKishorM/laya/pull/25"]), 4.0)
+    subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-framerate", str(FPS), "-i", str(out / "frames" / "%06d.png"), "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "23", str(out / "laya_browser_demo.mp4")], check=True)
+    subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", str(out / "laya_browser_demo.mp4"), "-vf", "fps=8,scale=700:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=128[p];[s1][p]paletteuse=dither=bayer", str(out / "laya_browser_demo.gif")], check=True)
+    print("video:", out / "laya_browser_demo.mp4", f"{(out / 'laya_browser_demo.mp4').stat().st_size/1e6:.1f} MB", "| gif:", f"{(out / 'laya_browser_demo.gif').stat().st_size/1e6:.1f} MB", "| frames", n, f"({n/FPS:.0f}s)")
+
+if __name__ == "__main__":
+    main()

code/apps/moderator.py

@@ -0,0 +1,47 @@
+"""内容审核台：给一批评论打 有害/垃圾/需人工复核 的校准概率，并按风险排序。
+用法: python apps/moderator.py [file.txt]   # 每行一条评论；无参数用内置样例
+"""
+import sys, time
+from common import get_agent, bar
+
+QUESTIONS = {
+    "toxic": {"type": "noul", "instructions": "Is this comment abusive, hateful or harassing toward someone?"},
+    "spam": {"type": "noul", "instructions": "Is this comment spam or unsolicited advertising?"},
+    "topic": {"type": "choice", "instructions": "What is the comment mainly about?",
+              "criteria": {"product": "the product or service itself", "politics": "political opinion",
+                           "personal": "attacks or remarks about a person", "offtopic": "unrelated chatter"}},
+    "severity": {"type": "score", "instructions": "How severe is the policy violation, if any?",
+                 "criteria": ["none", "mild", "serious", "ban-worthy"]},
+}
+
+SAMPLES = [
+    "This update is great, the new editor is so much faster!",
+    "Buy cheap followers now!!! visit my profile link, 50% off today only",
+    "You are a worthless idiot and everyone here knows it.",
+    "这个功能真的太难用了，建议回滚到上个版本。",
+    "滚出去，你这种垃圾不配在这发言。",
+    "Honestly both parties are the same, nothing will change.",
+    "Does anyone know if the API supports webhooks?",
+]
+
+def main():
+    agent = get_agent("multilingual")
+    texts = [l.strip() for l in open(sys.argv[1], encoding="utf-8") if l.strip()] if len(sys.argv) > 1 else SAMPLES
+    t = time.time()
+    results = [agent.predict({"comment": c}, QUESTIONS) for c in texts]
+    dt = time.time() - t
+    rows = []
+    for c, r in zip(texts, results):
+        a = r["answers"]
+        risk = max(a["toxic"]["noul"], a["spam"]["noul"])
+        rows.append((risk, a["toxic"]["noul"], a["spam"]["noul"],
+                     a["topic"]["choice"], round(a["severity"]["score"],1), c))
+    rows.sort(reverse=True)
+    print(f"{len(texts)} comments in {dt*1000:.0f} ms  ({dt*1000/len(texts):.0f} ms each)\n")
+    print(f"{'risk':>5} {'toxic':>5} {'spam':>5}  {'topic':9} {'sev':>4}  comment")
+    for risk, tox, spam, topic, sev, c in rows:
+        flag = "🚨" if risk > 0.7 else ("⚠️ " if risk > 0.4 else "  ")
+        print(f"{flag}{risk:5.2f} {tox:5.2f} {spam:5.2f}  {topic:9} {str(sev):>4}  {c[:60]}")
+
+if __name__ == "__main__":
+    main()

code/apps/profile_step.py

@@ -0,0 +1,17 @@
+"""Time one real browser step (recorded in finetune/out/dagger_cases.jsonl) end to end inside the server process.
+    python apps/profile_step.py <checkpoint dir>"""
+import json, os, sys
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))); sys.path.insert(0, "/home/ckl/projects/S/laya/finetune")
+os.environ.setdefault("LAYA_FMT", "v2")
+from common import get_agent
+from common_ft import build_request
+from fast_batch import profile_step
+agent = get_agent(sys.argv[1])
+if agent.cfg.get("head_max_len_train"): agent.cfg["head_max_len"] = agent.cfg["head_max_len_train"]
+cases = [json.loads(l) for l in open("/home/ckl/projects/S/laya/finetune/out/dagger_cases.jsonl")]
+for c in cases[:4]:
+    page = c["page_obj"]; state, questions, _, _ = build_request(page, c["goal"], c.get("history", []))
+    n_opts = sum(len(q["criteria"]) for q in questions.values())
+    r = profile_step(agent, state, questions)
+    print(f"{len(questions)} questions / {n_opts:3d} options / {r['tokens']:4d} tokens: agent.predict {r['predict_ms']:6.1f} ms | fast {r['predict_fast_ms']:6.1f} ms "
+          f"(tokenize {r['tokenize_ms']:.1f} + forward {r['forward_ms']:.1f} + post {r['post_ms']:.1f})")

code/apps/systemone_server.py

@@ -0,0 +1,169 @@
+"""TypeSafe-compatible /v1/systemone endpoint backed by a local laya checkpoint (+ TileLang fast path).
+
+    python apps/systemone_server.py [port=8791] [variant=typed|multilingual|english]
+
+Request body: {"model": ..., "state": {...}, "questions": {...}}  ->  {"answers": ..., "model": ..., "usage": ...}
+"""
+import json, os, sys, time, traceback
+from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
+from common import get_agent
+from fast_batch import predict_fast
+
+PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 8791
+VARIANT = sys.argv[2] if len(sys.argv) > 2 else "typed"
+MAXOPT = int(sys.argv[3]) if len(sys.argv) > 3 else 12   # laya's option budget: keep choice questions at most this wide
+agent = get_agent(VARIANT)
+FMT = os.environ.get("LAYA_FMT", agent.cfg.get("laya_fmt", "v1"))   # fine-tuned checkpoints record their format in rl_agent_config.json
+if agent.cfg.get("head_max_len_train"):
+    agent.cfg["head_max_len"] = agent.cfg["head_max_len_train"]
+print(f"[systemone] format={FMT} head_max_len={agent.cfg.get('head_max_len')}", flush=True)
+LOG = []
+
+# ---- System 1 / System 2 gating: below ESCALATE_TAU confidence, ask the LLM teacher (same element table) and return its
+# decision in laya's answer format.  Every escalation is also appended to ESCALATE_LOG as a DAgger case.
+TAU = float(os.environ.get("ESCALATE_TAU", "0"))           # 0 = off
+ESC_URL = os.environ.get("TEXT_MODEL_BASE_URL", "http://127.0.0.1:30000/v1") + "/chat/completions"
+ESC_MODEL = os.environ.get("TEXT_MODEL", "Qwen/Qwen3-8B-AWQ")
+ESC_LOG = os.environ.get("ESCALATE_LOG", "")
+STATS = {"calls": 0, "escalated": 0}
+ESC_SYS = """You are the System-2 fallback for a browser agent. Given the goal, the actions so far, the page and a numbered list of
+controls (each with the operations it supports), pick the single best NEXT step. Answer JSON:
+{"operation": "CLICK"|"TYPE_TEXT"|"SELECT"|"DONE"|"BLOCKED"|"WAIT"|"SCROLL_DOWN"|"SCROLL_UP", "target": "<option key of the chosen control, or null>"}
+DONE only if the goal is already visibly satisfied. A field that already shows the requested value is done; do not re-type it."""
+
+
+def escalate(state, questions, answers):
+    import httpx
+    ops = questions["operation"]["criteria"]
+    controls = []
+    for qid, q in questions.items():
+        if qid.endswith("_target"):
+            op = qid[:-7].upper()
+            for key, desc in q["criteria"].items():
+                controls.append({"op": op, "target": key, "control": desc})
+    user = {"goal": (questions["operation"]["instructions"] or {}).get("goal") if isinstance(questions["operation"]["instructions"], dict) else "",
+            "actions_so_far": state.get("recent_actions", [])[-8:], "page": state.get("page", {}), "operations": list(ops),
+            "controls": controls[:150], "system1_guess": {k: v.get("choice") for k, v in answers.items()}}
+    body = {"model": ESC_MODEL, "max_tokens": 80, "temperature": 0.0, "response_format": {"type": "json_object"},
+            "chat_template_kwargs": {"enable_thinking": False},
+            "messages": [{"role": "system", "content": ESC_SYS}, {"role": "user", "content": json.dumps(user, ensure_ascii=False)}]}
+    r = httpx.post(ESC_URL, json=body, timeout=120).json()
+    v = json.loads(r["choices"][0]["message"]["content"])
+    op = str(v.get("operation", "")).upper(); tgt = v.get("target")
+    if op not in ops:
+        return answers, False
+    def one_hot(keys, k, p=0.97):
+        rest = (1 - p) / max(1, len(keys) - 1)
+        return {kk: (p if kk == k else rest) for kk in keys}
+    answers["operation"] = {**answers["operation"], "choice": op, "probabilities": one_hot(list(ops), op), "confidence": 0.9, "system2": True}
+    tq = op.lower() + "_target"
+    if tq in questions:
+        keys = list(questions[tq]["criteria"]); tgt = str(tgt)
+        if tgt not in keys:
+            return answers, False
+        answers[tq] = {**answers[tq], "choice": tgt, "probabilities": one_hot(keys, tgt), "confidence": 0.9, "system2": True}
+    if ESC_LOG:
+        with open(ESC_LOG, "a") as f:
+            f.write(json.dumps({"state": state, "operation": op, "target": tgt if tq in questions else None}, ensure_ascii=False) + "\n")
+    return answers, True
+
+
+def compact(v):
+    """Shrink jev-ultrafast element criteria ({'element': '[3] Search', 'role': 'button', ...}) into one short string
+    so more options fit laya's head token budget."""
+    if isinstance(v, dict) and "element" in v:
+        s = str(v["element"])[:50 if FMT == "v3" else 10000]
+        if v.get("role"):
+            s += f" ({v['role']})"
+        if v.get("current_value"):
+            s += f" = {str(v['current_value'])[:30]!r}"
+        for k in ("checked", "selected", "expanded"):
+            if k in v:
+                s += f" {k}={v[k]}"
+        return s
+    return v
+
+
+def predict(state, questions):
+    """agent.predict with coarse-to-fine handling of wide choice questions.
+
+    A choice with more than MAXOPT options is split into interleaved chunks; every chunk is a question in the same
+    forward pass as the normal questions, then the chunk winners compete in a second pass.
+    p(option) = p_final(winner of its chunk) * p_chunk(option)."""
+    qs, plan = {}, {}
+    if isinstance(state, dict) and isinstance(state.get("page"), dict) and isinstance(state["page"].get("text"), str):
+        if FMT in ("v2", "v3"):   # mirror finetune/common_ft.py
+            state = {"page": {**state["page"], "text": state["page"]["text"][:1500 if FMT == "v2" else 1200]}, "recent_actions": state.get("recent_actions", [])}
+        else:
+            state = {**state, "page": {**state["page"], "text": state["page"]["text"][:6000]}}
+    for qid, q in questions.items():
+        q = dict(q)
+        if isinstance(q.get("criteria"), dict):
+            q["criteria"] = {k: compact(v) for k, v in q["criteria"].items()}
+        keys = list(q["criteria"]) if q["type"] == "choice" and isinstance(q.get("criteria"), dict) else []
+        if len(keys) <= MAXOPT:
+            qs[qid] = q
+            continue
+        n = -(-len(keys) // MAXOPT)
+        chunks = [keys[i::n] for i in range(n)]
+        plan[qid] = (q, chunks)
+        for ci, ch in enumerate(chunks):
+            qs[f"{qid}__chunk{ci}"] = {**q, "criteria": {k: q["criteria"][k] for k in ch}}
+    r = predict_fast(agent, state, qs)
+    r["passes"] = 1
+    if plan:
+        chunk_ans = {qid: [r["answers"].pop(f"{qid}__chunk{ci}") for ci in range(len(chunks))] for qid, (q, chunks) in plan.items()}
+        finals = {qid: {**q, "criteria": {a["choice"]: q["criteria"][a["choice"]] for a in chunk_ans[qid]}} for qid, (q, _) in plan.items()}
+        r2 = predict_fast(agent, state, finals)
+        r["passes"] = 2
+        r["usage"]["input_tokens"] += r2["usage"]["input_tokens"]
+        for qid, (q, chunks) in plan.items():
+            fa = r2["answers"][qid]
+            probs = {}
+            for ca, ch in zip(chunk_ans[qid], chunks):
+                pf = fa["probabilities"][ca["choice"]]
+                for k in ch:
+                    probs[k] = pf * ca["probabilities"][k]
+            tot = sum(probs.values()) or 1.0
+            probs = {k: round(v / tot, 6) for k, v in probs.items()}
+            choice = max(probs, key=probs.get)
+            r["answers"][qid] = {"type": "choice", "choice": choice, "probabilities": probs, "confidence": fa["confidence"],
+                                 "action": fa.get("action", {}), "coarse_to_fine": {"chunks": len(chunks), "winners": [a["choice"] for a in chunk_ans[qid]]}}
+    return r
+
+
+class H(BaseHTTPRequestHandler):
+    def log_message(self, *a): pass
+    def _send(self, code, body):
+        data = json.dumps(body, ensure_ascii=False).encode()
+        self.send_response(code); self.send_header("Content-Type", "application/json"); self.send_header("Content-Length", str(len(data))); self.end_headers(); self.wfile.write(data)
+    def do_GET(self):
+        self._send(200, {"ok": True, "variant": VARIANT, "calls": len(LOG), "tau": TAU, "escalated": STATS["escalated"], "recent": LOG[-5:]})
+    def do_POST(self):
+        n = int(self.headers.get("Content-Length", 0)); req = json.loads(self.rfile.read(n) or b"{}")
+        try:
+            t = time.perf_counter()
+            r = predict(req["state"], req["questions"])
+            STATS["calls"] += 1
+            if TAU > 0:
+                a = r["answers"]; op = a["operation"]["choice"]; tq = op.lower() + "_target"
+                conf = min(a["operation"]["confidence"], a[tq]["confidence"] if tq in a else 1.0)
+                if conf < TAU:
+                    try:
+                        r["answers"], esc = escalate(req["state"], req["questions"], a)
+                        STATS["escalated"] += esc
+                    except Exception as e:
+                        print("[escalate] failed:", str(e)[:80], flush=True)
+            ms = (time.perf_counter() - t) * 1000
+            r["model"] = f"laya-{VARIANT}"
+            nq = len(req["questions"]); nopt = sum(len(q.get("criteria") or []) for q in req["questions"].values())
+            LOG.append({"ms": round(ms, 1), "questions": nq, "options": nopt, "tokens": r["usage"]["input_tokens"], "passes": r["passes"]})
+            print(f"[systemone] {nq} q / {nopt} opts / {r['usage']['input_tokens']} tok / {r['passes']} pass -> {ms:.1f} ms  " +
+                  ", ".join(f"{k}={v.get('choice', v.get('score', v.get('noul')))}({v['confidence']:.2f})" for k, v in r["answers"].items()), flush=True)
+            self._send(200, r)
+        except Exception as e:
+            traceback.print_exc(); self._send(400, {"error": f"{type(e).__name__}: {e}"})
+
+if __name__ == "__main__":
+    print(f"laya systemone server on http://127.0.0.1:{PORT}/v1/systemone  ({VARIANT})", flush=True)
+    ThreadingHTTPServer(("127.0.0.1", PORT), H).serve_forever()

code/apps/web_console.py

@@ -0,0 +1,71 @@
+"""决策台 Web UI（零依赖，stdlib http.server）：粘贴任意文本，自定义问题，实时看概率条。
+用法: python apps/web_console.py [port=7860]   然后打开 http://127.0.0.1:7860
+"""
+import sys, json, time
+from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
+from common import get_agent
+
+HTML = r"""<!doctype html><meta charset=utf-8><title>Laya 决策台</title>
+<style>
+body{font:14px system-ui;margin:0;background:#0f1115;color:#e6e6e6;display:grid;grid-template-columns:1fr 1fr;gap:16px;padding:16px;height:100vh;box-sizing:border-box}
+textarea{width:100%;box-sizing:border-box;background:#1a1d24;color:#eee;border:1px solid #333;border-radius:6px;padding:8px;font:13px ui-monospace,monospace}
+button{background:#4f8cff;color:#fff;border:0;padding:8px 16px;border-radius:6px;font-size:14px;cursor:pointer}
+select{background:#1a1d24;color:#eee;border:1px solid #333;padding:6px;border-radius:6px}
+.q{margin:10px 0;padding:10px;background:#171a21;border-radius:8px}.q h3{margin:0 0 6px;font-size:14px}
+.row{display:flex;align-items:center;gap:8px;margin:2px 0}.bar{height:10px;background:#4f8cff;border-radius:3px}
+.lab{width:120px;text-align:right;color:#aaa}.p{width:40px;color:#aaa}
+#out{overflow:auto}.meta{color:#888;font-size:12px}
+</style>
+<div><h2>Laya 决策台 <span class=meta>单次前向传播 · 不生成文本 · 校准概率</span></h2>
+<label>模型 <select id=model><option value=multilingual>multilingual (100+ 语言)</option><option value=english>english</option><option value=typed>typed-decisions</option></select></label>
+<p><b>状态 (JSON 或纯文本)</b><br><textarea id=state rows=8>{"subject": "登录一直失败", "body": "从昨天开始整个团队都登录不了后台，报 502，我们的上线被卡住了。再不解决就退订。"}</textarea></p>
+<p><b>问题 (JSON)</b><br><textarea id=questions rows=16>{
+  "department": {"type": "choice", "instructions": "Which team should handle this?",
+    "criteria": {"billing": "invoices, refunds", "technical": "bugs, outages, login", "sales": "pricing, plans"}},
+  "urgency": {"type": "score", "instructions": "How urgent is this?", "criteria": ["not urgent", "soon", "blocking"]},
+  "churn_risk": {"type": "noul", "instructions": "Does the user threaten to cancel?"}
+}</textarea></p>
+<button onclick=run()>预测 (Ctrl+Enter)</button> <span id=t class=meta></span></div>
+<div id=out></div>
+<script>
+async function run(){
+ const body={model:model.value,state:state.value,questions:questions.value};
+ t.textContent='...';
+ const r=await fetch('/predict',{method:'POST',body:JSON.stringify(body)});const j=await r.json();
+ if(j.error){out.innerHTML='<pre style="color:#f66">'+j.error+'</pre>';t.textContent='';return}
+ t.textContent=j.ms.toFixed(0)+' ms';
+ let h='';for(const [k,a] of Object.entries(j.answers)){
+  h+='<div class=q><h3>'+k+' → <span style=color:#8fd>'+(a.choice??(a.score!==undefined?'score '+a.score.toFixed(2):'')??'')+(a.noul!==undefined?'P(true)='+a.noul.toFixed(2):'')+'</span>'+(a.confidence!==undefined?' <span class=meta>conf '+a.confidence.toFixed(2)+'</span>':'')+'</h3>';
+  let d=a.probabilities||(a.noul!==undefined?{true:a.noul,false:1-a.noul}:{});if(a.legend)d=Object.fromEntries(Object.entries(d).map(([k,v])=>[k+' '+a.legend[k],v]));
+  if(Array.isArray(d))d=Object.fromEntries(d.map((v,i)=>[i,v]));
+  for(const [l,p] of Object.entries(d).sort((x,y)=>y[1]-x[1]))h+='<div class=row><span class=lab>'+l+'</span><div class=bar style=width:'+(p*300)+'px></div><span class=p>'+p.toFixed(2)+'</span></div>';
+  h+='</div>'}
+ h+='<pre class=meta>'+JSON.stringify(j.raw,null,1)+'</pre>';out.innerHTML=h}
+document.addEventListener('keydown',e=>{if(e.ctrlKey&&e.key=='Enter')run()});
+</script>"""
+
+class H(BaseHTTPRequestHandler):
+    def log_message(self, *a): pass
+    def do_GET(self):
+        self.send_response(200); self.send_header("Content-Type", "text/html; charset=utf-8"); self.end_headers()
+        self.wfile.write(HTML.encode())
+    def do_POST(self):
+        n = int(self.headers.get("Content-Length", 0)); req = json.loads(self.rfile.read(n))
+        try:
+            st = req["state"].strip()
+            try: st = json.loads(st)
+            except Exception: st = {"text": st}
+            qs = json.loads(req["questions"])
+            agent = get_agent(req.get("model", "multilingual"))
+            t = time.time(); r = agent.predict(st, qs); ms = (time.time() - t) * 1000
+            body = {"answers": r["answers"], "raw": r, "ms": ms}
+        except Exception as e:
+            body = {"error": f"{type(e).__name__}: {e}"}
+        data = json.dumps(body, ensure_ascii=False, default=str).encode()
+        self.send_response(200); self.send_header("Content-Type", "application/json"); self.end_headers(); self.wfile.write(data)
+
+if __name__ == "__main__":
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 7860
+    get_agent("multilingual")
+    print(f"open http://127.0.0.1:{port}")
+    ThreadingHTTPServer(("127.0.0.1", port), H).serve_forever()

code/env.sh

@@ -0,0 +1,6 @@
+export HF_ENDPOINT=https://hf-mirror.com
+export USE_TF=0
+export UV_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple
+export PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple
+unset http_proxy https_proxy all_proxy HTTP_PROXY HTTPS_PROXY ALL_PROXY
+export PATH="$HOME/.local/bin:$PATH"

code/finetune/README.md

@@ -0,0 +1,94 @@
+# 微调 laya 做浏览器 agent 决策头（替代 TypeSafe Jev）
+
+流水线（全部本地、无付费 API）：
+
+| 步骤 | 脚本 | 说明 |
+|---|---|---|
+| 1 抓页面 | `collect_pages.py` | headless Chromium + browser-harness，90 个真实页面的元素表 + 正文 |
+| 2 反向生成目标 | `gen_goals.py` | 随机选一个元素当 gold，本地 Qwen3-8B-AWQ（sglang）写出"要用它的用户目标"，1121 条 |
+| 3 真实 DONE 样本 | `make_done_cases.py` | 在浏览器里真的执行点击，落地页 + 历史 = DONE，250 条 |
+| 4 构建样本 | `build_items.py` | 复刻 jev-ultrafast 的 systemone 请求格式（`common_ft.py`），head_max_len 512；页面按 index%5 留出 |
+| 5 训练 | `train.py` | laya 官方 RLCD 配方（噪声 logit 策略梯度 + soft CE）单卡版，4 轮约 10 分钟 |
+| 6 评测 | `eval.py` | 留出页面上的操作准确率 / 目标 top-1 |
+
+```fish
+bash finetune/run_v2.sh          # 4-6 步
+bash finetune/run_all.sh         # 含零样本基线
+```
+
+## 加入魔搭 Mind2Web 后（v3/v4）
+
+`osunlp/Mind2Web`（魔搭，6.7 GB，12-25 MB/s 不走代理）→ `convert_mind2web.py`：按 backend_node_id 从 cleaned_html 还原元素文本/角色，
+正例 + 44 个负例打乱成 jev 格式元素表，历史用 action_reprs，7296 条；按网站哈希留出 20%。v4 = 自采 + 真实 DONE + 全部 Mind2Web，
+DONE / TYPE_TEXT / SELECT 操作样本 3 倍过采样，16020 条训练样本，3 轮 64 分钟。`bash finetune/run_v4.sh`。
+
+评测 1642 条（自采留出页 232 + Mind2Web 未见网站 1410）：
+
+| 模型 | 操作准确率 | 目标 top-1 | live DONE | m2w CLICK 目标 | m2w TYPE_TEXT 操作 | m2w SELECT 操作 |
+|---|---|---|---|---|---|---|
+| typed-decisions 零样本 | 0.26 | 0.13 | 0.39 | 0.03 | 0.00 | 0.00 |
+| v3（无过采样） | 0.790 | 0.496 | 0.58 | 0.40 | 0.04 | 0.20 |
+| **v4（过采样）** | **0.795** | **0.524** | **0.82** | **0.43** | **0.80** | **0.55** |
+
+真实浏览器 6 任务：零样本 0/6 → v2 2/6 → **v4 3/6**（python.org Downloads 2.0 s、Travel 分类 0.3 s、Wikipedia 随机文章），
+Wikipedia 搜索任务首次正确选 TYPE_TEXT 并由本地 Qwen 填入 "Python programming language"，但之后重复填同一字段而没有提交——
+训练数据里缺"字段已填好 → 下一步提交"的样本。GitHub Issues 点成 Releases、HN new 提前 DONE。
+
+## 最终对比 v2（2026-09-21，修正检查脚本后：下拉按 current_value 文本判定、导航后等 1.5 s 再判）
+
+| 模型 | 真实任务 16×3 | 留出 top-1 | 每步 |
+|---|---|---|---|
+| v10（421M） | 50% | 0.656 | 41–50 ms |
+| **v10s（322M）** | **62%** | 0.631 | 17–23 ms |
+| v11s（322M + 682 条滚动/搜索/下拉脚本轨迹） | 56% | 0.623 | 19 ms |
+
+10 个任务 3/3 稳过、6 个 3/3 稳挂；v10s/v11s 差异小于站点随机波动。老师对比：27B 思考预算 300 最好（0.861/0.603，4.7 s/步），
+仍不超过 laya v11s（0.890/0.623，0.021 s）；8B/27B 都不适合做 DAgger 老师或 System-2 兜底。
+
+## 最终对比（2026-09-21，16 个真实任务 × 3 次，apps/browser_suite.py）
+
+| 模型 | 底座 | 一步延迟 | 留出目标 top-1 | 真实任务通过率 | +门控 τ=0.7（Qwen3-8B 兜底） |
+|---|---|---|---|---|---|
+| v10 | ModernBERT-large 421M | 41–50 ms | 0.656 | **58%**（28/48） | 42%，升级率 78% |
+| v10s | mmBERT-base 322M，格式 v3 | **17–23 ms** | 0.631 | 50%（24/48） | 52%，升级率 85% |
+
+结果高度双峰：9 个任务 3/3 稳定通过（导航、分类、勾选、HN 各页、DuckDuckGo 搜索），7 个任务 0/3 稳定失败
+（Wikipedia 两个搜索任务、GitHub Issues、下拉选择、翻页需滚动、arXiv 搜索、Google Flights）。
+门控把低置信步骤交给 Qwen3-8B 反而更差：在这些页面上微调后的 laya 比 8B 通用模型判断得更准，System 2 需要更强的模型或专门提示。
+失败任务的共性是"输入后提交 / 选建议"和"需要先滚动"，训练数据里几乎没有滚动样本。
+v10 数据：5244 条自采目标（421 页）+ 700 真实 DONE + step-2 + Mind2Web 全量 + DAgger，格式 v2，head 768，4 轮 2.2 小时。
+
+## 输入格式 v2（v9 起）
+
+`LAYA_FMT=v2 LAYA_HEAD=768`：元素表不再塞进 state（1024 token 里会被截掉），只在选项里保留完整标签 + 角色 + 已填值，
+state 只留标题 / URL / 历史 / 1500 字正文，head_max_len 512→768。v9 只用 Mind2Web + 该格式，真实任务从 6/16 到 **10/16**，
+Mind2Web 点击目标 0.44→0.51。checkpoint 的 `rl_agent_config.json` 记录 `laya_fmt` / `head_max_len_train`，服务端自动跟随。
+
+注意：jev 的 `snapshot.js` 有意隐藏密码框（`!['password','file','hidden'].includes(e.type)`），密码登录任务在该框架里不可能完成，任务集已移除。
+
+## 真实任务集（apps/browser_suite.py，16 个任务，自动验收）
+
+| 版本 | 通过 | 主要失败模式 |
+|---|---|---|
+| v4 | 3/14 | 过早 DONE（6 个），填完不提交���2 个），点错（3 个） |
+| v5（DONE 过采样 2x + 字段带已填值 + 温度 1.40） | 4/14 | 登录/搜索仍在填一个字段后 DONE |
+
+v5 的根因：真实 DONE 样本历史恰好都是 1 步、自采点击样本历史都是 0 步，模型学到"有历史 ⇒ DONE"。
+v6 加 `gen_step2.py`：在 250 个落地页上保留历史再生成 659 条新目标作为负样本。
+
+## 结果（v1/v2，仅自采数据）
+
+留出 18 个未见页面、232 条：
+
+| 模型 | 操作准确率 | 目标 top-1 | DONE 判断 | 每条延迟 |
+|---|---|---|---|---|
+| typed-decisions 零样本 | 0.543 | 0.103（随机） | 0.39 | 254 ms |
+| multilingual 零样本 | 0.127 | 0.124 | 0.00 | 249 ms |
+| **微调 v2（1886 样本）** | **0.875** | **0.665** | 0.66 | 55 ms |
+
+真实浏览器 6 个任务（jev-ultrafast 循环 + 本地 laya 服务）：python.org Downloads 2.4 s 完成、books.toscrape Travel
+分类 0.3 s 完成；HN "new"、GitHub Issues、Wikipedia 两个任务失败（点错元素或提前 DONE）。零样本时 6 个全失败。
+
+已知问题：置信度全是 1.00（未做温度校准）；数据只有 90 个页面，泛化有限。下一步是把页面扩到 500+、
+每轮把线上失败样本加回训练集、拟合温度。v1 的教训：模板化的 DONE 样本会让模型学到"看到 stop when 就答 DONE"，
+DONE 样本必须来自真实执行后的落地页。

code/finetune/build_items.py

@@ -0,0 +1,67 @@
+"""cases.jsonl + pages.jsonl -> tokenized training items (train split) and eval cases (held-out pages).
+
+    python finetune/build_items.py out/pages.jsonl out/cases.jsonl out/
+"""
+import json, os, sys
+import torch
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common_ft import build_request, gold_for
+from transformers import AutoTokenizer
+from laya.common import QTYPES, build_sequence, render_options
+
+MAX_LEN, HEAD_MAX_LEN = 1024, int(os.environ.get('LAYA_HEAD', '512'))
+EVAL_EVERY = 5   # pages with index % 5 == 0 are held out
+
+
+def main():
+    pages_f, cases_f, out = sys.argv[1:4]
+    pages = [json.loads(l) for l in open(pages_f)]
+    cases = [json.loads(l) for l in open(cases_f)]
+    for extra in sys.argv[4:]:
+        cases += [json.loads(l) for l in open(extra)]
+    snap = os.environ.get("LAYA_BASE")
+    tok = AutoTokenizer.from_pretrained(os.path.join(snap, "tokenizer"))
+    items, n_skip, ev = [], 0, []
+    import hashlib
+    STOPS = [" Stop when it is open.", " Stop once that page is visible.", " Then stop.", " Finish when it has loaded.", ""]
+    for c in cases:
+        if c["kind"] == "done" and "page_obj" not in c:
+            continue  # template DONE cases leak phrasing; real ones come from make_done_cases.py
+        page = c.get("page_obj") or pages[c["page"]]
+        h = int(hashlib.md5(c["goal"].encode()).hexdigest(), 16)
+        goal = c["goal"] + STOPS[h % len(STOPS)]
+        c = {**c, "goal": goal}
+        state, questions, targets, controls = build_request(page, goal, c.get("history", []))
+        gop, gidx = gold_for(c, targets, controls)
+        if gop is None:
+            n_skip += 1; continue
+        held = (hashlib.md5(c["website"].encode()).digest()[0] % EVAL_EVERY == 0) if c.get("source") == "mind2web" else (c["page"] % EVAL_EVERY == 0)
+        if held:
+            ev.append({**c, "gold_index": gidx}); continue
+        golds = {"operation": gop}
+        if gidx is not None:
+            golds[gop.lower() + "_target"] = gidx
+        for qid, gold in golds.items():
+            q = questions[qid]; keys = list(q["criteria"])
+            target = [1.0 if k == gold else 0.0 for k in keys]
+            qq = {"t": "choice", "ins": json.dumps(q["instructions"]), "crit": q["criteria"]}
+            seq, markers = build_sequence(tok, state, qq, MAX_LEN, HEAD_MAX_LEN)
+            if len(markers) != len(render_options(qq)):
+                n_skip += 1; continue
+            item = {"ids": seq, "markers": markers, "qtype": QTYPES["choice"], "target": target, "label": keys.index(gold), "qid": qid, "gold_op": gop}
+            # class balance: CLICK dominates the operation question, so repeat the rare operations
+            reps = {"DONE": 4, "TYPE_TEXT": 3, "SELECT": 3}.get(gop, 1) if qid == "operation" else 1
+            if c.get("source") == "dagger":
+                reps *= 5   # on-policy teacher corrections from real tasks: few but exactly where the policy fails
+            items.extend([item] * reps)
+    torch.save(items, os.path.join(out, "train_items.pt"))
+    with open(os.path.join(out, "eval_cases.jsonl"), "w") as f:
+        for c in ev: f.write(json.dumps(c, ensure_ascii=False) + "\n")
+    lens = [len(i["ids"]) for i in items]
+    import collections
+    print("operation label counts:", dict(collections.Counter(i["gold_op"] for i in items if i["qid"] == "operation")))
+    print(f"train items {len(items)} (op {sum(i['qid']=='operation' for i in items)}, target {sum(i['qid']!='operation' for i in items)}), "
+          f"eval cases {len(ev)}, skipped {n_skip}, seq len mean {sum(lens)/len(lens):.0f} max {max(lens)}")
+
+if __name__ == "__main__":
+    main()

code/finetune/calibrate.py

@@ -0,0 +1,43 @@
+"""Fit per-question-type temperatures on held-out cases (NLL), write them into rl_agent_config.json.
+
+    python finetune/calibrate.py out/pages.jsonl out/eval_cases.jsonl <checkpoint dir>
+"""
+import json, os, sys
+import numpy as np, torch
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))); sys.path.insert(0, "/home/ckl/projects/S/laya-upstream")
+from common_ft import build_request, gold_for
+import laya
+from laya.common import QTYPES, build_sequence, collate_items
+
+def main():
+    pages = [json.loads(l) for l in open(sys.argv[1])]; cases = [json.loads(l) for l in open(sys.argv[2])]; ck = sys.argv[3]
+    agent = laya.load(ck); agent.cfg["max_len"], agent.cfg["head_max_len"] = 1024, int(os.environ.get("LAYA_HEAD", agent.cfg.get("head_max_len_train", 512))); agent.accelerate()
+    Z, T, K = [], [], []
+    for c in cases[::2]:
+        state, questions, targets, controls = build_request(c.get("page_obj") or pages[c["page"]], c["goal"], c.get("history", []))
+        gop, gidx = gold_for(c, targets, controls)
+        golds = {"operation": gop}
+        if gidx is not None: golds[gop.lower() + "_target"] = gidx
+        items, keys = [], []
+        for qid, gold in golds.items():
+            q = questions[qid]; qq = {"t": "choice", "ins": json.dumps(q["instructions"]), "crit": q["criteria"]}
+            seq, markers = build_sequence(agent.tok, state, qq, 1024, agent.cfg['head_max_len'])
+            items.append({"ids": seq, "markers": markers, "qtype": QTYPES["choice"]}); keys.append((list(q["criteria"]), gold))
+        b = collate_items([items], agent.tok.pad_token_id)
+        with torch.no_grad(), torch.autocast("cuda", dtype=agent.dtype):
+            logits, _ = agent.model(b["input_ids"].cuda(), b["attention_mask"].cuda(), b["marker_pos"].cuda(), b["marker_mask"].cuda(), b["qtype"].cuda())
+        for r, (ks, gold) in enumerate(keys):
+            z = logits[r, :len(ks)].float().cpu(); Z.append(z); T.append(ks.index(gold))
+    kmax = max(len(z) for z in Z); M = torch.full((len(Z), kmax), -1e4)
+    for i, z in enumerate(Z): M[i, :len(z)] = z
+    y = torch.tensor(T)
+    def nll(t): return torch.nn.functional.cross_entropy(M / t, y).item()
+    ts = np.exp(np.linspace(np.log(0.2), np.log(10), 200)); best = min(ts, key=nll)
+    acc = (M.argmax(-1) == y).float().mean().item()
+    conf0 = torch.softmax(M, -1).max(-1).values.mean().item(); conf1 = torch.softmax(M / best, -1).max(-1).values.mean().item()
+    print(f"n={len(Z)} acc={acc:.3f}  T=1: nll {nll(1.0):.3f} mean conf {conf0:.3f}  |  T={best:.2f}: nll {nll(best):.3f} mean conf {conf1:.3f}")
+    cfgp = os.path.join(ck, "rl_agent_config.json"); cfg = json.load(open(cfgp)); cfg["temperature"] = [float(best), 1.0, 1.0]
+    json.dump(cfg, open(cfgp, "w"), indent=2); print("wrote temperature", best, "->", cfgp)
+
+if __name__ == "__main__":
+    main()

code/finetune/collect_pages.py

@@ -0,0 +1,107 @@
+"""Crawl real pages with browser-harness and dump their jev-ultrafast observations (element tables + page text).
+
+    python finetune/collect_pages.py out/pages.jsonl [max_pages=80]
+
+Starts from SEEDS, follows a few random same-site links from each page to diversify. One JSON line per page.
+"""
+import json, os, random, sys, time
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast")
+os.environ.setdefault("BU_CDP_URL", "http://127.0.0.1:9222")
+from jev_ultrafast.browser import Browser, StalePage
+from jev_ultrafast.model import action_space
+
+SEEDS = [
+    "https://en.wikipedia.org/wiki/Main_Page", "https://en.wikipedia.org/wiki/Special:Random", "https://en.wikipedia.org/wiki/Python_(programming_language)",
+    "https://news.ycombinator.com/", "https://news.ycombinator.com/newest", "https://news.ycombinator.com/login",
+    "https://github.com/", "https://github.com/tile-ai/tilelang", "https://github.com/browser-use/browser-use/issues", "https://github.com/login",
+    "https://www.python.org/", "https://docs.python.org/3/", "https://pypi.org/", "https://pypi.org/project/laya/",
+    "https://archlinux.org/", "https://wiki.archlinux.org/", "https://developer.mozilla.org/en-US/", "https://duckduckgo.com/",
+    "https://www.bing.com/", "https://stackoverflow.com/questions", "https://www.reddit.com/", "https://arxiv.org/",
+    "https://arxiv.org/list/cs.LG/recent", "https://huggingface.co/models", "https://huggingface.co/convaiinnovations/laya",
+    "https://www.saucedemo.com/", "https://the-internet.herokuapp.com/", "https://the-internet.herokuapp.com/login",
+    "https://demo.opencart.com/", "https://www.demoblaze.com/", "https://books.toscrape.com/", "https://quotes.toscrape.com/login",
+    "https://www.google.com/travel/flights?hl=en", "https://www.booking.com/", "https://www.airbnb.com/", "https://www.amazon.com/",
+    "https://www.ebay.com/", "https://www.imdb.com/", "https://www.nytimes.com/", "https://www.bbc.com/",
+    "https://www.openstreetmap.org/", "https://weather.com/", "https://www.wolframalpha.com/", "https://translate.google.com/",
+    "https://www.gnu.org/", "https://kernel.org/", "https://www.rust-lang.org/", "https://go.dev/", "https://nodejs.org/en",
+    "https://www.npmjs.com/", "https://crates.io/", "https://docs.rs/", "https://www.kaggle.com/", "https://paperswithcode.com/",
+    # round 2: more sites, more form-heavy pages
+    "https://en.wikipedia.org/wiki/Special:Search", "https://en.wikipedia.org/wiki/Portal:Current_events", "https://de.wikipedia.org/", "https://zh.wikipedia.org/",
+    "https://news.ycombinator.com/ask", "https://news.ycombinator.com/show", "https://news.ycombinator.com/jobs", "https://news.ycombinator.com/submit",
+    "https://github.com/explore", "https://github.com/trending", "https://github.com/pytorch/pytorch", "https://github.com/pytorch/pytorch/pulls",
+    "https://github.com/pytorch/pytorch/issues", "https://gitlab.com/explore", "https://gitee.com/explore", "https://about.gitlab.com/",
+    "https://www.python.org/downloads/", "https://docs.python.org/3/tutorial/", "https://docs.python.org/3/library/", "https://peps.python.org/",
+    "https://pypi.org/search/?q=torch", "https://pypi.org/project/torch/", "https://pypi.org/account/login/", "https://pypi.org/help/",
+    "https://the-internet.herokuapp.com/dropdown", "https://the-internet.herokuapp.com/checkboxes", "https://the-internet.herokuapp.com/forgot_password",
+    "https://the-internet.herokuapp.com/inputs", "https://the-internet.herokuapp.com/tables", "https://the-internet.herokuapp.com/javascript_alerts",
+    "https://demo.opencart.com/index.php?route=product/category&path=20", "https://demo.opencart.com/index.php?route=account/login",
+    "https://demo.opencart.com/index.php?route=account/register", "https://demo.opencart.com/index.php?route=product/search&search=mac",
+    "https://www.demoblaze.com/cart.html", "https://www.demoblaze.com/prod.html?idp_=1", "https://books.toscrape.com/catalogue/page-2.html",
+    "https://books.toscrape.com/catalogue/category/books/mystery_3/index.html", "https://quotes.toscrape.com/tag/love/", "https://quotes.toscrape.com/page/2/",
+    "https://www.saucedemo.com/inventory.html", "https://automationexercise.com/", "https://automationexercise.com/login", "https://automationexercise.com/products",
+    "https://practicetestautomation.com/practice-test-login/", "https://demoqa.com/", "https://demoqa.com/text-box", "https://demoqa.com/select-menu",
+    "https://demoqa.com/webtables", "https://www.selenium.dev/selenium/web/web-form.html", "https://formy-project.herokuapp.com/", "https://formy-project.herokuapp.com/form",
+    "https://parabank.parasoft.com/parabank/index.htm", "https://parabank.parasoft.com/parabank/register.htm", "https://www.globalsqa.com/angularJs-protractor/BankingProject/",
+    "https://opensource-demo.orangehrmlive.com/", "https://magento.softwaretestingboard.com/", "https://magento.softwaretestingboard.com/women.html",
+    "https://www.airbnb.com/s/London/homes", "https://www.booking.com/searchresults.html?ss=Paris", "https://www.google.com/travel/hotels?hl=en",
+    "https://www.google.com/maps?hl=en", "https://www.google.com/search?q=tilelang&hl=en", "https://duckduckgo.com/?q=modernbert", "https://www.bing.com/search?q=laya",
+    "https://arxiv.org/list/cs.CL/new", "https://arxiv.org/abs/2412.13663", "https://arxiv.org/search/?query=flash+attention&searchtype=all",
+    "https://huggingface.co/datasets", "https://huggingface.co/spaces", "https://huggingface.co/docs", "https://huggingface.co/login", "https://huggingface.co/answerdotai/ModernBERT-base",
+    "https://www.modelscope.cn/models", "https://www.modelscope.cn/datasets", "https://www.kaggle.com/datasets", "https://www.kaggle.com/competitions",
+    "https://stackoverflow.com/", "https://stackoverflow.com/questions/tagged/python", "https://superuser.com/", "https://askubuntu.com/",
+    "https://www.reddit.com/r/MachineLearning/", "https://old.reddit.com/", "https://old.reddit.com/r/python/", "https://lobste.rs/",
+    "https://www.bbc.com/news", "https://www.bbc.com/sport", "https://www.theguardian.com/international", "https://www.reuters.com/", "https://apnews.com/",
+    "https://www.imdb.com/chart/top/", "https://www.imdb.com/find/?q=inception", "https://www.rottentomatoes.com/", "https://www.goodreads.com/",
+    "https://www.openstreetmap.org/search?query=Berlin", "https://www.wikidata.org/", "https://commons.wikimedia.org/", "https://www.wiktionary.org/",
+    "https://developer.mozilla.org/en-US/docs/Web/JavaScript", "https://developer.mozilla.org/en-US/docs/Web/HTML/Element/select", "https://web.dev/",
+    "https://www.rust-lang.org/learn", "https://doc.rust-lang.org/book/", "https://go.dev/doc/", "https://pkg.go.dev/", "https://nodejs.org/en/download",
+    "https://www.npmjs.com/package/react", "https://react.dev/", "https://vuejs.org/", "https://tailwindcss.com/docs", "https://getbootstrap.com/docs/",
+    "https://www.wolframalpha.com/input?i=2%2B2", "https://translate.google.com/?sl=en&tl=zh-CN&text=hello", "https://www.deepl.com/translator",
+    "https://weather.com/weather/today/l/USNY0996", "https://www.timeanddate.com/", "https://www.xe.com/currencyconverter/", "https://www.calculator.net/",
+    "https://archlinux.org/packages/", "https://aur.archlinux.org/", "https://wiki.archlinux.org/title/Installation_guide", "https://www.kernel.org/doc/",
+    "https://www.debian.org/", "https://ubuntu.com/download", "https://www.gnu.org/software/", "https://www.fsf.org/",
+]
+
+def observe(url, timeout=25):
+    b = Browser(url)
+    try:
+        page = b.observe(screenshot=False)
+        links = b.evaluate("""(() => { const out=[]; for (const a of document.querySelectorAll('a[href]')) {
+            const h=a.href; if (h.startsWith(location.origin) && !h.includes('#') && h!==location.href) out.push(h); } return out.slice(0,400); })()""") or []
+        return page, links
+    finally:
+        b.close()
+
+def main():
+    out, max_pages = sys.argv[1], int(sys.argv[2]) if len(sys.argv) > 2 else 80
+    os.makedirs(os.path.dirname(out) or ".", exist_ok=True)
+    seen = set()
+    if os.path.exists(out):
+        for line in open(out):
+            seen.add(json.loads(line)["url"])
+    rng = random.Random(0)
+    queue = list(SEEDS); rng.shuffle(queue)
+    n = len(seen)
+    with open(out, "a") as f:
+        while queue and n < max_pages:
+            url = queue.pop(0)
+            if url in seen:
+                continue
+            t = time.time()
+            try:
+                page, links = observe(url)
+            except Exception as e:
+                print(f"skip {url}: {type(e).__name__}: {str(e)[:80]}", flush=True); continue
+            elements, targets, controls = action_space(page["actions"])
+            if len(elements) < 5 or len(elements) > 160:
+                print(f"skip {url}: {len(elements)} elements", flush=True); continue
+            seen.add(page["url"]); n += 1
+            f.write(json.dumps({"url": page["url"], "title": page["title"], "text": page["text"], "actions": page["actions"],
+                                "scroll": page.get("scroll")}, ensure_ascii=False) + "\n"); f.flush()
+            print(f"[{n}] {len(elements):3d} elements {time.time()-t:4.1f}s {page['title'][:60]}", flush=True)
+            rng.shuffle(links)
+            queue.extend(l for l in links[:3] if l not in seen)
+    print("done", n, "pages")
+
+if __name__ == "__main__":
+    main()

code/finetune/common_ft.py

@@ -0,0 +1,77 @@
+"""Shared: build the exact jev-ultrafast systemone request for a page + goal, with the server-side compaction."""
+import importlib.util, json, sys, types
+
+JEV = "/home/ckl/projects/S/jev-ultrafast/jev_ultrafast"
+# load model.py / questions.py without running the package __init__ (which pulls in browser-harness)
+if "jev_ultrafast" not in sys.modules:
+    _pkg = types.ModuleType("jev_ultrafast"); _pkg.__path__ = [JEV]; sys.modules["jev_ultrafast"] = _pkg
+    for _name in ("questions", "model"):
+        _spec = importlib.util.spec_from_file_location(f"jev_ultrafast.{_name}", f"{JEV}/{_name}.py")
+        _m = importlib.util.module_from_spec(_spec); sys.modules[_spec.name] = _m; _spec.loader.exec_module(_m)
+from jev_ultrafast.model import action_space  # noqa: E402
+from jev_ultrafast.questions import NEXT_ACTION, TARGET  # noqa: E402
+
+import os
+FMT = os.environ.get("LAYA_FMT", "v1")
+# v1: jev's state verbatim (page text up to 6000 chars + the whole element table as JSON) -- the 1024-token budget truncates
+#     most of it, so the model often never sees the candidates' context.  3000 chars was tried (v7): -0.04 top-1.
+# v2: elements live only in the option list (full label + role + value); state keeps title/url/history and 1500 chars of text.
+# v3: v2 + option labels capped at 50 chars and 1200 chars of text (~30% fewer tokens; for the 322M base to hit ~20 ms/step)
+PAGE_TEXT_CHARS = {"v2": 1500, "v3": 1200}.get(FMT, 6000)
+LABEL_CHARS = 50 if FMT == "v3" else 10000
+
+LABELS = {
+    "CLICK": "Click an element, button, menu option, autocomplete suggestion, or calendar day.",
+    "TYPE_TEXT": "Enter or replace text in an editable field. A small LLM will supply the value from the goal.",
+    "SELECT": "Select an observed dropdown value.",
+}
+
+
+def compact(v):
+    if isinstance(v, dict) and "element" in v:
+        s = str(v["element"])[:LABEL_CHARS]
+        if v.get("role"):
+            s += f" ({v['role']})"
+        if v.get("current_value"):
+            s += f" = {str(v['current_value'])[:30]!r}"
+        for k in ("checked", "selected", "expanded"):
+            if k in v:
+                s += f" {k}={v[k]}"
+        return s
+    return v
+
+
+def build_request(page, goal, history=()):
+    """Mirror of jev_ultrafast.model.choose() up to the HTTP call. Returns (state, questions, targets, controls)."""
+    elements, targets, controls = action_space(page["actions"])
+    operations = {key: LABELS[key] for key in targets}
+    operations.update({key: value["label"] for key, value in controls.items()})
+    operations.update(DONE="Every requirement is visibly satisfied.", BLOCKED="No supported operation can progress.")
+    questions = {"operation": {"type": "choice", "criteria": operations, "instructions": {"goal": goal, "rules": NEXT_ACTION}}}
+    for operation, candidates in targets.items():
+        questions[operation.lower() + "_target"] = {
+            "type": "choice",
+            "criteria": {index: {"element": f"[{index}] {a['label']}", "current_value": a.get("current_value", a.get("value", "")),
+                                 **{k: a[k] for k in ("role", "checked", "selected", "expanded") if k in a}} for index, a in candidates.items()},
+            "instructions": {"goal": goal, "operation": operation, "rules": [NEXT_ACTION, TARGET]},
+        }
+    state = {"page": {"url": page["url"], "title": page["title"], "text": page["text"][:PAGE_TEXT_CHARS]},
+             "recent_actions": [{k: h.get(k) for k in ("action", "kind", "text", "page_changed")} for h in list(history)[-10:]]}
+    if FMT not in ("v2", "v3"):
+        state["elements"] = elements
+    for q in questions.values():
+        q["criteria"] = {k: compact(v) for k, v in q["criteria"].items()}
+    return state, questions, targets, controls
+
+
+def gold_for(case, targets, controls):
+    """(gold operation key, gold target index or None) for a case in the operation/target question vocab."""
+    op = case["gold_op"]
+    if op == "DONE":
+        return "DONE", None
+    if op in ("SCROLL_DOWN", "SCROLL_UP", "WAIT"):          # page-level controls: operation question only
+        return (op, None) if op in {k.upper() for k in controls} else (None, None)
+    for index, a in targets.get(op, {}).items():
+        if a["id"] == case["gold_id"]:
+            return op, index
+    return None, None

code/finetune/convert_mind2web.py

@@ -0,0 +1,116 @@
+"""Mind2Web (osunlp/Mind2Web from ModelScope) -> cases in this repo's format (page_obj with jev-style actions).
+
+    python finetune/convert_mind2web.py finetune/data/mind2web/data/train/*.json finetune/out/m2w_cases.jsonl
+
+Each Mind2Web action becomes one case: goal = confirmed_task, history = previous action_reprs, gold = the positive
+candidate; the element table = positive + up to MAX_NEG sampled negative candidates rendered like jev's snapshot.js
+(label from text / aria-label / placeholder / alt / title / value, role from tag).
+"""
+import json, random, re, sys
+from bs4 import BeautifulSoup
+
+MAX_NEG = 44
+ROLE = {"a": "link", "button": "button", "input": "textbox", "textarea": "textbox", "select": "combobox", "option": "option",
+        "img": "img", "li": "listitem", "label": "label", "span": "generic", "div": "generic", "svg": "img", "h1": "heading",
+        "h2": "heading", "h3": "heading", "p": "text", "td": "cell", "th": "columnheader", "tr": "row", "ul": "list"}
+
+
+def label_of(el):
+    attrs = el.attrs
+    for k in ("aria-label", "placeholder", "alt", "title"):
+        v = attrs.get(k)
+        if isinstance(v, list): v = " ".join(v)
+        if v and v.strip(): return v.strip()
+    txt = " ".join(el.get_text(" ", strip=True).split())
+    if txt: return txt[:80]
+    v = attrs.get("value")
+    if v: return str(v).strip()[:80]
+    return (attrs.get("name") or attrs.get("id") or el.name or "")[:60]
+
+
+def kind_of(el, op):
+    t = el.name
+    typ = (el.attrs.get("type") or "").lower()
+    if t == "select": return "select"
+    if t == "textarea" or (t == "input" and typ in ("", "text", "search", "email", "password", "number", "tel", "url")) or el.attrs.get("contenteditable"):
+        return "fill"
+    return "click"
+
+
+def convert_action(task, ai, action, rng):
+    soup = BeautifulSoup(action["cleaned_html"], "lxml")
+    by_id = {}
+    for el in soup.find_all(attrs={"backend_node_id": True}):
+        by_id[el.attrs["backend_node_id"]] = el
+    pos = action["pos_candidates"]
+    if not pos: return None
+    gold_el = by_id.get(pos[0]["backend_node_id"])
+    if gold_el is None: return None
+    negs = [c for c in action["neg_candidates"] if c["backend_node_id"] in by_id]
+    rng.shuffle(negs)
+    cands = [pos[0]] + negs[:MAX_NEG]
+    rng.shuffle(cands)
+    op = action["operation"]["op"]
+    # values typed/selected in earlier steps: a field that already holds its value must show it (jev's rules key on that)
+    filled = {}
+    for r in task["action_reprs"][:ai]:
+        m = re.match(r"\[(\w+)\]\s+(.*?)\s+->\s+(TYPE|SELECT):\s*(.*)$", r)
+        if m: filled[" ".join(m.group(2).split()).lower()] = m.group(4).strip()
+    actions, gold_id, node = [], None, 0
+    for c in cands:
+        el = by_id[c["backend_node_id"]]
+        lab = label_of(el)
+        if not lab: continue
+        node += 1
+        is_gold = c["backend_node_id"] == pos[0]["backend_node_id"]
+        kind = {"CLICK": "click", "TYPE": "fill", "SELECT": "select"}[op] if is_gold else kind_of(el, op)
+        role = ROLE.get(el.name, "generic")
+        base = {"node": node, "label": lab, "role": role}
+        if kind == "select":
+            opts = [o.get_text(" ", strip=True) for o in el.find_all("option")][:8] or [action["operation"]["value"] or "option"]
+            if is_gold and action["operation"]["value"] and action["operation"]["value"] not in opts:
+                opts = [action["operation"]["value"]] + opts[:7]
+            for oi, o in enumerate(opts):
+                a = {**base, "id": f"select:{node}:{oi}", "kind": "select", "value": o, "label": f"{lab} → {o}", "current_value": ""}
+                actions.append(a)
+                if is_gold and (o == action["operation"]["value"] or (oi == 0 and not action["operation"]["value"])): gold_id = a["id"]
+            continue
+        a = {**base, "id": f"{kind}:{node}", "kind": kind}
+        if kind == "fill":
+            a["value"] = filled.get(lab.lower(), "")
+            a["current_value"] = a["value"]
+        actions.append(a)
+        if is_gold: gold_id = a["id"]
+    if gold_id is None: return None
+    for k, lab in (("wait", "Wait for the page to update"), ("scroll_down", "Scroll down"), ("scroll_up", "Scroll up")):
+        actions.append({"id": k, "kind": "wait" if k == "wait" else "scroll", "label": lab, "node": None, "delta": 600 if k == "scroll_down" else -600})
+    text = " ".join(soup.get_text(" ", strip=True).split())[:6000]
+    hist = []
+    for r in task["action_reprs"][:ai]:
+        lab_, _, opv = r.rpartition(" -> ")
+        kind_, _, val = opv.partition(": ")
+        hist.append({"action": lab_.strip(), "kind": {"CLICK": "click", "TYPE": "fill", "SELECT": "select"}.get(kind_, kind_.lower()),
+                     "text": val or None, "page_changed": kind_ == "CLICK"})
+    gold_op = {"CLICK": "CLICK", "TYPE": "TYPE_TEXT", "SELECT": "SELECT"}[op]
+    return {"page": -1, "url": f"https://{task['website']}.com/", "title": task["website"], "goal": task["confirmed_task"], "gold_op": gold_op,
+            "gold_id": gold_id, "kind": {"CLICK": "click", "TYPE": "fill", "SELECT": "select"}[op], "label": label_of(gold_el), "history": hist,
+            "source": "mind2web", "task_id": task["annotation_id"], "website": task["website"],
+            "page_obj": {"url": f"https://{task['website']}.com/", "title": task["website"], "text": text, "actions": actions}}
+
+
+def main():
+    files, out = sys.argv[1:-1], sys.argv[-1]
+    rng = random.Random(0); n = 0; skipped = 0
+    with open(out, "w") as f:
+        for fn in files:
+            tasks = json.load(open(fn))
+            for t in tasks:
+                for ai, a in enumerate(t["actions"]):
+                    c = convert_action(t, ai, a, rng)
+                    if c is None: skipped += 1; continue
+                    f.write(json.dumps(c, ensure_ascii=False) + "\n"); n += 1
+            print(f"{fn}: total {n} cases, skipped {skipped}", flush=True)
+    print("wrote", n)
+
+if __name__ == "__main__":
+    main()

code/finetune/dagger.py

@@ -0,0 +1,121 @@
+"""DAgger-style harvesting: run real tasks with the current laya agent, and at every step ask the local Qwen teacher which
+action is right given the page's element table. Disagreements (and agreements) become training cases with the *agent's*
+on-policy states, so the next model learns exactly where this one goes wrong.
+
+    python finetune/dagger.py out/dagger_cases.jsonl [tasks.jsonl]   (services: chromium 9222, laya 8791, sglang 30000)
+
+tasks.jsonl lines: {"url": ..., "goal": ...}; default = apps/browser_suite.TASKS plus extra goals below.
+"""
+import json, os, sys, time
+import httpx
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast"); sys.path.insert(0, "/home/ckl/projects/S/laya/apps")
+os.environ.update(BU_CDP_URL="http://127.0.0.1:9222", TYPESAFE_BASE_URL="http://127.0.0.1:8791", TYPESAFE_API_KEY="local",
+                  TEXT_MODEL_API_KEY="local", TEXT_MODEL_BASE_URL="http://127.0.0.1:30000/v1", TEXT_MODEL="Qwen/Qwen3-8B-AWQ",
+                  TEXT_MODEL_EXTRA_JSON='{"chat_template_kwargs": {"enable_thinking": false}}')
+from jev_ultrafast import Agent
+from jev_ultrafast.model import action_space
+from browser_suite import TASKS
+
+EXTRA = [
+    ("https://en.wikipedia.org/wiki/Main_Page", "Open the article about Albert Einstein."),
+    ("https://news.ycombinator.com/", "Open the 'past' page."),
+    ("https://news.ycombinator.com/", "Open the comments of the first story on the front page."),
+    ("https://github.com/tile-ai/tilelang", "Open the Pull requests tab."),
+    ("https://github.com/tile-ai/tilelang", "Open the README's 'examples' folder."),
+    ("https://www.python.org/", "Open the documentation page."),
+    ("https://docs.python.org/3/", "Open the tutorial."),
+    ("https://books.toscrape.com/", "Open the 'Mystery' category and then open the first book in it."),
+    ("https://books.toscrape.com/", "Go to page 2 of the catalogue."),
+    ("https://the-internet.herokuapp.com/", "Open the 'Dropdown' example and select 'Option 2'."),
+    ("https://the-internet.herokuapp.com/", "Open the 'Checkboxes' example and tick the first checkbox."),
+    ("https://quotes.toscrape.com/", "Open the quotes tagged 'love'."),
+    ("https://quotes.toscrape.com/", "Go to the next page of quotes."),
+    ("https://arxiv.org/", "Open the listing of new submissions in cs.CL."),
+    ("https://pypi.org/", "Search PyPI for 'tilelang' and open the project page."),
+    ("https://duckduckgo.com/", "Search for 'ModernBERT paper'."),
+    ("https://www.saucedemo.com/", "Log in with username 'standard_user' and password 'secret_sauce', then add the 'Sauce Labs Backpack' to the cart."),
+    ("https://demo.opencart.com/", "Open the 'Desktops' category from the top menu."),
+    ("https://www.demoblaze.com/", "Open the 'Laptops' category."),
+    ("https://huggingface.co/models", "Search models for 'laya'."),
+]
+TEACHER = os.environ["TEXT_MODEL_BASE_URL"] + "/chat/completions"
+client = httpx.Client(timeout=180)
+SYS = """You are the teacher for a browser agent. You see the user's goal, the actions taken so far, the current page (title, url, text excerpt) and a
+numbered table of the controls on it. Decide the single best NEXT step:
+- {"operation": "CLICK", "index": n}  click control n
+- {"operation": "TYPE_TEXT", "index": n}  type into text control n (a separate helper supplies the value)
+- {"operation": "SELECT", "index": n, "value": "..."}  choose that option of select control n
+- {"operation": "DONE"}  every requirement of the goal is already visibly satisfied on this page
+- {"operation": "WAIT"} / {"operation": "SCROLL_DOWN"} / {"operation": "SCROLL_UP"}
+Do not re-do satisfied steps; a field that already shows the requested value is done. Return JSON only."""
+
+def teach(goal, history, page, elements):
+    table = [{"index": e["index"], "label": e["label"][:70], "role": e.get("role"), "ops": e["operations"], **({"value": e["value"]} if e.get("value") else {})} for e in elements[:120]]
+    user = {"goal": goal, "actions_so_far": [{k: h.get(k) for k in ("action", "kind", "text")} for h in history[-8:]],
+            "page": {"title": page["title"], "url": page["url"], "text": page["text"][:2500]}, "controls": table}
+    body = {"model": os.environ["TEXT_MODEL"], "max_tokens": 120, "temperature": 0.0, "response_format": {"type": "json_object"},
+            "chat_template_kwargs": {"enable_thinking": False},
+            "messages": [{"role": "system", "content": SYS}, {"role": "user", "content": json.dumps(user, ensure_ascii=False)}]}
+    r = client.post(TEACHER, json=body).json()
+    return json.loads(r["choices"][0]["message"]["content"])
+
+def to_case(goal, history, page, verdict):
+    elements, targets, controls = action_space(page["actions"])
+    op = str(verdict.get("operation", "")).upper()
+    if op in ("DONE",):
+        return {"page": -1, "url": page["url"], "title": page["title"], "goal": goal, "gold_op": "DONE", "gold_id": "DONE", "kind": "done", "label": "",
+                "history": history, "source": "dagger", "page_obj": {k: page[k] for k in ("url", "title", "text", "actions")}}
+    if op in ("CLICK", "TYPE_TEXT", "SELECT"):
+        idx = str(verdict.get("index"))
+        cands = targets.get(op, {})
+        if op == "SELECT":
+            hit = [k for k, a in cands.items() if k.split(":")[0] == idx and (a["value"] == verdict.get("value") or a["label"].endswith(str(verdict.get("value"))))]
+            key = hit[0] if hit else None
+        else:
+            key = idx if idx in cands else None
+        if key is None: return None
+        a = cands[key]
+        return {"page": -1, "url": page["url"], "title": page["title"], "goal": goal, "gold_op": op, "gold_id": a["id"], "kind": a["kind"], "label": a["label"],
+                "history": history, "source": "dagger", "page_obj": {k: page[k] for k in ("url", "title", "text", "actions")}}
+    return None
+
+def main():
+    out = sys.argv[1]
+    tasks = [(u, g) for _, u, g, _ in TASKS] + EXTRA
+    if len(sys.argv) > 2:
+        tasks += [(json.loads(l)["url"], json.loads(l)["goal"]) for l in open(sys.argv[2])]
+    n_cases = n_dis = 0
+    with open(out, "a") as f:
+        for url, goal in tasks:
+            t0 = time.time()
+            try:
+                with Agent(url, goal) as agent:
+                    steps = 0
+                    while agent.state["status"] not in ("done", "blocked") and steps < 12:
+                        page = agent.state["page"]; history = list(agent.state["history"])
+                        elements = action_space(page["actions"])[0]
+                        try:
+                            verdict = teach(goal, history, page, elements)
+                        except Exception as e:
+                            print("  teacher fail", str(e)[:60]); break
+                        case = to_case(goal, [{k: h.get(k) for k in ("action", "kind", "text", "page_changed")} for h in history], page, verdict)
+                        if case:
+                            f.write(json.dumps(case, ensure_ascii=False) + "\n"); f.flush(); n_cases += 1
+                        # step the agent with its own policy
+                        try:
+                            st = agent.command("tick")
+                        except Exception as e:
+                            print("  tick fail", type(e).__name__, str(e)[:50]); break
+                        d = st["decisions"][-1] if st["decisions"] else None
+                        agent_choice = (d["operation"], d.get("target")) if d else None
+                        teacher_choice = (str(verdict.get("operation", "")).upper(), str(verdict.get("index")) if verdict.get("index") is not None else None)
+                        if agent_choice and agent_choice[0] != teacher_choice[0] or (agent_choice and agent_choice[1] != teacher_choice[1] and teacher_choice[0] in ("CLICK", "TYPE_TEXT")):
+                            n_dis += 1
+                        steps += 1
+            except Exception as e:
+                print(f"  task fail {type(e).__name__}: {str(e)[:60]}")
+            print(f"{goal[:60]:60s} cases={n_cases} disagreements={n_dis} {time.time()-t0:.0f}s", flush=True)
+    print("wrote", n_cases, "cases ->", out)
+
+if __name__ == "__main__":
+    main()

code/finetune/eval.py

@@ -0,0 +1,33 @@
+"""Held-out eval: operation accuracy and target top-1 (given the gold operation) on unseen pages.
+
+    python finetune/eval.py out/pages.jsonl out/eval_cases.jsonl <checkpoint dir> [subfolder]
+"""
+import json, os, sys, time
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, "/home/ckl/projects/S/laya-upstream")  # laya with Agent.accelerate()
+from common_ft import build_request
+import laya
+
+def main():
+    pages = [json.loads(l) for l in open(sys.argv[1])]; cases = [json.loads(l) for l in open(sys.argv[2])]
+    agent = laya.load(sys.argv[3], subfolder=sys.argv[4] if len(sys.argv) > 4 else None)
+    agent.cfg["max_len"], agent.cfg["head_max_len"] = 1024, int(os.environ.get("LAYA_HEAD", agent.cfg.get("head_max_len_train", 512)))
+    agent.accelerate()
+    op_ok = tgt_ok = tgt_n = 0; ranks = []; t = time.time(); by_kind = {}
+    for c in cases:
+        state, questions, targets, controls = build_request(c.get("page_obj") or pages[c["page"]], c["goal"], c.get("history", []))
+        r = agent.predict(state, questions)["answers"]
+        op_hit = r["operation"]["choice"] == c["gold_op"]; op_ok += op_hit
+        k = by_kind.setdefault(f"{c.get('source', 'live'):9s} {c['gold_op']}", [0, 0, 0]); k[0] += 1; k[1] += op_hit
+        if c.get("gold_index") is not None:
+            a = r[c["gold_op"].lower() + "_target"]; probs = a["probabilities"]
+            order = sorted(probs, key=probs.get, reverse=True); rank = order.index(c["gold_index"]) + 1
+            tgt_n += 1; tgt_ok += rank == 1; ranks.append(rank / len(probs)); k[2] += rank == 1
+    dt = (time.time() - t) / len(cases) * 1000
+    print(f"{sys.argv[3]}/{sys.argv[4] if len(sys.argv) > 4 else ''}: cases {len(cases)}  operation acc {op_ok/len(cases):.3f}  "
+          f"target top-1 {tgt_ok/max(1,tgt_n):.3f} (n={tgt_n}, mean normalized rank {sum(ranks)/max(1,len(ranks)):.3f})  {dt:.0f} ms/case")
+    for kind, (n, o, tg) in sorted(by_kind.items()):
+        print(f"   {kind:19s} n={n:4d} op acc {o/n:.2f}" + (f"  target top-1 {tg/n:.2f}" if not kind.endswith("DONE") else ""))
+
+if __name__ == "__main__":
+    main()

code/finetune/gen_goals.py

@@ -0,0 +1,85 @@
+"""Reverse-generate browser goals with a local LLM: pick an element as gold, ask Qwen to write the user goal for it.
+
+    python finetune/gen_goals.py out/pages.jsonl out/cases.jsonl [per_page=12]
+
+Each case: {url, title, goal, gold_op, gold_id, gold_node, kind, label}.  Also one DONE case per page.
+"""
+import json, os, random, sys, threading
+from concurrent.futures import ThreadPoolExecutor
+import httpx
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast")
+from jev_ultrafast.model import action_space
+
+LLM = os.environ.get("TEXT_MODEL_BASE_URL", "http://127.0.0.1:30000/v1") + "/chat/completions"
+MODEL = os.environ.get("TEXT_MODEL", "Qwen/Qwen3-8B-AWQ")
+client = httpx.Client(timeout=120)
+
+SYS = """You write realistic browser-automation goals. Given a web page and ONE target control on it, write the goal a user
+would give to an assistant such that the assistant's NEXT step is to use exactly that control. Rules:
+- One or two sentences, natural language, from the user's perspective, mention what they want (not the UI mechanics).
+- The goal must single out the target among the other listed controls; do not mention element numbers.
+- For a text field, the goal must imply typing a concrete value into it (include the value).
+- For a dropdown option, the goal must imply choosing that option.
+- Vary phrasing: sometimes terse ("open the login page"), sometimes contextual ("I want to read about X, take me there").
+Return JSON: {"goal": "..."}"""
+
+def ask(page, target, others):
+    user = {"page": {"title": page["title"], "url": page["url"], "text_excerpt": page["text"][:700]},
+            "target": {"kind": target["kind"], "label": target["label"], "role": target.get("role"),
+                       "value": target.get("value", target.get("current_value", ""))},
+            "other_controls_on_page": [o["label"][:60] for o in others]}
+    body = {"model": MODEL, "max_tokens": 200, "temperature": 0.9, "response_format": {"type": "json_object"},
+            "chat_template_kwargs": {"enable_thinking": False},
+            "messages": [{"role": "system", "content": SYS}, {"role": "user", "content": json.dumps(user, ensure_ascii=False)}]}
+    r = client.post(LLM, json=body).json()
+    goal = json.loads(r["choices"][0]["message"]["content"])["goal"]
+    return goal.strip()
+
+def main():
+    src, out, per_page = sys.argv[1], sys.argv[2], int(sys.argv[3]) if len(sys.argv) > 3 else 12
+    pages = [json.loads(l) for l in open(src)]
+    rng = random.Random(1)
+    jobs = []
+    for pi, page in enumerate(pages):
+        elements, targets, controls = action_space(page["actions"])
+        cands = [a for a in page["actions"] if a["kind"] in ("click", "fill", "select")]
+        # de-duplicate by label, prefer informative labels
+        seen, uniq = set(), []
+        for a in cands:
+            lab = a["label"].split(" → ")[0].strip()
+            if len(lab) < 2 or lab.lower() in seen: continue
+            seen.add(lab.lower()); uniq.append(a)
+        rng.shuffle(uniq)
+        fills = [a for a in uniq if a["kind"] == "fill"][:3]
+        picks = fills + [a for a in uniq if a["kind"] != "fill"][: max(0, per_page - len(fills))]
+        for a in picks:
+            others = rng.sample([o for o in uniq if o is not a], min(10, len(uniq) - 1))
+            jobs.append((pi, page, a, others))
+    print(f"{len(pages)} pages -> {len(jobs)} goal jobs", flush=True)
+    lock = threading.Lock(); done = [0]
+    def work(job):
+        pi, page, a, others = job
+        try:
+            goal = ask(page, a, others)
+        except Exception as e:
+            print("fail", type(e).__name__, str(e)[:60], flush=True); return None
+        with lock:
+            done[0] += 1
+            if done[0] % 50 == 0: print(f"  {done[0]}/{len(jobs)}", flush=True)
+        op = {"click": "CLICK", "fill": "TYPE_TEXT", "select": "SELECT"}[a["kind"]]
+        return {"page": pi, "url": page["url"], "title": page["title"], "goal": goal, "gold_op": op, "gold_id": a["id"],
+                "gold_node": a.get("node"), "kind": a["kind"], "label": a["label"]}
+    with ThreadPoolExecutor(16) as ex:
+        cases = [c for c in ex.map(work, jobs) if c]
+    for pi, page in enumerate(pages):   # DONE cases: the goal is already satisfied by the current page
+        cases.append({"page": pi, "url": page["url"], "title": page["title"], "gold_op": "DONE", "gold_id": "DONE", "kind": "done",
+                      "label": "", "goal": rng.choice([f"Open the page titled '{page['title'][:70]}'. Stop once it is open.",
+                                                       f"Go to {page['url']} and stop when it has loaded.",
+                                                       f"Navigate to the '{page['title'][:50]}' page."])})
+    with open(out, "w") as f:
+        for c in cases: f.write(json.dumps(c, ensure_ascii=False) + "\n")
+    print("wrote", len(cases), "cases ->", out)
+    for c in rng.sample(cases, 8): print(f"  [{c['gold_op']:9s}] {c['label'][:35]:35s} <- {c['goal'][:90]}")
+
+if __name__ == "__main__":
+    main()

code/finetune/gen_step2.py

@@ -0,0 +1,50 @@
+"""Step-2 negatives: on landing pages from done_cases (history = one executed click), reverse-generate NEW goals whose
+next step is another element on that page. Breaks the 'any history => DONE' shortcut.
+
+    python finetune/gen_step2.py out/done_cases.jsonl out/step2_cases.jsonl [per_page=3]
+"""
+import json, random, sys, threading
+from concurrent.futures import ThreadPoolExecutor
+sys.path.insert(0, "/home/ckl/projects/S/laya/finetune")
+from gen_goals import ask
+
+def main():
+    src, out, per = sys.argv[1], sys.argv[2], int(sys.argv[3]) if len(sys.argv) > 3 else 3
+    dones = [json.loads(l) for l in open(src)]
+    rng = random.Random(7); jobs = []
+    for d in dones:
+        page = d["page_obj"]
+        cands = [a for a in page["actions"] if a["kind"] in ("click", "fill", "select") and len(a["label"].split(" → ")[0].strip()) > 1
+                 and a["label"] != d["label"]]
+        seen, uniq = set(), []
+        for a in cands:
+            k = a["label"].lower()
+            if k in seen: continue
+            seen.add(k); uniq.append(a)
+        rng.shuffle(uniq)
+        fills = [a for a in uniq if a["kind"] == "fill"][:1]
+        for a in fills + [a for a in uniq if a["kind"] != "fill"][: per - len(fills)]:
+            jobs.append((d, a, rng.sample([o for o in uniq if o is not a], min(10, len(uniq) - 1))))
+    print(f"{len(dones)} landing pages -> {len(jobs)} jobs", flush=True)
+    lock = threading.Lock(); n = [0]
+    def work(job):
+        d, a, others = job
+        try:
+            goal = ask(d["page_obj"], a, others)
+        except Exception as e:
+            print("fail", str(e)[:60], flush=True); return None
+        with lock:
+            n[0] += 1
+            if n[0] % 100 == 0: print(f"  {n[0]}/{len(jobs)}", flush=True)
+        op = {"click": "CLICK", "fill": "TYPE_TEXT", "select": "SELECT"}[a["kind"]]
+        # keep the history: the previous click is unrelated to the new goal, which is what happens mid-task all the time
+        return {**{k: d[k] for k in ("page", "url", "title", "history", "page_obj")}, "goal": goal, "gold_op": op, "gold_id": a["id"],
+                "gold_node": a.get("node"), "kind": a["kind"], "label": a["label"], "source": "live"}
+    with ThreadPoolExecutor(16) as ex:
+        cases = [c for c in ex.map(work, jobs) if c]
+    with open(out, "w") as f:
+        for c in cases: f.write(json.dumps(c, ensure_ascii=False) + "\n")
+    print("wrote", len(cases))
+
+if __name__ == "__main__":
+    main()

code/finetune/make_done_cases.py

@@ -0,0 +1,47 @@
+"""Turn click cases into realistic DONE cases by actually executing the click in the browser.
+
+    python finetune/make_done_cases.py out/pages.jsonl out/cases.jsonl out/done_cases.jsonl [max=250]
+
+For a click case (page A, goal, gold element): open A, click the gold element, observe the landing page B.
+If the page changed, emit {goal, gold_op: DONE, page_obj: B, history: [that click]} with the same goal phrasing.
+"""
+import json, os, random, sys, time
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast")
+os.environ.setdefault("BU_CDP_URL", "http://127.0.0.1:9222")
+from jev_ultrafast.browser import Browser
+
+def main():
+    pages_f, cases_f, out = sys.argv[1:4]; mx = int(sys.argv[4]) if len(sys.argv) > 4 else 250
+    pages = [json.loads(l) for l in open(pages_f)]
+    cases = [c for c in (json.loads(l) for l in open(cases_f)) if c["kind"] == "click"]
+    rng = random.Random(3); rng.shuffle(cases)
+    n_ok = n_try = 0
+    with open(out, "w") as f:
+        for c in cases:
+            if n_ok >= mx: break
+            src = pages[c["page"]]; n_try += 1
+            try:
+                b = Browser(src["url"])
+                try:
+                    page = b.observe(screenshot=False)
+                    act = next((a for a in page["actions"] if a["kind"] == "click" and a["label"] == c["label"]), None)
+                    if act is None:
+                        continue
+                    b.act(act, page); time.sleep(0.3)
+                    dest = b.observe(screenshot=False)
+                finally:
+                    b.close()
+            except Exception as e:
+                print("fail", type(e).__name__, str(e)[:60], flush=True); continue
+            if dest["url"] == page["url"] and dest["title"] == page["title"]:
+                continue
+            hist = [{"action": act["label"], "kind": "click", "text": None, "page_changed": True}]
+            f.write(json.dumps({"page": c["page"], "url": dest["url"], "title": dest["title"], "goal": c["goal"], "gold_op": "DONE",
+                                "gold_id": "DONE", "kind": "done", "label": act["label"], "history": hist,
+                                "page_obj": {k: dest[k] for k in ("url", "title", "text", "actions")}}, ensure_ascii=False) + "\n"); f.flush()
+            n_ok += 1
+            if n_ok % 25 == 0: print(f"  {n_ok} done cases from {n_try} tries", flush=True)
+    print("wrote", n_ok, "DONE cases")
+
+if __name__ == "__main__":
+    main()

code/finetune/rollouts.py

@@ -0,0 +1,109 @@
+"""Scripted multi-step trajectories executed in the real browser, for the three skills the model lacks:
+  scroll   : goal targets an element that is only visible after scrolling  -> [SCROLL_DOWN, CLICK, DONE]
+  search   : goal asks to search for a phrase in a text field               -> [TYPE_TEXT, CLICK submit/suggestion, DONE]
+  select   : goal asks to choose an option of a <select>                    -> [SELECT, DONE]
+
+    python finetune/rollouts.py out/pages.jsonl out/rollout_cases.jsonl [max_pages=300]
+
+Goals are templated (varied phrasing); no LLM needed.  Pages are the crawled ones; the suite's exact URLs are skipped.
+"""
+import json, os, random, re, sys, time
+sys.path.insert(0, "/home/ckl/projects/S/jev-ultrafast")
+os.environ.setdefault("BU_CDP_URL", "http://127.0.0.1:9222")
+from jev_ultrafast.browser import Browser, StalePage
+
+SUITE_URLS = {"https://en.wikipedia.org/wiki/Main_Page", "https://news.ycombinator.com/", "https://github.com/tile-ai/tilelang", "https://www.python.org/",
+              "https://books.toscrape.com/", "https://the-internet.herokuapp.com/dropdown", "https://the-internet.herokuapp.com/checkboxes",
+              "https://quotes.toscrape.com/", "https://duckduckgo.com/", "https://arxiv.org/", "https://www.google.com/travel/flights?hl=en"}
+SCROLL_T = ["Open '{x}'.", "I want to see '{x}', take me there.", "Go to {x}.", "Find and click '{x}' on this page.", "Open the '{x}' link further down the page.", "Navigate to '{x}'."]
+SEARCH_T = ["Search for '{q}'.", "Look up '{q}' using the search box and show the results.", "Find results for '{q}'.", "Use the site search to find '{q}'.", "Search this site for {q}."]
+SELECT_T = ["Select '{o}' in the '{f}' dropdown.", "Choose {o} for {f}.", "Set '{f}' to '{o}'.", "Pick the option '{o}'."]
+QUERIES = ["python tutorial", "flash attention", "climate change", "rust async", "linear algebra", "tilelang", "modernbert", "black holes", "sourdough bread", "gpu kernels"]
+
+def lab(a): return a["label"].split(" → ")[0].strip()
+def case(page, goal, gold_op, gold_id, kind, label, hist, tag):
+    return {"page": -1, "url": page["url"], "title": page["title"], "goal": goal, "gold_op": gold_op, "gold_id": gold_id, "kind": kind, "label": label,
+            "history": hist, "source": "rollout", "skill": tag, "page_obj": {k: page[k] for k in ("url", "title", "text", "actions")}}
+def hist_of(a, text=None, changed=True): return {"action": a["label"], "kind": a["kind"], "text": text, "page_changed": changed}
+def find(page, pred):
+    return next((a for a in page["actions"] if pred(a)), None)
+
+def do_scroll(b, page, rng, out):
+    if not page.get("scroll") or page["scroll"]["height"] < 1300: return 0
+    before = {a["label"] for a in page["actions"] if a["kind"] == "click"}
+    sd = find(page, lambda a: a["id"] == "scroll_down")
+    if not sd: return 0
+    b.act(sd, page); time.sleep(0.3); p2 = b.observe(screenshot=False)
+    new = [a for a in p2["actions"] if a["kind"] == "click" and a["label"] not in before and 3 <= len(lab(a)) <= 60 and a.get("role") in ("link", "button")]
+    if not new: return 0
+    n = 0
+    for tgt in rng.sample(new, min(2, len(new))):
+        goal = rng.choice(SCROLL_T).format(x=lab(tgt))
+        out.write(json.dumps(case(page, goal, "SCROLL_DOWN", "scroll_down", "scroll", "Scroll down", [], "scroll"), ensure_ascii=False) + "\n")
+        out.write(json.dumps(case(p2, goal, "CLICK", tgt["id"], "click", tgt["label"], [hist_of(sd, changed=False)], "scroll"), ensure_ascii=False) + "\n")
+        n += 2
+    # execute one click for a DONE state
+    tgt = new[0]
+    try:
+        b.act(tgt, p2); time.sleep(0.4); p3 = b.observe(screenshot=False)
+        if p3["url"] != p2["url"]:
+            goal = rng.choice(SCROLL_T).format(x=lab(tgt))
+            out.write(json.dumps(case(p3, goal, "DONE", "DONE", "done", "", [hist_of(sd, changed=False), hist_of(tgt)], "scroll"), ensure_ascii=False) + "\n"); n += 1
+    except Exception: pass
+    return n
+
+def do_search(b, page, rng, out):
+    field = find(page, lambda a: a["kind"] == "fill" and re.search(r"search|query|find|keyword", a["label"], re.I))
+    if not field: return 0
+    q = rng.choice(QUERIES); goal = rng.choice(SEARCH_T).format(q=q)
+    out.write(json.dumps(case(page, goal, "TYPE_TEXT", field["id"], "fill", field["label"], [], "search"), ensure_ascii=False) + "\n")
+    b.act(field, page, text=q); time.sleep(0.4); p2 = b.observe(screenshot=False)
+    # submit: a search/go button, or a suggestion containing the query
+    sub = find(p2, lambda a: a["kind"] == "click" and (re.search(r"^(search|go|submit|find)\b", lab(a), re.I) or (a.get("role") in ("option", "listitem", "link") and q.split()[0].lower() in a["label"].lower())))
+    if not sub: return 1
+    out.write(json.dumps(case(p2, goal, "CLICK", sub["id"], "click", sub["label"], [hist_of(field, q, False)], "search"), ensure_ascii=False) + "\n")
+    try:
+        b.act(sub, p2); time.sleep(0.6); p3 = b.observe(screenshot=False)
+        if p3["url"] != p2["url"] or p3["title"] != p2["title"]:
+            out.write(json.dumps(case(p3, goal, "DONE", "DONE", "done", "", [hist_of(field, q, False), hist_of(sub)], "search"), ensure_ascii=False) + "\n"); return 3
+    except Exception: pass
+    return 2
+
+def do_select(b, page, rng, out):
+    sels = [a for a in page["actions"] if a["kind"] == "select" and a.get("value") and a["value"] != a.get("current_value")]
+    if not sels: return 0
+    by_field = {}
+    for a in sels: by_field.setdefault(a["node"], []).append(a)
+    node, opts = rng.choice(list(by_field.items()))
+    opt = rng.choice(opts); f = lab(opt); o = opt["label"].split(" → ")[-1].strip()
+    goal = rng.choice(SELECT_T).format(o=o, f=f)
+    out.write(json.dumps(case(page, goal, "SELECT", opt["id"], "select", opt["label"], [], "select"), ensure_ascii=False) + "\n")
+    try:
+        b.act(opt, page); time.sleep(0.3); p2 = b.observe(screenshot=False)
+        out.write(json.dumps(case(p2, goal, "DONE", "DONE", "done", "", [hist_of(opt, changed=False)], "select"), ensure_ascii=False) + "\n"); return 2
+    except Exception: return 1
+
+def main():
+    pages = [json.loads(l) for l in open(sys.argv[1])]; out_f = sys.argv[2]; mx = int(sys.argv[3]) if len(sys.argv) > 3 else 300
+    rng = random.Random(11); rng.shuffle(pages)
+    counts = {"scroll": 0, "search": 0, "select": 0}; done = 0
+    with open(out_f, "w") as out:
+        for pg in pages:
+            if done >= mx: break
+            if pg["url"] in SUITE_URLS: continue
+            for skill, fn in (("scroll", do_scroll), ("search", do_search), ("select", do_select)):
+                try:
+                    b = Browser(pg["url"])
+                    try:
+                        page = b.observe(screenshot=False); n = fn(b, page, rng, out)
+                    finally:
+                        b.close()
+                    counts[skill] += n
+                except Exception as e:
+                    pass
+            done += 1
+            if done % 25 == 0: print(f"  {done} pages  {counts}", flush=True)
+    print("wrote", counts, "->", out_f)
+
+if __name__ == "__main__":
+    main()

code/finetune/run_after_v6.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# after v6: (1) real-task suite with v6, (2) training-speed benchmark of the three cheap wins, (3) v7 = v6 data with
+# truncated page text + no checkpointing + torch.compile, 3 epochs, calibrate, eval, suite.
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+P=.venv/bin/python
+until grep -qE "V6_DONE|Traceback" finetune/out/v6.log; do sleep 30; done
+echo "== suite v6"
+bash $S/start_infra.sh >/dev/null 2>&1
+bash $S/restart_s1.sh $PWD/finetune/out/laya-browser-v6 999 >/dev/null
+(cd ../jev-ultrafast && SUITE_OUT=$PWD/../laya/finetune/out/suite_v6.json timeout 1500 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -vE "Warn|TileLang")
+bash $S/stop_all.sh >/dev/null 2>&1; sleep 3
+echo "== speed benchmark (256 items, 1 epoch)"
+echo "-- old items (1016 tok), CKPT=1 COMPILE=0"; CKPT=1 COMPILE=0 LIMIT=256 $P finetune/train.py finetune/out/train_items.pt /tmp/bench_ck 1 2>&1 | grep "=== epoch"
+echo "-- old items, CKPT=0 COMPILE=0";            CKPT=0 COMPILE=0 LIMIT=256 $P finetune/train.py finetune/out/train_items.pt /tmp/bench_ck 1 2>&1 | grep -E "=== epoch|OutOfMemory"
+echo "-- old items, CKPT=0 COMPILE=1";            CKPT=0 COMPILE=1 LIMIT=256 $P finetune/train.py finetune/out/train_items.pt /tmp/bench_ck 1 2>&1 | grep -E "=== epoch|OutOfMemory|Error"
+echo "== rebuild items with 3000-char page text"
+$P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl finetune/out/step2_cases.jsonl finetune/out/m2w_cases.jsonl
+echo "-- new items, CKPT=0 COMPILE=1";            CKPT=0 COMPILE=1 LIMIT=256 $P finetune/train.py finetune/out/train_items.pt /tmp/bench_ck 1 2>&1 | grep -E "=== epoch|OutOfMemory|Error"
+echo "== train v7 (3 epochs, fast settings)"; CKPT=0 COMPILE=1 $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v7 3 2>&1 | grep -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate v7"; $P finetune/calibrate.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v7 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v7"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v7 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== suite v7"
+bash $S/start_infra.sh >/dev/null 2>&1
+bash $S/restart_s1.sh $PWD/finetune/out/laya-browser-v7 999 >/dev/null
+(cd ../jev-ultrafast && SUITE_OUT=$PWD/../laya/finetune/out/suite_v7.json timeout 1500 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -vE "Warn|TileLang")
+bash $S/stop_all.sh >/dev/null 2>&1
+echo AFTER_V6_DONE

code/finetune/run_all.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# build items -> zero-shot baselines -> fine-tune -> eval.  Logs to finetune/out/run.log
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+P=.venv/bin/python
+for p in $(pgrep -f "sglang.launch_server"); do kill $p; done; sleep 3
+uv pip install --python $P "httpx[http2]" 2>&1 | tail -1
+set -e
+echo "== build items"; $P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/
+echo "== zero-shot baselines"
+$P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl "$LAYA_BASE" 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+$P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl convaiinnovations/laya multilingual 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== train"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser 4 2>&1 | grep -vE "Warn|warn"
+echo "== eval fine-tuned"
+$P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl finetune/out/laya-browser 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo RUN_ALL_DONE

code/finetune/run_final.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Final comparison after v10s: v10 vs v10s, gating off vs tau=0.7, 3 runs per task; plus per-step latency profiles.
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+O=finetune/out; P=.venv/bin/python
+until grep -q "V10S_DONE" $O/v10s.log; do sleep 60; done
+echo "== per-step latency"
+for ck in laya-browser-v10 laya-browser-v10s; do echo "-- $ck"; $P apps/profile_step.py $PWD/$O/$ck 2>&1 | grep -vE "TileLang|Warn|warn|Fetch|loaded"; done
+bash $S/start_infra.sh >/dev/null 2>&1
+for ck in laya-browser-v10 laya-browser-v10s; do
+  for tau in 0 0.7; do
+    echo "== suite $ck tau=$tau x3"
+    export ESCALATE_TAU=$tau ESCALATE_LOG=$PWD/$O/escalations_final_${ck}_$tau.jsonl; rm -f $ESCALATE_LOG
+    bash $S/restart_s1.sh $PWD/$O/$ck 999 >/dev/null
+    (cd ../jev-ultrafast && REPEATS=3 SUITE_OUT=$PWD/../laya/$O/suite_final_${ck}_$tau.json timeout 3000 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -E "^==|per task")
+    curl -s http://127.0.0.1:8791/ | python3 -c "import json,sys; d=json.load(sys.stdin); print(f\"   server calls={d['calls']} escalated={d['escalated']} ({100*d['escalated']/max(1,d['calls']):.0f}%)\")"
+  done
+done
+bash $S/stop_all.sh >/dev/null 2>&1
+echo FINAL_DONE

code/finetune/run_gated.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# after v10: real-task suite with System-1/System-2 gating at several confidence thresholds; escalations logged as DAgger cases
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+O=finetune/out
+until grep -q "V10_DONE" $O/v10.log; do sleep 60; done
+bash $S/start_infra.sh >/dev/null 2>&1
+for tau in 0.5 0.7 0.9; do
+  echo "== suite v10 + gating tau=$tau"
+  export ESCALATE_TAU=$tau ESCALATE_LOG=$PWD/$O/escalations_tau$tau.jsonl
+  rm -f $ESCALATE_LOG
+  bash $S/restart_s1.sh $PWD/$O/laya-browser-v10 999 >/dev/null
+  (cd ../jev-ultrafast && SUITE_OUT=$PWD/../laya/$O/suite_v10_tau$tau.json timeout 1500 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -vE "Warn|TileLang")
+  curl -s http://127.0.0.1:8791/ | python3 -c "import json,sys; d=json.load(sys.stdin); print(f\"   server calls={d['calls']} escalated={d['escalated']} ({100*d['escalated']/max(1,d['calls']):.0f}%)\")"
+done
+bash $S/stop_all.sh >/dev/null 2>&1
+echo GATED_DONE

code/finetune/run_suite_fixed.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# after the teacher eval: re-run the 16-task suite x3 for v11s, v10s and v10 with the corrected checks
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh; O=finetune/out
+until grep -q "TEACHER_EVAL_DONE" $O/teacher_eval.log; do sleep 60; done
+bash $S/stop_all.sh >/dev/null 2>&1; bash $S/bonsai.sh stop >/dev/null 2>&1
+curl -s -m 3 http://127.0.0.1:9222/json/version >/dev/null || (nohup chromium --headless=new --remote-debugging-port=9222 --user-data-dir=$S/chrome-profile --window-size=1120,780 --no-first-run --lang=en-US about:blank >/dev/null 2>&1 &); sleep 3
+for ck in laya-browser-v11s laya-browser-v10s laya-browser-v10; do
+  echo "== suite $ck x3 (fixed checks)"
+  ESCALATE_TAU=0 bash $S/restart_s1.sh $PWD/$O/$ck 999 >/dev/null
+  (cd ../jev-ultrafast && REPEATS=3 SUITE_OUT=$PWD/../laya/$O/suite_fixed_$ck.json timeout 3000 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -E "^==|per task")
+done
+bash $S/stop_all.sh >/dev/null 2>&1
+echo SUITE_FIXED_DONE

code/finetune/run_teacher_eval.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# after v11: compare teachers on 80 held-out cases (40 Mind2Web human-labelled + 40 live), then laya v10s / v11s on the same cases.
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+O=finetune/out; P=.venv/bin/python
+until grep -q "V11_DONE" $O/v11.log; do sleep 60; done
+bash $S/stop_all.sh >/dev/null 2>&1
+echo "== 27B (bonsai), thinking off"
+bash $S/bonsai.sh start
+$P finetune/teacher_eval.py $O/pages.jsonl $O/eval_cases.jsonl http://127.0.0.1:30001/v1 "bonsai-27b think=off" 80
+echo "== 27B, thinking full"
+$P finetune/teacher_eval.py $O/pages.jsonl $O/eval_cases.jsonl http://127.0.0.1:30001/v1 "bonsai-27b think=full" 40 --think
+bash $S/bonsai.sh stop
+echo "== 27B, thinking budget 300 tokens (--reasoning-budget 300)"
+bash $S/bonsai.sh start --reasoning-budget 300
+$P finetune/teacher_eval.py $O/pages.jsonl $O/eval_cases.jsonl http://127.0.0.1:30001/v1 "bonsai-27b think=budget300" 80 --think
+bash $S/bonsai.sh stop
+echo "== 27B, thinking with --reasoning-effort low (server flag)"
+bash $S/bonsai.sh start --reasoning-effort low
+$P finetune/teacher_eval.py $O/pages.jsonl $O/eval_cases.jsonl http://127.0.0.1:30001/v1 "bonsai-27b think=low" 40 --think
+bash $S/bonsai.sh stop
+echo "== Qwen3-8B-AWQ, thinking off"
+bash $S/start_infra.sh >/dev/null 2>&1
+$P finetune/teacher_eval.py $O/pages.jsonl $O/eval_cases.jsonl http://127.0.0.1:30000/v1 "qwen3-8b think=off" 80
+bash $S/stop_all.sh >/dev/null 2>&1
+echo "== laya v10s / v11s on the full eval set (for reference)"
+LAYA_FMT=v3 $P finetune/eval.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v10s 2>&1 | grep -vE "TileLang|Warn|warn|Fetch" | head -1
+LAYA_FMT=v3 $P finetune/eval.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v11s 2>&1 | grep -vE "TileLang|Warn|warn|Fetch" | head -1
+echo TEACHER_EVAL_DONE

code/finetune/run_train.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+P=.venv/bin/python
+echo "== train"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser 4 2>&1 | grep -vE "Warn|warn"
+echo "== eval fine-tuned"
+$P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo TRAIN_DONE

code/finetune/run_v10.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# v10 = v9 recipe (format v2, head 768, 4 epochs) + the live data that failed silently in v9: goals on 421 pages,
+# real DONE, step-2, DAgger with policy v9.  Full logs kept per step under finetune/out/v10_*.log
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True CKPT=0 COMPILE=0
+P=.venv/bin/python; O=finetune/out
+bash $S/start_infra.sh
+for i in 1 2 3 4 5 6; do
+  r=$(curl -s -m 60 http://127.0.0.1:30000/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"Qwen/Qwen3-8B-AWQ","max_tokens":20,"chat_template_kwargs":{"enable_thinking":false},"messages":[{"role":"user","content":"say ok"}]}' | head -c 300)
+  echo "sglang probe: $r" | cut -c1-120; echo "$r" | grep -q '"content"' && break; sleep 20
+done
+echo "== goals (421 pages)"; (cd ../jev-ultrafast && timeout 5400 .venv/bin/python ../laya/finetune/gen_goals.py ../laya/finetune/out/pages.jsonl ../laya/finetune/out/cases.jsonl 12 > ../laya/$O/v10_goals.log 2>&1); tail -3 $O/v10_goals.log; echo "cases: $(wc -l < $O/cases.jsonl)"
+echo "== real DONE"; (cd ../jev-ultrafast && timeout 5400 .venv/bin/python ../laya/finetune/make_done_cases.py ../laya/finetune/out/pages.jsonl ../laya/finetune/out/cases.jsonl ../laya/finetune/out/done_cases.jsonl 700 > ../laya/$O/v10_done.log 2>&1); tail -1 $O/v10_done.log
+echo "== step-2"; (cd ../jev-ultrafast && timeout 3600 .venv/bin/python ../laya/finetune/gen_step2.py ../laya/finetune/out/done_cases.jsonl ../laya/finetune/out/step2_cases.jsonl 2 > ../laya/$O/v10_step2.log 2>&1); tail -1 $O/v10_step2.log
+echo "== dagger (policy v9)"
+bash $S/restart_s1.sh $PWD/$O/laya-browser-v9 999 >/dev/null
+(cd ../jev-ultrafast && timeout 3000 .venv/bin/python ../laya/finetune/dagger.py ../laya/finetune/out/dagger_cases.jsonl > ../laya/$O/v10_dagger.log 2>&1); tail -1 $O/v10_dagger.log
+bash $S/stop_all.sh >/dev/null 2>&1; sleep 3
+export LAYA_FMT=v2 LAYA_HEAD=768
+echo "== build v10"; $P finetune/build_items.py $O/pages.jsonl $O/cases.jsonl $O/ $O/done_cases.jsonl $O/step2_cases.jsonl $O/m2w_cases.jsonl $O/dagger_cases.jsonl
+echo "== train v10 (4 epochs)"; $P finetune/train.py $O/train_items.pt $O/laya-browser-v10 4 2>&1 | grep --line-buffered -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate"; $P finetune/calibrate.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v10 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v10"; $P finetune/eval.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v10 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v9 (same eval)"; $P finetune/eval.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v9 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== suite v10"
+bash $S/start_infra.sh >/dev/null 2>&1
+bash $S/restart_s1.sh $PWD/$O/laya-browser-v10 999 >/dev/null
+(cd ../jev-ultrafast && SUITE_OUT=$PWD/../laya/$O/suite_v10.json timeout 1500 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -vE "Warn|TileLang")
+bash $S/stop_all.sh >/dev/null 2>&1
+echo V10_DONE

code/finetune/run_v10s.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+# v10s: same data as v10, 322M mmBERT-base (multilingual) backbone, format v3 -> target ~20 ms per browser step.
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+until grep -q "GATED_DONE" finetune/out/gated.log; do sleep 60; done
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/multilingual | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True CKPT=0 COMPILE=0 LAYA_FMT=v3 LAYA_HEAD=768
+P=.venv/bin/python; O=finetune/out
+echo "== build v10s (format v3, mmBERT-base tokenizer)"
+$P finetune/build_items.py $O/pages.jsonl $O/cases.jsonl $O/ $O/done_cases.jsonl $O/step2_cases.jsonl $O/m2w_cases.jsonl $O/dagger_cases.jsonl
+echo "== train v10s (4 epochs)"; $P finetune/train.py $O/train_items.pt $O/laya-browser-v10s 4 2>&1 | grep --line-buffered -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate"; $P finetune/calibrate.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v10s 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v10s"; $P finetune/eval.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v10s 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== profile step"; $P apps/profile_step.py $PWD/$O/laya-browser-v10s 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+bash $S/start_infra.sh >/dev/null 2>&1
+for tau in 0 0.7; do
+  echo "== suite v10s tau=$tau"
+  export ESCALATE_TAU=$tau ESCALATE_LOG=$PWD/$O/escalations_v10s_tau$tau.jsonl; rm -f $ESCALATE_LOG
+  bash $S/restart_s1.sh $PWD/$O/laya-browser-v10s 999 >/dev/null
+  (cd ../jev-ultrafast && SUITE_OUT=$PWD/../laya/$O/suite_v10s_tau$tau.json timeout 1500 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -vE "Warn|TileLang")
+  curl -s http://127.0.0.1:8791/ | python3 -c "import json,sys; d=json.load(sys.stdin); print(f\"   server calls={d['calls']} escalated={d['escalated']} ({100*d['escalated']/max(1,d['calls']):.0f}%)\")"
+done
+bash $S/stop_all.sh >/dev/null 2>&1
+echo V10S_DONE

code/finetune/run_v11.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# v11s: v10s recipe + scripted scroll / search-submit / select trajectories (rollout_cases, x3), then 16 tasks x3.
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+O=finetune/out; P=.venv/bin/python
+until ! pgrep -f "finetune/rollouts.py" >/dev/null; do sleep 60; done
+echo "== rollout cases: $(wc -l < $O/rollout_cases.jsonl)"
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/multilingual | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True CKPT=0 COMPILE=0 LAYA_FMT=v3 LAYA_HEAD=768
+echo "== build v11s"
+$P finetune/build_items.py $O/pages.jsonl $O/cases.jsonl $O/ $O/done_cases.jsonl $O/step2_cases.jsonl $O/m2w_cases.jsonl $O/dagger_cases.jsonl $O/rollout_cases.jsonl
+echo "== train v11s (4 epochs)"; $P finetune/train.py $O/train_items.pt $O/laya-browser-v11s 4 2>&1 | grep --line-buffered -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate"; $P finetune/calibrate.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v11s 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v11s"; $P finetune/eval.py $O/pages.jsonl $O/eval_cases.jsonl $PWD/$O/laya-browser-v11s 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== suite v11s x3"
+bash $S/start_infra.sh >/dev/null 2>&1
+export ESCALATE_TAU=0
+bash $S/restart_s1.sh $PWD/$O/laya-browser-v11s 999 >/dev/null
+(cd ../jev-ultrafast && REPEATS=3 SUITE_OUT=$PWD/../laya/$O/suite_final_v11s.json timeout 3000 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -E "^==|per task")
+bash $S/stop_all.sh >/dev/null 2>&1
+echo V11_DONE

code/finetune/run_v2.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+P=.venv/bin/python
+for p in $(pgrep -f "sglang.launch_server|apps/systemone_server"); do kill $p; done; sleep 3
+echo "== build"; $P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl
+echo "== zero-shot baseline (typed) on v2 eval"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl "$LAYA_BASE" 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== train v2"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v2 4 2>&1 | grep -E "=== epoch|saved|Error|Traceback"
+echo "== eval v2"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v2 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo V2_DONE

code/finetune/run_v3.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+P=.venv/bin/python
+for p in $(pgrep -f "sglang.launch_server|apps/systemone_server"); do kill $p; done; sleep 3
+echo "== build"; $P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl finetune/out/m2w_cases.jsonl
+echo "== zero-shot baseline (typed) on v2 eval"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl "$LAYA_BASE" 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== train v3"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v3 4 2>&1 | grep -E "=== epoch|saved|Error|Traceback"
+echo "== eval v3"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v3 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo V3_DONE

code/finetune/run_v4.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+P=.venv/bin/python
+for p in $(pgrep -f "sglang.launch_server|apps/systemone_server"); do kill $p; done; sleep 3
+echo "== wait for shards"; until [ "$(ls finetune/data/mind2web/data/train/train_*.json 2>/dev/null | wc -l)" -ge 11 ] && ! ls finetune/data/mind2web/data/train/*.incomplete >/dev/null 2>&1; do sleep 10; done
+echo "== convert all shards"; $P finetune/convert_mind2web.py finetune/data/mind2web/data/train/train_*.json finetune/out/m2w_cases.jsonl 2>&1 | tail -1
+echo "== build"; $P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl finetune/out/m2w_cases.jsonl
+echo "== train v4 (3 epochs)"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v4 3 2>&1 | grep -E "=== epoch|saved|Error|Traceback"
+echo "== eval v4"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v4 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v3 on same eval set"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v3 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo V4_DONE

code/finetune/run_v5.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+P=.venv/bin/python
+for p in $(pgrep -f "sglang.launch_server|apps/systemone_server"); do kill $p; done; sleep 3
+
+echo "== convert all shards"; $P finetune/convert_mind2web.py finetune/data/mind2web/data/train/train_*.json finetune/out/m2w_cases.jsonl 2>&1 | tail -1
+echo "== build"; $P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl finetune/out/m2w_cases.jsonl
+echo "== train v5 (3 epochs)"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v5 3 2>&1 | grep -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate"; $P finetune/calibrate.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v5 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v5"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v5 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+
+echo V5_DONE

code/finetune/run_v6.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+P=.venv/bin/python
+for p in $(pgrep -f "sglang.launch_server|apps/systemone_server"); do kill $p; done; sleep 3
+
+
+echo "== build"; $P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl finetune/out/step2_cases.jsonl finetune/out/m2w_cases.jsonl
+echo "== train v6 (3 epochs)"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v6 3 2>&1 | grep -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate"; $P finetune/calibrate.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v6 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v6"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v6 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+
+echo V6_DONE

code/finetune/run_v7.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# v7: best training config (no checkpointing, no compile, 3000-char page text) + DONE oversampling x4.
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True CKPT=0 COMPILE=0
+P=.venv/bin/python
+echo "== build (3000-char text, DONE x4)"
+$P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl finetune/out/step2_cases.jsonl finetune/out/m2w_cases.jsonl
+echo "== speed: new items, CKPT=0 COMPILE=0 (256 items)"; LIMIT=256 $P finetune/train.py finetune/out/train_items.pt /tmp/bench_ck 1 2>&1 | grep -E "=== epoch|Error"
+echo "== train v7 (3 epochs)"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v7 3 2>&1 | grep --line-buffered -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate v7"; $P finetune/calibrate.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v7 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v7"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v7 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v6 on same (truncated) eval"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v6 2>&1 | grep -vE "TileLang|Warn|warn|Fetch" | head -1
+echo "== suite v7"
+bash $S/start_infra.sh >/dev/null 2>&1
+bash $S/restart_s1.sh $PWD/finetune/out/laya-browser-v7 999 >/dev/null
+(cd ../jev-ultrafast && SUITE_OUT=$PWD/../laya/finetune/out/suite_v7.json timeout 1500 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -vE "Warn|TileLang")
+bash $S/stop_all.sh >/dev/null 2>&1
+echo V7_DONE

code/finetune/run_v8.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# v8: after v7 -> DAgger harvest on real tasks with v7 as the policy and Qwen as teacher -> retrain -> eval -> suite.
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True CKPT=0 COMPILE=0
+P=.venv/bin/python
+echo "== build v8"
+$P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl finetune/out/step2_cases.jsonl finetune/out/m2w_cases.jsonl finetune/out/dagger_cases.jsonl
+echo "== train v8 (3 epochs)"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v8 3 2>&1 | grep --line-buffered -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate v8"; $P finetune/calibrate.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v8 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v8"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v8 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== suite v8"
+bash $S/start_infra.sh >/dev/null 2>&1
+bash $S/restart_s1.sh $PWD/finetune/out/laya-browser-v8 999 >/dev/null
+(cd ../jev-ultrafast && SUITE_OUT=$PWD/../laya/finetune/out/suite_v8.json timeout 1500 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -vE "Warn|TileLang")
+bash $S/stop_all.sh >/dev/null 2>&1
+echo V8_DONE

code/finetune/run_v9.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# v9 "one shot": 420 pages -> goals -> real DONE -> step-2 -> DAgger (policy v8) -> format v2 (head 768) -> 4 epochs -> eval -> suite
+S=/tmp/claude-1000/-home-ckl-projects-S/8a7ce50a-5640-4606-837a-93df5ff48c83/scratchpad
+cd /home/ckl/projects/S/laya && source env.sh
+export LAYA_BASE=$(ls -d ~/.cache/huggingface/hub/models--convaiinnovations--laya/snapshots/*/typed-decisions | head -1)
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True CKPT=0 COMPILE=0
+P=.venv/bin/python; J=../jev-ultrafast/.venv/bin/python
+until grep -q "V8_DONE" finetune/out/v8.log && grep -q "^done" finetune/out/collect2.log; do sleep 30; done
+echo "== pages: $(wc -l < finetune/out/pages.jsonl)"
+bash $S/start_infra.sh >/dev/null 2>&1
+echo "== goals for all pages"; (cd ../jev-ultrafast && timeout 3600 .venv/bin/python ../laya/finetune/gen_goals.py ../laya/finetune/out/pages.jsonl ../laya/finetune/out/cases.jsonl 12 2>&1 | tail -2)
+echo "== real DONE cases"; (cd ../jev-ultrafast && timeout 3600 .venv/bin/python ../laya/finetune/make_done_cases.py ../laya/finetune/out/pages.jsonl ../laya/finetune/out/cases.jsonl ../laya/finetune/out/done_cases.jsonl 700 2>&1 | tail -1)
+echo "== step-2 negatives"; (cd ../jev-ultrafast && timeout 1800 .venv/bin/python ../laya/finetune/gen_step2.py ../laya/finetune/out/done_cases.jsonl ../laya/finetune/out/step2_cases.jsonl 2 2>&1 | tail -1)
+echo "== dagger round 2 (policy v8)"
+bash $S/restart_s1.sh $PWD/finetune/out/laya-browser-v8 999 >/dev/null
+(cd ../jev-ultrafast && timeout 3000 .venv/bin/python ../laya/finetune/dagger.py ../laya/finetune/out/dagger_cases.jsonl 2>&1 | tail -1)
+bash $S/stop_all.sh >/dev/null 2>&1; sleep 3
+export LAYA_FMT=v2 LAYA_HEAD=768
+echo "== build v9 (format v2, head 768)"
+$P finetune/build_items.py finetune/out/pages.jsonl finetune/out/cases.jsonl finetune/out/ finetune/out/done_cases.jsonl finetune/out/step2_cases.jsonl finetune/out/m2w_cases.jsonl finetune/out/dagger_cases.jsonl
+echo "== train v9 (4 epochs)"; $P finetune/train.py finetune/out/train_items.pt finetune/out/laya-browser-v9 4 2>&1 | grep --line-buffered -E "=== epoch|saved|Error|Traceback"
+echo "== calibrate v9"; $P finetune/calibrate.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v9 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== eval v9"; $P finetune/eval.py finetune/out/pages.jsonl finetune/out/eval_cases.jsonl $PWD/finetune/out/laya-browser-v9 2>&1 | grep -vE "TileLang|Warn|warn|Fetch"
+echo "== suite v9"
+bash $S/start_infra.sh >/dev/null 2>&1
+bash $S/restart_s1.sh $PWD/finetune/out/laya-browser-v9 999 >/dev/null
+(cd ../jev-ultrafast && SUITE_OUT=$PWD/../laya/finetune/out/suite_v9.json timeout 1500 .venv/bin/python ../laya/apps/browser_suite.py 2>&1 | grep -vE "Warn|TileLang")
+bash $S/stop_all.sh >/dev/null 2>&1
+echo V9_DONE