@qqbrowser/openclaw-qbot 0.10.15 → 0.10.16

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.15",
-  "commit": "7187441ef98deb503e2d1dd34633df3768e5f7d7",
-  "builtAt": "2026-06-03T02:08:52.803Z"
+  "version": "0.10.16",
+  "commit": "8594507507cc7488894cbaa90de3930c118bbd74",
+  "builtAt": "2026-06-03T06:31:42.639Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-cb1d57e5a97f17ed3449f82242b3ed117eebf7623673aa68bbdbdbc7b85208d7
+f7a15c502412644edbd46618c15a2859b3267e15f4ae1e98b9bbf7424c5c4014

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qqbrowser/openclaw-qbot",
-  "version": "0.10.15",
+  "version": "0.10.16",
   "description": "Multi-channel AI gateway with extensible messaging integrations",
   "keywords": [],
   "homepage": "https://github.com/openclaw/openclaw#readme",

package/skills/qqbrowser-playbook/SKILL.md

@@ -42,7 +42,7 @@ Convert raw `qqbrowser-skill` task recordings into reusable, parameterized repla
 | `browser_download_file` / `browser_download_url` | — |
 | `browser_eval_content_js` | `script` |
 | `browser_find_and_act` | `value`, `actionValue`, `name`, `nth` |
-| `loop` | `count`, nested `steps` |
+| `loop` | `count`, `variable`, `start`, `on_error`, nested `steps` |
 
 ### ❌ Excluded (filter out from recording)
 
@@ -102,7 +102,30 @@ Use `loop` when recording shows **2+ repetitions** of the same action sequence d
 }
 ```
 
-Fields: `count`(string/number, supports `{{param}}`), `variable`(loop var name), `start`(default 1, 1-based for `nth`).
+Fields: `count`(string/number, supports `{{param}}`), `variable`(loop var name), `start`(default 1, 1-based for `nth`), `on_error`(optional, see below).
+
+### `on_error` — Dynamic List Handling
+
+When the list length is **unknown or dynamic** (e.g., "claim all free games", "process all search results"), use `on_error: "break"`:
+
+```json
+{
+  "action": "loop",
+  "params": { "count": "100", "variable": "i", "start": 1, "on_error": "break" },
+  "description": "处理所有列表项（自动检测结束）",
+  "steps": [ ... ]
+}
+```
+
+| `on_error` | Behavior |
+|---|---|
+| `"fail"` (default) | Sub-step failure → entire replay fails |
+| `"break"` | Sub-step failure → **exit loop gracefully**, replay continues as success |
+
+**When to use `on_error: "break"`:**
+- List length is unknown at script generation time
+- Task is "process ALL items" (not a fixed count)
+- Set `count` to a large upper bound (e.g., 100), loop breaks when `find_and_act` can't find the Nth element
 
 ### Key Rules for Loop Steps
 
@@ -129,6 +152,7 @@ Fields: `count`(string/number, supports `{{param}}`), `variable`(loop var name),
 | Need detail page content | `loop` (navigate in/out per item) |
 | Pagination + extract | `loop` |
 | Fixed different form fields | Linear steps |
+| Process ALL items (unknown count) | `loop` with `on_error: "break"` + large `count` |
 
 **`go_back` vs `tab_close` + `tab_switch`:**
 

package/skills/qqbrowser-skill/SKILL.md

@@ -15,57 +15,117 @@ permissions:
 ```bash
 # Linux / macOS
 pipx install qqbrowser-skill && qqbrowser-skill install
-
 # Windows
 pip install qqbrowser-skill && qqbrowser-skill install
 ```
 
 ## Key Concepts
 
-- **Element Index**: Encoded string like `2_sfli_qp0u` (format: `highlightIndex_attrHash_xpathHash`). Generated by `browser_snapshot`, used to target elements for interaction. Features a 4-level degradation matching mechanism for cross-snapshot stability.
-- **Snapshot**: Returns page content with indexed elements. Re-snapshot is required after any DOM change (navigation, form submission, AJAX loading).
-- **Task Recording**: All browser tasks MUST be wrapped with `task_begin`/`task_end` to enable replay.
+- **Element Index**: Encoded string like `2_sfli_qp0u` (`highlightIndex_attrHash_xpathHash`). Generated by `browser_snapshot`, used to target elements.
+- **Snapshot**: Returns page content with indexed elements. Re-snapshot after any DOM change.
+- **Task Recording**: All manual browser tasks MUST be wrapped with `task_begin`/`task_end`.
+
+---
+
+## ⚠️ Task Execution Priority (MANDATORY)
+
+> **CRITICAL: You MUST run `playbook_list` BEFORE any `task_begin` or `browser_go_to_url`. NEVER start manual automation without first checking for existing playbooks.**
+
+```
+User task → playbook_list (MANDATORY) → Match? → YES → browser_replay
+                                                → NO  → Manual automation
+```
+
+### Step 0: Check Playbooks (DO NOT SKIP)
+
+```bash
+qqbrowser-skill playbook_list
+```
+
+1. Match returned playbooks against user's task by `name`, `description`, keywords, target URL
+2. If matched (even partially): `browser_replay --script <path> --variables '{...}'`
+3. Only if NO match: proceed to manual automation
+
+### Step 1: Composite Task — Multi-Playbook Orchestration
+
+For tasks spanning multiple domains (e.g., "从知乎获取文章然后发到小红书"):
+
+```
+Composite task → Decompose into sub-tasks → Match EACH against playbook_list
+→ Execute pipeline: playbook₁ → AI mediation → playbook₂ → ...
+```
+
+**Rules:**
+1. Break request into atomic browser operations, match each independently
+2. AI mediates BETWEEN playbooks (summarize, rewrite, transform format) — no browser commands needed
+3. Each playbook runs independently — never chain inside a single `task_begin`/`task_end`
+4. If a sub-task has no playbook, fall back to manual for that sub-task only
+5. Report progress after each stage
+
+**Example:**
+```bash
+# Sub-task A: playbook exists
+qqbrowser-skill browser_replay --script ~/.qqbrowser-skill/playbooks/zhihu-article-extractor.json \
+  --variables '{"topic": "人工智能", "count": "3"}'
+# AI mediation: transform extracted content to target platform style
+# Sub-task B: playbook exists
+qqbrowser-skill browser_replay --script ~/.qqbrowser-skill/playbooks/xiaohongshu-publish.json \
+  --variables '{"notes_title": "AI生成标题", "notes_content": "转换后内容"}'
+```
+
+### Step 2: Fallback to Manual Automation
+
+Only when: no matching playbook / replay failed after retry / task requires dynamic AI decisions.
+
+### Step 3: Save as Playbook (explicit user request only)
 
-## Core Workflow
+Trigger words: "save this", "make reusable", "保存为脚本", "下次还要用"
+→ Load `qqbrowser-playbook` skill → `task_latest` → generate → save
+
+---
+
+## Core Workflow (Manual Automation)
 
 ```bash
-qqbrowser-skill task_begin --description "描述任务"     # 1. Start recording (MANDATORY)
-qqbrowser-skill browser_go_to_url --url <url>           # 2. Navigate
-qqbrowser-skill browser_snapshot                        # 3. Get element indices
-# ... interact using indices ...                        # 4. Perform actions
-qqbrowser-skill browser_snapshot                        # 5. Re-snapshot after DOM changes
-qqbrowser-skill task_end                                # 6. End recording (MANDATORY)
+qqbrowser-skill task_begin --description "描述任务"
+qqbrowser-skill browser_go_to_url --url <url>
+qqbrowser-skill browser_snapshot                    # Get element indices
+# ... interact using indices ...
+qqbrowser-skill browser_snapshot                    # Re-snapshot after DOM changes
+qqbrowser-skill task_end
 ```
 
+---
+
 ## Command Reference
 
 ### Navigation
 ```bash
-browser_go_to_url --url <url>          # Navigate to URL
-browser_go_back                         # Go back
-browser_wait --seconds <n>              # Wait (default 3s)
+browser_go_to_url --url <url>
+browser_go_back
+browser_wait --seconds <n>              # Default 3s
 ```
 
 ### Snapshot & Screenshot
 ```bash
-browser_snapshot                        # Element indices mode (for interaction)
-browser_snapshot --markdown             # Clean Markdown mode (for reading, no indices)
-browser_screenshot [--full] [--annotate]  # Screenshot (returns .webp temp path)
+browser_snapshot                        # Element indices (for interaction)
+browser_snapshot --markdown             # Markdown (for reading)
+browser_screenshot [--full] [--annotate]
 ```
 
 ### Click & Input
 ```bash
-browser_click_element --index <id>                     # Click
-browser_dblclick_element --index <id>                  # Double-click
-browser_focus_element --index <id>                     # Focus
-browser_input_text --index <id> --text "<content>"     # Clear + input text
+browser_click_element --index <id>
+browser_dblclick_element --index <id>
+browser_focus_element --index <id>
+browser_input_text --index <id> --text "<content>"
 ```
 
 ### Scroll
 ```bash
-browser_scroll_down [--amount <px>]     # Scroll down (default one page)
-browser_scroll_up [--amount <px>]       # Scroll up
-browser_scroll_to_text --text "<text>"  # Scroll to text
+browser_scroll_down [--amount <px>]
+browser_scroll_up [--amount <px>]
+browser_scroll_to_text --text "<text>"
 browser_scroll_to_top / browser_scroll_to_bottom
 browser_scroll_by --direction <dir> --pixels <n> [--index <id>]
 browser_scroll_into_view --index <id>
@@ -73,9 +133,9 @@ browser_scroll_into_view --index <id>
 
 ### Keyboard
 ```bash
-browser_keypress --key <key>                           # Press key (Enter, Tab, etc.)
-browser_keyboard_op --action type --text "<content>"   # Type text
-browser_keyboard_op --action inserttext --text "<content>"  # Insert without key events
+browser_keypress --key <key>
+browser_keyboard_op --action type --text "<content>"
+browser_keyboard_op --action inserttext --text "<content>"
 browser_keydown --key <key> / browser_keyup --key <key>
 ```
 
@@ -89,8 +149,8 @@ browser_check_op --index <id> --value / --no-value
 ### Find and Act (Semantic Locators)
 ```bash
 browser_find_and_act --by <role|text|label|placeholder|testid|css> --value "<v>" --action <click|fill|type> [--actionValue "<v>"] [--name "<n>"] [--nth <n>]
-# --nth: select the Nth matching element (0-based). Essential for loop patterns in lists.
 ```
+> `--nth`: 0-based index for list iteration. Use `by: "css"` + `--nth` for loops.
 
 ### Get Information & State
 ```bash
@@ -98,50 +158,26 @@ browser_get_info --type <text|url|title|html|value|attr|count|box|styles|list_se
 browser_check_state --state <visible|enabled|checked> --index <id>
 ```
 
-> **💡 Key Usage**: `browser_get_info` returns **only the requested info** (no page state or interactive elements), making it lightweight and token-efficient.
->
-> **🔑 `list_selector` — Auto-detect CSS selector for list iteration (PREFERRED for loop tasks):**
-> ```bash
-> # From snapshot you see a list of articles:
-> #   [3_abc1_def2]<a 人工智能的未来/>
-> #   [4_xyz3_uvw4]<a 深度学习入门/>
-> #   [5_mno5_pqr6]<a 大模型时代/>
->
-> # Pick ANY one element from the list and run:
-> browser_get_info --type list_selector --index "3_abc1_def2"
-> # → {"success":true, "selector":".ContentItem h2 a", "count":10,
-> #    "samples":["人工智能的未来","深度学习入门","大模型时代","...","..."],
-> #    "strategy":"parent_level_1"}
->
-> # Now use this selector directly in find_and_act for loop iteration:
-> browser_find_and_act --by css --value ".ContentItem h2 a" --action click --nth 1
-> ```
-> **This is the RECOMMENDED way to find CSS selectors for list operations.** It replaces the manual workflow of `get_info --type html` → analyze → construct selector → probe verify. One command does it all.
->
-> If `list_selector` returns `success: false`, fall back to manual inspection:
-> ```bash
-> browser_get_info --type html --index "5_abc1_def2"
-> # → returns element HTML, use it to construct a selector manually
-> ```
+> **`list_selector`**: Auto-detect CSS selector for list iteration. Pass any list item's index → returns `{"selector": "...", "count": N, "samples": [...]}`. Use the returned selector in `find_and_act --by css --value <selector> --nth N`.
 
 ### JavaScript Evaluation
 ```bash
-browser_eval_content_js --script "<js_code>"           # Evaluate JS, return result
-browser_eval_content_js --script "<base64>" --base64   # Base64-encoded script
+browser_eval_content_js --script "<js_code>"
+browser_eval_content_js --script "<base64>" --base64
 ```
 
 ### Download
 ```bash
-browser_download_file --index <id>     # Download by clicking element
-browser_download_url                    # Download from URL
+browser_download_file --index <id>
+browser_download_url
 ```
 
 ### Tab Management
 ```bash
-browser_tab_open --url <url>           # Open new tab
-browser_tab_list                        # List tabs
-browser_tab_switch --tabId <n>         # Switch tab
-browser_tab_close --tabId <n>          # Close tab
+browser_tab_open --url <url>
+browser_tab_list
+browser_tab_switch --tabId <n>
+browser_tab_close --tabId <n>
 ```
 
 ### Dialog
@@ -149,267 +185,143 @@ browser_tab_close --tabId <n>          # Close tab
 browser_dialog --action <accept|dismiss> [--text "<input>"]
 ```
 
-### Replay
+### Replay & Playbook
 ```bash
-browser_replay --script <path>         # Replay from file
-browser_replay --script_content '<json>'  # Replay from JSON string
-browser_replay --script <path> --variables '{"key":"value"}'  # With params
+playbook_list                              # List available playbooks
+browser_replay --script <path> [--variables '{"key":"value"}']
+browser_replay --script_content '<json>'
+```
+> ⚠️ `browser_replay` can take **up to 10 minutes**. Wait patiently — do NOT interrupt.
+
+**`browser_replay` Output Format:**
+```json
+{
+  "success": true,
+  "total_steps": 5,
+  "completed_steps": 5,
+  "step_results": [
+    {"index": 0, "action": "browser_go_to_url", "description": "...", "success": true, "result": "Success! Navigated to ..."},
+    {"index": 1, "action": "browser_eval_content_js", "description": "提取数据", "success": true, "result": "{\"title\":\"...\",\"content\":\"...\"}"}
+  ],
+  "duration_ms": 12345,
+  "summary": "Replay completed successfully: 5/5 steps in 12345ms."
+}
 ```
 
-> **⚠️ LONG EXECUTION TIME**: `browser_replay` executes ALL steps in the playbook sequentially (navigation, waiting, data extraction, etc.). **This can take up to 10 minutes** depending on the number of steps, network conditions, and configured delays/timeouts.
->
-> **You MUST wait patiently** for the command to complete — do NOT assume it has hung or timed out. Do NOT interrupt or retry unless you receive an explicit error message.
-> Typical durations: simple playbooks (5-10 steps) ~30s–1min, complex playbooks with loops (20+ steps) ~3–10min.
+**How to use the output (especially for composite tasks):**
+- `success`: Check overall success/failure. If `false`, check `failed_step` for error details.
+- `step_results[N].result`: Contains the return value of each step. **For `browser_eval_content_js` steps, this is the extracted data (usually JSON string)** — parse it for use in subsequent AI processing or next playbook's variables.
+- For composite pipelines: find all `eval_content_js` steps in `step_results`, parse their `result` field to get structured data for AI mediation.
 
 ### Task Recording
 ```bash
-task_begin --description "<description>"   # Start recording (MUST be first)
-task_end                                    # Stop recording → then auto-generate playbook (see below)
-task_latest                                 # Get most recent recording (for playbook generation)
+task_begin --description "<desc>"
+task_end
+task_latest                                # Get most recent recording
 ```
-
-> **IMPORTANT**: After `task_end`, do NOT just show the raw recording path. The raw recording (`~/.qqbrowser-skill/records/task_*.json`) is NOT a ready-to-use replay script. You MUST proceed to generate a proper playbook — see "Generating Replay Scripts / Playbooks" section.
+> After `task_end`, raw recordings are NOT replay-ready. Must generate proper playbook.
 
 ### Utility
 ```bash
-browser_done --success --text "<msg>"  # Mark task complete
-status                                  # Check skill status
-list                                    # List available skills
+browser_done --success --text "<msg>"
+status
+list
 ```
 
 ---
 
-## ⚠️ MANDATORY: Replay-Friendly Execution Rules
-
-**All operations MUST prioritize replayability. Follow these rules to ensure recorded steps can be replayed with parameterized variables.**
+## Replay-Friendly Execution Rules
 
 ### Rule 1: Task Classification
 
-Before executing, classify the task:
-
 | Category | Replayable? | Strategy |
 |----------|-------------|----------|
-| **A: Fixed-path** (navigate, click, fill forms) | ✅ | Standard commands, all recorded |
-| **B: Data extraction** | ⚠️ Partial | Use `browser_eval_content_js` (replayable), NOT `snapshot --markdown` + AI summarization |
-| **C: Content understanding** (summarize, compare) | ❌ | Separate from replayable steps, mark with `"requires_ai": true` |
-| **D: Dynamic iteration** (pagination, load more) | ⚠️ | Use fixed number of operations based on predictable calculation |
+| **A: Fixed-path** (navigate, click, fill) | ✅ | Standard commands |
+| **B: Data extraction** | ⚠️ | Use `browser_eval_content_js`, NOT `snapshot --markdown` |
+| **C: Content understanding** | ❌ | Mark `"requires_ai": true` |
+| **D: Dynamic iteration** | ⚠️ | Fixed operation count |
 
 ### Rule 2: Data Extraction — Always Prefer JS
 
 ```bash
-# ✅ Replayable: JS extraction
-browser_eval_content_js --script "JSON.stringify(Array.from(document.querySelectorAll('.item')).slice(0,10).map(el=>({title:el.querySelector('.title')?.textContent?.trim()})))" --base64
-
-# ❌ Non-replayable: AI reading
+# ✅ Replayable
+browser_eval_content_js --script "JSON.stringify(Array.from(document.querySelectorAll('.item')).slice(0,10).map(el=>({title:el.querySelector('.title')?.textContent?.trim()})))"
+# ❌ Non-replayable
 browser_snapshot --markdown  # then AI summarizes
 ```
 
-**Exception**: Tasks explicitly requiring AI understanding (e.g., "总结文章要点") — note in `task_begin` description: "需要AI在线参与，不可纯回放".
+### Rule 3: Analyze First, Execute Once
 
-### Rule 3: Analyze First, Execute Once (No Trial-and-Error Recording)
+Do NOT trial-and-error during recorded tasks. Use `browser_snapshot` to analyze, then write ONE definitive script. If it fails, `task_end` → discard → re-record.
 
-**CRITICAL**: Do NOT use trial-and-error during a recorded task. Every command between `task_begin` and `task_end` is recorded — failed attempts pollute the recording and make it unreplayable.
-
-**Correct workflow for data extraction:**
-```bash
-task_begin --description "..."
-browser_go_to_url --url "..."
-browser_wait --seconds 3
-browser_snapshot                    # ← AI analyzes page structure here (not recorded in replay)
-# AI identifies the correct, stable selector BEFORE writing the JS script
-browser_eval_content_js --script "/* one correct script */"   # ← Only this gets replayed
-task_end
-```
-
-**PROHIBITED patterns:**
-- ❌ Running multiple `browser_eval_content_js` with different selectors hoping one works
-- ❌ Using `browser_get_info` to "check" results mid-recording then adjusting
-- ❌ Hardcoding element index strings (e.g., `[id='25_tg4y_yb9z']`) inside JS scripts — index is for command params only, not JS selectors
-- ❌ Using regex to match page text content as a selector strategy (fragile, locale-dependent)
-
-**Rule**: Use `browser_snapshot` to understand the DOM, then write **one definitive** JS extraction script. If the first script fails, call `task_end` to discard, fix the script, then re-record with `task_begin`.
+**PROHIBITED:**
+- ❌ Multiple `eval_content_js` with different selectors
+- ❌ Hardcoding element index in JS scripts
+- ❌ Using regex on page text as selector strategy
 
 ### Rule 4: JS Selector Priority
 
-| Priority | Type | Example |
-|----------|------|---------|
-| 1 | `id` | `#rank-list` |
-| 2 | `data-*` | `[data-testid="item"]` |
-| 3 | ARIA | `[role="listitem"]` |
-| 4 | Semantic class | `.article-title` |
-| 5 | Structural path | `main > ul > li` |
-| ❌ | Dynamic/hash class | `.css-1a2b3c` — NEVER use |
+`id` > `data-*` > ARIA > semantic class > structural path. ❌ NEVER use dynamic/hash classes (`.css-1a2b3c`).
 
-### Rule 5: Repeating Patterns & Pagination
+### Rule 5: Loop Recording
 
-**Identify repeating patterns during recording**. If you find yourself doing the same sequence of actions N times (e.g., click item → read → go back), this is a **loop pattern**. Record it correctly:
+Record **at least 2 iterations** using `browser_find_and_act --by css --nth`:
 
-**Recording strategy for loop tasks:**
 ```bash
-task_begin --description "搜索{{topic}}并提取前{{count}}篇文章内容"
-browser_go_to_url --url "https://example.com/search?q=AI"
-browser_wait --seconds 3
-browser_snapshot                           # AI analyzes list structure
-
-# ★ STEP 0: DISCOVER LIST SELECTOR (MANDATORY before any list iteration)
-# Use list_selector to auto-detect the CSS selector from any list item's snapshot index:
+# ★ MANDATORY: Discover selector first
 browser_get_info --type list_selector --index "3_abc1_def2"
-# → {"success":true, "selector":".result-item h2 a", "count":10, "samples":[...]}
-# Then record the probe with the discovered selector for playbook generation:
+# Record probe for playbook generator:
 browser_eval_content_js --script "JSON.stringify({__list_probe__: true, selector: '.result-item h2 a', count: document.querySelectorAll('.result-item h2 a').length, samples: Array.from(document.querySelectorAll('.result-item h2 a')).slice(0,3).map(e=>e.textContent.trim())})"
-# The __list_probe__ marker helps the playbook generator locate this data.
-
-# Record ONE complete iteration as the pattern:
+# Iteration 1:
 browser_find_and_act --by css --value ".result-item h2 a" --action click --nth 1
-browser_wait --seconds 2
-browser_eval_content_js --script "JSON.stringify({title: document.querySelector('h1')?.textContent, content: document.querySelector('.content')?.textContent?.substring(0,2000)})"
-browser_go_back
-browser_wait --seconds 1
-
-# Record second iteration to confirm the pattern:
+# ... extract, go back ...
+# Iteration 2:
 browser_find_and_act --by css --value ".result-item h2 a" --action click --nth 2
-browser_wait --seconds 2
-browser_eval_content_js --script "JSON.stringify({title: document.querySelector('h1')?.textContent, content: document.querySelector('.content')?.textContent?.substring(0,2000)})"
-browser_go_back
-
-task_end
+# ... extract, go back ...
 ```
 
-**Key points:**
-- **★ MUST discover and probe list selector** before iterating — first use `browser_get_info --type list_selector --index <id>` to auto-detect the CSS selector, then use `browser_eval_content_js` with `__list_probe__: true` to record it. **NEVER guess CSS selectors.**
-- Record **at least 2 iterations** so the playbook generator can identify the loop pattern
-- Use `browser_find_and_act` with `--nth` (not `browser_click_element` with hardcoded index) for list items — this enables loop parameterization
-- The playbook generator will automatically convert repetitions into a `loop` structure with `{{count}}` controlling iterations
+**Key:** Use `list_selector` to discover CSS selector (NEVER guess). Use `find_and_act --nth` (not `click_element` with hardcoded index).
 
-**How to find the CSS selector (MANDATORY — use `list_selector`):**
-```
-★ PREFERRED (one command, auto-detect):
-1. browser_snapshot              → AI sees list elements: [3_abc1_def2]<a 人工智能的未来/> ...
-2. browser_get_info --type list_selector --index "3_abc1_def2"
-                                 → returns: {"success":true, "selector":".ContentItem h2 a", "count":10, "samples":[...]}
-3. Use the returned selector     → proceed with __list_probe__ and find_and_act
-
-FALLBACK (if list_selector returns success=false):
-1. browser_get_info --type html --index "3_abc1_def2"
-                                 → returns: <a class="ContentItem-title" href="/p/123456">人工智能的未来</a>
-2. AI reads the HTML             → identifies class, parent structure, etc.
-3. AI constructs CSS selector    → ".ContentItem-title" or "a[data-za-detail-view-element_name='Title']"
-4. browser_eval_content_js       → run __list_probe__ to verify the selector
-```
-**NEVER guess CSS selectors.** Always use `list_selector` first, then fall back to `html` inspection if needed.
-
-**For simple pagination** (next page button):
-```bash
-browser_eval_content_js --script "/* extract page 1 */"
-browser_find_and_act --by text --value "下一页" --action click
-browser_wait --seconds 2
-browser_eval_content_js --script "/* extract page 2 */"
-```
+### Rule 6: Multi-Tab Recording
 
-**DO NOT** use AI judgment loops ("check if enough, scroll more").
-
-### Rule 6: Multi-Tab Recording Strategy
-
-When a task involves links that open in new tabs (e.g., `target="_blank"`), record using **explicit tab management commands** instead of relying on `browser_go_back`:
-
-```bash
-task_begin --description "搜索并提取文章(新Tab场景)"
-browser_go_to_url --url "https://example.com/search?q=AI"
-browser_wait --seconds 3
-browser_snapshot                           # AI analyzes list structure
-
-# ★ DISCOVER + PROBE LIST SELECTOR (same as Rule 5 — MANDATORY before list iteration):
-browser_get_info --type list_selector --index "3_abc1_def2"   # auto-detect selector
-browser_eval_content_js --script "JSON.stringify({__list_probe__: true, selector: '.result-item h2 a', count: document.querySelectorAll('.result-item h2 a').length, samples: Array.from(document.querySelectorAll('.result-item h2 a')).slice(0,3).map(e=>e.textContent.trim())})"
-
-# Click link that opens in new tab:
-browser_find_and_act --by css --value ".result-item h2 a" --action click --nth 1
-browser_tab_list                           # AI checks: new tab appeared?
-browser_tab_switch --tabId <new_tab_id>    # Switch to the new tab
-browser_wait --seconds 2
-browser_eval_content_js --script "..."     # Extract content in detail page
-browser_tab_close --tabId <current_tab_id> # Close detail tab
-browser_tab_switch --tabId <origin_tab_id> # Switch back to list page
-browser_wait --seconds 1
-
-# Repeat for second item...
-browser_find_and_act --by css --value ".result-item h2 a" --action click --nth 2
-# ... same pattern ...
-
-task_end
-```
-
-**Key points:**
-- Use `browser_tab_list` to observe tab changes (this is AI-only, filtered from playbook)
-- Record physical `tabId` during recording — the **playbook generator** will convert them to semantic references (`"origin"`, `"latest"`, `"current"`)
-- **DO NOT use `browser_go_back`** when the previous action opened a new tab — `go_back` navigates within the current tab's history, it cannot close tabs or switch between them
-- Record **at least 2 iterations** of the tab pattern (same as loop recording) so the playbook generator can detect and convert to `loop` + tab management
-
-**How to detect new tab during recording:**
-1. After clicking a link, call `browser_tab_list`
-2. If a new tab appeared (tab count increased), use `browser_tab_switch` to go to it
-3. If no new tab (same count), the link navigated in-place → use normal flow with `browser_go_back`
+When links open new tabs:
+1. After click, `browser_tab_list` to detect new tab
+2. `browser_tab_switch` → extract → `browser_tab_close` → `browser_tab_switch` back
+3. Do NOT use `browser_go_back` for cross-tab navigation
+4. Record 2+ iterations for loop detection
 
 ### Rule 7: Fixed vs Variable Parameters
 
-| Command | Fixed | Variable (→ `{{param}}`) |
-|---------|-------|--------------------------|
-| `browser_go_to_url` | Base URL | Query params, path segments |
-| `browser_click_element` | `--index` | — (never parameterize) |
-| `browser_input_text` | `--index` | `--text` |
-| `browser_select_dropdown_option` | `--index` | `--text` |
-| `browser_keyboard_op` | `--action` | `--text` |
-| `browser_eval_content_js` | Script structure | Count, selector, keyword in script |
-| `browser_find_and_act` | `--by`, `--action` | `--value`, `--actionValue`, `--name` |
-| `browser_dialog` | `--action` | `--text` |
-| `browser_wait` / `browser_scroll_*` | All params | — |
-
-### Rule 8: Non-Replayable Commands (AI-Decision Only)
+| Fixed (never parameterize) | Variable (→ `{{param}}`) |
+|---|---|
+| `index`, `action`, base URLs, `settings` | `text`, query params, `actionValue`, count in scripts |
 
-These commands help AI decide but produce **no replayable action** — they are skipped during replay:
+### Rule 8: Non-Replayable Commands (filtered during replay)
 
-`browser_snapshot`, `browser_snapshot --markdown`, `browser_screenshot`, `browser_get_info`, `browser_check_state`, `browser_get_dropdown_options`, `browser_tab_list`
-
-**Principle**: AI uses these to decide; the resulting **actions** (click, input, select) are what gets recorded and replayed.
+`browser_snapshot`, `browser_screenshot`, `browser_get_info`, `browser_check_state`, `browser_get_dropdown_options`, `browser_tab_list`
 
 ### Rule 9: Prefer `browser_find_and_act` for Dynamic Content
 
-For elements in dynamic lists (search results, feeds) where index stability is uncertain:
-
 ```bash
-# ✅ Preferred: semantic locator (stable across page changes)
-browser_find_and_act --by text --value "{{target_text}}" --action click
-
-# ⚠️ Acceptable: index-based (for stable page structures only)
+# ✅ Stable across page changes
+browser_find_and_act --by text --value "{{target}}" --action click
+# ⚠️ Only for stable structures
 browser_click_element --index 15_abc1_def2
 ```
 
 ---
 
-## Generating Replay Scripts / Playbooks
+## Generating Playbooks
 
-### Auto-Generate Trigger
+After `task_end`, if task is replayable:
 
-After every `task_end`, if the task description indicates it should be replayable (e.g., contains "可回放", "replay", or is a standard operational task without AI summarization), the AI **MUST automatically**:
-
-1. Load the `qqbrowser-playbook` skill
-2. Run `task_latest` to get the raw recording
-3. Generate a clean playbook (filtering out AI-only commands, parameterizing user data)
+1. Load `qqbrowser-playbook` skill
+2. `task_latest` → get raw recording
+3. Generate clean playbook (filter AI-only commands, parameterize user data)
 4. Save to `~/.qqbrowser-skill/playbooks/<name>.json`
 
-**DO NOT** simply tell the user to run `browser_replay --script <raw_recording_path>`. Raw recordings contain trial-and-error steps and AI-only commands — they are NOT replay-ready.
-
-### Explicit Trigger
-
-When the user explicitly asks to "save as replay script" / "generate playbook" / "保存成回放脚本" / "生成回放脚本":
-
-Same workflow as above.
-
-### Rules
-
-1. **MUST** load the `qqbrowser-playbook` skill for format specification
-2. **MUST** use `task_latest` to get recorded steps — do NOT fabricate
-3. **MUST** filter out all AI-only commands (`browser_snapshot`, `browser_screenshot`, `browser_get_info`, `browser_check_state`, etc.)
-4. **MUST** save to `~/.qqbrowser-skill/playbooks/<name>.json` (macOS/Linux) or `%LOCALAPPDATA%/qqbrowser-skill/playbooks/<name>.json` (Windows)
-5. **MUST** use the exact JSON format from the `qqbrowser-playbook` skill specification
-6. **MUST NOT** output the raw recording path as the "replay script" — it is source material, not a ready playbook
+**Rules:**
+- MUST base on `task_latest` — never fabricate steps
+- MUST filter excluded commands
+- MUST use `qqbrowser-playbook` skill JSON format
+- Raw recordings are NOT replay-ready — always generate proper playbook