@wwkit/harness 1.0.4

package/skills/extract/references/clean-html.js

@@ -0,0 +1,91 @@
+import { fileURLToPath } from 'url';
+import * as cheerio from 'cheerio';
+
+const STRIP_TAGS = new Set([
+  'script', 'style', 'noscript', 'iframe', 'svg', 'canvas', 'template',
+  'form', 'video', 'audio', 'object', 'embed', 'nav', 'footer', 'aside',
+]);
+
+const WRAPPER_TAGS = new Set([
+  'strong', 'b', 'i', 'em', 'span', 'u', 's', 'strike', 'mark',
+  'small', 'sub', 'sup', 'code', 'kbd', 'q', 'abbr', 'cite',
+]);
+
+const KEEP_ATTRS = new Set(['href', 'src', 'alt']);
+
+export function cleanHtml(html) {
+  if (!html) return '';
+  let $ = cheerio.load(html);
+
+  // 1. Strip blocks
+  STRIP_TAGS.forEach(tag => { $(tag).remove(); });
+
+  // 2. Strip comments
+  $.root().find('*').contents().filter((i, el) => el.type === 'comment').remove();
+
+  // 3. Extract body
+  const body = $('body').html();
+  if (body) {
+    $ = cheerio.load(body);
+  }
+
+  // 4. Strip attributes (keep only href/src/alt)
+  $('*').each((i, el) => {
+    const attrs = el.attribs;
+    Object.keys(attrs).forEach(attr => {
+      if (!KEEP_ATTRS.has(attr)) delete attrs[attr];
+    });
+  });
+
+  // 5. Strip wrapper tags (unwrap content)
+  WRAPPER_TAGS.forEach(tag => {
+    $(tag).each((i, el) => {
+      const $el = $(el);
+      $el.replaceWith($el.contents());
+    });
+  });
+
+  // 6. Strip void elements (img, br, hr, etc.) and empty paired elements
+  const VOID_TAGS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+  ]);
+  VOID_TAGS.forEach(tag => { $(tag).remove(); });
+
+  // Remove empty elements repeatedly
+  let prev = '';
+  let curr = $.html();
+  while (curr !== prev) {
+    prev = curr;
+    $ = cheerio.load(curr);
+    $('*').each((i, el) => {
+      const $el = $(el);
+      if ($el.text().trim() === '' && !$el.children().length) {
+        $el.remove();
+      }
+    });
+    curr = $.html();
+  }
+
+  // 7. Strip base64 images
+  $ = cheerio.load(curr);
+  $('img[src^="data:image/"]').remove();
+
+  // 8. Minify
+  let result = $.html();
+  result = result.replace(/\s+/g, ' ');
+  result = result.replace(/>\s+</g, '><');
+  return result.trim();
+}
+
+function main() {
+  const chunks = [];
+  process.stdin.on('data', chunk => chunks.push(chunk));
+  process.stdin.on('end', () => {
+    const html = Buffer.concat(chunks).toString();
+    process.stdout.write(cleanHtml(html));
+  });
+}
+
+export default cleanHtml;
+if (process.argv[1] === fileURLToPath(import.meta.url)) main();

package/skills/extract/references/detail.md

@@ -0,0 +1,60 @@
+# detail 提取流程
+
+从文章详情页的正文容器 HTML 中提取结构化信息（本地提取 + LLM 规范）。
+
+## 输入
+
+- `source`：正文容器 HTML（已去除非正文内容）
+- `url`：页面 URL（可选，相对路径转绝对）
+
+## 输出
+
+符合 `detail.schema.json5` 的 JSON 数组（仅含 1 项）：
+
+```json
+[
+  {
+    "title": "文章标题",
+    "author": "作者名",
+    "date": "2026-06-20",
+    "url": "https://example.com/article/123",
+    "blocks": [
+      {"type": "text", "value": "第一段文本"},
+      {"type": "image", "value": "https://example.com/pic1.jpg"},
+      {"type": "text", "value": "第二段文本"}
+    ]
+  }
+]
+```
+
+字段：`title`（可选，空则基于全文生成 ≤30 字短标题）、`author` / `date`（可选）、`url`（可选，直接用输入 `{{ url }}`）、`blocks`（必填，`type`/`value` 交替数组）。
+
+## 步骤
+
+### Step 1 — 本地提取（按 img 切分）
+
+用 `write` 工具将正文容器 HTML 写入临时文件，再用 stdin 重定向交给 Node.js 按 `<img>` 标签切分：
+
+```bash
+node '<技能目录>/references/extract-detail.js' < <临时 HTML 文件>
+```
+
+输出 JSON 包含 `blocks`：按 DOM 序交替排列的 `{"type":"text"/"image", "value":...}`。
+
+### Step 2 — LLM 数据规范
+
+将 Step 1 输出的 `{blocks}` + `{{ url }}` 交给 LLM 进行规范：
+
+1. **提取元数据**：从 `blocks[0]["value"]`（文章首段）中识别并提取 `title`、`author`、`date`
+   - 标题通常是首段开头最显著的完整短句
+   - 作者通常在标题后或段尾，常见格式：「作者：xxx」「文/xxx」「xxx/文」
+   - 日期通常在段首或段尾，格式多样，统一输出 `yyyy-mm-dd`
+2. **无标题时生成**：如果首段无法提取 title，基于全部 `blocks` 中 `type=text` 的内容生成一个不超过 30 字的短标题
+3. **清理 blocks**：从 `blocks` 数组中移除已提取的元数据行、广告引导语、文末推荐、版权声明等无效段（仅移除 `type=text` 的无效段，保留图片段）
+4. 相对路径 URL 基于 `{{ url }}` 转为绝对地址
+
+输出：规范后的 JSON 数组（`blocks` 已清理）。
+
+### Step 3 — 验证
+
+检查 `blocks` 非空，输出规范后的 JSON 数组（供 extract 技能阶段 4 校验）。

package/skills/extract/references/detail.schema.json5

@@ -0,0 +1,49 @@
+{
+  // 省略 $schema 字段，避免 bash -c "" 中 $ 展开问题
+  "title": "详情提取格式",
+  "description": "详情页提取（detail）输出校验 schema（数组，仅 1 项）",
+  "type": "array",
+  "items": {
+    "type": "object",
+    "properties": {
+      "title": {
+        "type": "string",
+        "description": "文章标题，可选；空则生成短标题"
+      },
+      "author": {
+        "type": "string",
+        "description": "作者，可选"
+      },
+      "date": {
+        "type": "string",
+        "description": "日期，统一 yyyy-mm-dd，可选"
+      },
+      "url": {
+        "type": "string",
+        "description": "文章链接，可选"
+      },
+      "blocks": {
+        "type": "array",
+        "description": "正文段落，type/value 交替数组",
+        "items": {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "enum": ["text", "image"],
+              "description": "段落类型：text 文本 / image 图片"
+            },
+            "value": {
+              "type": "string",
+              "description": "文本内容或图片地址"
+            }
+          },
+          "required": ["type", "value"],
+          "additionalProperties": false
+        }
+      }
+    },
+    "required": ["blocks"],
+    "additionalProperties": false
+  }
+}

package/skills/extract/references/extract-detail.js

@@ -0,0 +1,72 @@
+import { fileURLToPath } from 'url';
+import * as cheerio from 'cheerio';
+
+const IMG_RE = /<img\s[^>]*src=["'](.*?)["'][^>]*>/gi;
+
+export function extractDetail(html, maxLength = -1, maxImageCount = -1) {
+  if (!html || !html.trim()) return { paras: [] };
+
+  const parts = html.split(IMG_RE);
+  const rawParas = [];
+
+  for (let i = 0; i < parts.length; i++) {
+    if (i % 2 === 0) {
+      const text = cleanText(parts[i]);
+      if (text) rawParas.push({ type: 'text', value: text });
+    } else {
+      const imgUrl = (parts[i] || '').trim();
+      if (imgUrl) rawParas.push({ type: 'image', value: imgUrl });
+    }
+  }
+
+  return { paras: applyLimits(rawParas, maxLength, maxImageCount) };
+}
+
+function cleanText(raw) {
+  const $ = cheerio.load(raw);
+  let text = $.text();
+  text = text.replace(/\s+/g, ' ').trim();
+  return text;
+}
+
+function applyLimits(paras, maxLength, maxImageCount) {
+  if (maxLength === -1 && maxImageCount === -1) return paras;
+  const result = [];
+  let accLen = 0;
+  let imgCount = 0;
+
+  for (const entry of paras) {
+    if (entry.type === 'image') {
+      if (maxImageCount !== -1 && imgCount >= maxImageCount) break;
+      if (maxLength !== -1 && accLen >= maxLength) break;
+      imgCount++;
+      result.push(entry);
+    } else {
+      let text = entry.value;
+      if (maxLength !== -1) {
+        if (accLen >= maxLength) break;
+        const remaining = maxLength - accLen;
+        if (text.length > remaining) {
+          text = text.slice(0, remaining);
+          result.push({ type: 'text', value: text });
+          break;
+        }
+      }
+      result.push({ type: 'text', value: text });
+      accLen += text.length;
+    }
+  }
+  return result;
+}
+
+function main() {
+  const chunks = [];
+  process.stdin.on('data', chunk => chunks.push(chunk));
+  process.stdin.on('end', () => {
+    const html = Buffer.concat(chunks).toString();
+    process.stdout.write(JSON.stringify(extractDetail(html), null, 2));
+  });
+}
+
+export default extractDetail;
+if (process.argv[1] === fileURLToPath(import.meta.url)) main();

package/skills/extract/references/extract-regex.js

@@ -0,0 +1,82 @@
+import { fileURLToPath } from 'url';
+
+export function extractRegex(html, rules) {
+  if (!html || !rules) return [];
+
+  const { container_regex, fields } = rules;
+  if (!container_regex || !fields) return [];
+
+  const containerPattern = new RegExp(container_regex, 'gs');
+  const items = [];
+  let match;
+
+  while ((match = containerPattern.exec(html)) !== null) {
+    const block = match[1] !== undefined ? match[1] : match[0];
+    const item = {};
+
+    for (const [fieldName, fieldPattern] of Object.entries(fields)) {
+      if (fieldPattern) {
+        const fm = new RegExp(fieldPattern, 's').exec(block);
+        if (fm) {
+          item[fieldName] = (fm[1] !== undefined ? fm[1] : fm[0]).trim();
+        } else {
+          item[fieldName] = '';
+        }
+      } else {
+        item[fieldName] = '';
+      }
+    }
+
+    item.selector = makeSelector(item.title || '');
+    items.push(item);
+  }
+
+  return items;
+}
+
+const CURLY_CHARS = '\u201c\u201d\u2018\u2019';
+const EXCLUDE = ' and not(ancestor::script)';
+
+function makeSelector(title) {
+  if (!title) return '';
+  const hasCurly = [...CURLY_CHARS].some(c => title.includes(c));
+
+  if (!hasCurly) {
+    if (!title.includes("'")) return `//text()[contains(.,'${title}')${EXCLUDE}]/..`;
+    if (!title.includes('"')) return `//text()[contains(.,"${title}")${EXCLUDE}]/..`;
+    const parts = title.split("'");
+    const inner = parts.map(p => `'${p}'`).join(",\"'\",");
+    return `//text()[contains(.,concat(${inner}))${EXCLUDE}]/..`;
+  }
+
+  const allQuotes = CURLY_CHARS + '"\'';
+  const segs = title.split(new RegExp(`[${allQuotes}]+`)).filter(Boolean);
+  if (!segs.length) return '';
+
+  const clauses = segs.map(s => {
+    if (!s.includes("'")) return `contains(.,'${s}')`;
+    if (!s.includes('"')) return `contains(.,"${s}")`;
+    const sub = s.split("'");
+    const inner = sub.map(p => `'${p}'`).join(",\"'\",");
+    return `contains(.,concat(${inner}))`;
+  });
+
+  return `//text()[${clauses.join(' and ')}${EXCLUDE}]/..`;
+}
+
+function main() {
+  const chunks = [];
+  process.stdin.on('data', chunk => chunks.push(chunk));
+  process.stdin.on('end', () => {
+    try {
+      const input = JSON.parse(Buffer.concat(chunks).toString());
+      const result = extractRegex(input.html, input.rules);
+      process.stdout.write(JSON.stringify(result, null, 2));
+    } catch (e) {
+      process.stdout.write('[]');
+    }
+  });
+}
+
+export { makeSelector };
+if (process.argv[1] === fileURLToPath(import.meta.url)) main();

package/skills/extract/references/extract-sample.js

@@ -0,0 +1,49 @@
+import { fileURLToPath } from 'url';
+import * as cheerio from 'cheerio';
+import { cleanHtml } from './clean-html.js';
+
+export function extractSample(html, keepItems = 3) {
+  const cleaned = cleanHtml(html);
+  const $ = cheerio.load(cleaned);
+
+  // Find content items: look for list items or repeated block elements
+  const items = [];
+
+  // Try <li> first
+  $('li').each((i, el) => {
+    if (items.length < keepItems) items.push($(el).html() || '');
+  });
+
+  if (items.length > 0) {
+    return `<ul>${items.map(item => `<li>${item}</li>`).join('')}</ul>`;
+  }
+
+  // Fallback: look for repeated block elements
+  const blockTags = ['p', 'div', 'section', 'article', 'tr', 'td'];
+  for (const tag of blockTags) {
+    items.length = 0;
+    $(tag).each((i, el) => {
+      if (items.length < keepItems) items.push($.html(el));
+    });
+    if (items.length > 0) break;
+  }
+
+  return items.join('\n');
+}
+
+function main() {
+  const chunks = [];
+  process.stdin.on('data', chunk => chunks.push(chunk));
+  process.stdin.on('end', () => {
+    try {
+      const input = JSON.parse(Buffer.concat(chunks).toString());
+      const result = extractSample(input.html, input.keep_items || 3);
+      process.stdout.write(result);
+    } catch (e) {
+      process.stdout.write('');
+    }
+  });
+}
+
+export default extractSample;
+if (process.argv[1] === fileURLToPath(import.meta.url)) main();

package/skills/extract/references/format-aliases.json5

@@ -0,0 +1,22 @@
+{
+  // format 别名映射表：供 agent 将用户的自然语言描述翻译为 format 标准值。
+  // 用户可能用中文/口语而非英文标识，按以下 terms 命中匹配。
+  "aliases": {
+    "list": {
+      "description": "列表提取：从列表页提取多条目（HTML 或结构化 JSON 两种来源）",
+      "terms": ["列表", "多条", "集合", "条目", "list"]
+    },
+    "detail": {
+      "description": "详情提取：单条详情/正文内容",
+      "terms": ["详情", "正文", "单条", "内容页", "detail"]
+    },
+    "text": {
+      "description": "纯文本提取：HTML 转纯文本",
+      "terms": ["纯文本", "文字", "文本", "转文本", "text"]
+    },
+    "navi": {
+      "description": "导航提取：生成栏目/链接导航的 XPath",
+      "terms": ["导航", "栏目", "链接导航", "navi"]
+    }
+  }
+}

package/skills/extract/references/input.schema.json5

@@ -0,0 +1,23 @@
+{
+  // extract 技能入参字段清单（纯文档用途，供 agent 解析入参时参照，不做运行时校验）。
+  "title": "extract 技能入参字段清单",
+  "type": "object",
+  "properties": {
+    "source": {
+      "type": "string",
+      "description": "网页 HTML/文本内容，或本地文件路径",
+      "required": true
+    },
+    "format": {
+      "type": "string",
+      "description": "提取类型。标准值为 list/detail/text/navi 之一",
+      "enum": ["list", "detail", "text", "navi"],
+      "required": true
+    },
+    "url": {
+      "type": "string",
+      "description": "页面 URL；source 为相对路径时基于它转为绝对路径",
+      "required": false
+    }
+  }
+}

package/skills/extract/references/list-rule-gen.md

@@ -0,0 +1,109 @@
+# 规则生成指导
+
+## 你的角色
+
+你是一个 HTML 结构分析专家。给你一段（仅前几项的）HTML 样本，你需要分析其重复结构并生成正则提取规则。
+
+## 输入数据
+
+- **source**：干净的 HTML 片段（移除了 script/style/注释，仅含前若干条记录）。≥ 2 条时通过对比识别容器边界最准确；仅 1 条时需基于标签结构的层级关系推断容器模式
+- **fields**：需要提取的字段及其语义说明，例如 `{"title": "新闻标题", "author": "作者名"}`。LLM 据此在 HTML 中定位对应内容并编写正则
+- **path**（可选，框架级参数，LLM 无需处理）：指定时将规则写入该文件，否则直接输出
+
+## 输出格式
+
+必须是严格 JSON，不含任何其他内容。`fields` 的 key 与输入 `fields` 的 key 完全一致：
+
+```json
+{
+  "container_regex": "用于匹配每条容器的正则表达式，必须包含至少一个捕获组(group 1)",
+  "fields": {
+    "<field_name_1>": "对应输入字段的正则提取规则",
+    "<field_name_2>": "..."
+  }
+}
+```
+
+## 正则编写规则
+
+### 容器正则（container_regex）
+
+- 必须匹配列表中**每一条完整记录**的 HTML 块
+- 必须包含**一个捕获组 `(.*?)`**，代表单条记录的内部内容
+- 使用 `.*?`（非贪婪）避免跨记录匹配
+- 示例：
+  - `<li class="item">(.*?)</li>`
+  - `<div class="card"[^>]*>(.*?)</div>\s*`
+  - `<tr[^>]*>(.*?)</tr>`
+
+### 字段正则（fields）
+
+- 基于容器捕获组的内部内容编写
+- 使用具体标签名和 CSS 类名定位
+- 优先用 `<h1~6>`、`<a>` 提取标题
+- 用 `<time[datetime]>`、`<span[class~=date]>` 提取日期
+- 用 `<a[href]>` 提取链接
+- 用 `<img[src]>` 提取图片
+- 字段不存在时值留空字符串 `""`
+- **捕获组规则**：字段正则若有捕获组，提取值取 `group(1)`；建议每个字段正则只含 **1 个捕获组**。
+  > 反例：`<a href="(.*?)"[^>]*>(.*?)</a>` 含 2 个捕获组（href、文本），代码会静默取 `group(1)`（href）而非标题文本，与预期不符。应写为 `<a[^>]*>(.*?)</a>` 只捕获标签文本。
+
+### 常见模式（参考示例，非固定字段集）
+
+> **重要**：以下仅为正则写法范式。实际 class 名、标签层级必须**基于输入样本的真实结构**编写，禁止照搬表中的 class 名。
+
+| 字段语义 | 典型正则 |
+|---------|---------|
+| 标题类 | `<h3[^>]*class="title"[^>]*>(.*?)</h3>` |
+| 作者类 | `<span[^>]*class="author"[^>]*>(.*?)</span>` |
+| 日期类 | `<time[^>]*datetime="(.*?)"` 或 `<span[^>]*class="date"[^>]*>(.*?)</span>` |
+| 链接类 | `<a[^>]*href="(.*?)"` |
+| 图片类 | `<img[^>]*src="(.*?)"` |
+
+## 完整示例（以新闻列表字段为例）
+
+### 输入
+
+`fields` = `{"title": "新闻标题", "author": "作者名", "date": "发布日期", "url": "文章链接", "thumb": "缩略图地址"}`
+
+### 输入样本
+
+```html
+<li class="news-item">
+  <h3 class="title"><a href="/article/1">Title One</a></h3>
+  <span class="author">Alice</span>
+  <time datetime="2024-01-15">2024-01-15</time>
+  <img src="/thumb/1.jpg" alt="thumb1">
+</li>
+<li class="news-item">
+  <h3 class="title"><a href="/article/2">Title Two</a></h3>
+  <span class="author">Bob</span>
+  <time datetime="2024-01-16">2024-01-16</time>
+  <img src="/thumb/2.jpg" alt="thumb2">
+</li>
+```
+
+### 输出规则
+
+```json
+{
+  "container_regex": "<li[^>]*class=\"news-item\"[^>]*>(.*?)</li>",
+  "fields": {
+    "title": "<h3[^>]*class=\"title\"[^>]*><a[^>]*>(.*?)</a></h3>",
+    "author": "<span[^>]*class=\"author\"[^>]*>(.*?)</span>",
+    "date": "<time[^>]*datetime=\"(.*?)\"",
+    "url": "<a[^>]*href=\"(.*?)\"",
+    "thumb": "<img[^>]*src=\"(.*?)\""
+  }
+}
+```
+
+## 注意事项
+
+- **正则必须匹配清洗后 HTML**（等同 Step 3 中 `HtmlCleaner.clean()` 的输出口径），包括属性中的引号和空格
+- **自我验证**：产出规则后，在输入的样本上跑一遍——`container_regex` 至少匹配 1 条、每个字段至少有一条非空命中。不满足则调整规则
+- `container_regex` 的捕获组数量必须 >= 1
+- 字段正则可能匹配到空值（如空 `<span></span>`），此时提取为空字符串
+- 日期保留原始格式即可，规范化由下游处理
+- 链接和图片如果相对路径，保留原始值
+- **嵌套容器陷阱**：如果容器标签可能自嵌套（如 `<div>` 内嵌 `<div>`），`.*?` 非贪婪会在第一个闭合标签处提前闭合，导致匹配截断。优先选择不会自嵌套的标签（如 `<li>` 罕见包 `<li>`），或对容器用更具体的 class 锚定

package/skills/extract/references/list.schema.json5

@@ -0,0 +1,34 @@
+{
+  // 省略 $schema 字段，避免 bash -c "" 中 $ 展开问题
+  "title": "列表提取格式",
+  "description": "列表页提取（list）输出校验 schema（数组）",
+  "type": "array",
+  "items": {
+    "type": "object",
+    "properties": {
+      "title": {
+        "type": "string",
+        "minLength": 1,
+        "description": "标题，非空"
+      },
+      "author": {
+        "type": "string",
+        "description": "作者，可选"
+      },
+      "date": {
+        "type": "string",
+        "description": "日期，统一 yyyy-mm-dd，可选"
+      },
+      "url": {
+        "type": "string",
+        "description": "文章链接，可选"
+      },
+      "thumb": {
+        "type": "string",
+        "description": "缩略图地址，可选"
+      }
+    },
+    "required": ["title"],
+    "additionalProperties": false
+  }
+}

package/skills/extract/references/list_from_html.md

@@ -0,0 +1,74 @@
+# list_from_html 提取流程
+
+从列表页 HTML 中提取结构化信息（混合方案：本地提取 + 规则 + LLM 规范）。
+
+## 输入
+
+- `source`：完整网页 HTML 源码
+- `url`：页面 URL（可选，相对路径转绝对）
+
+## 输出
+
+符合 `list.schema.json5` 的 JSON 数组：
+
+```json
+[
+  {
+    "title": "标题",
+    "author": "作者",
+    "date": "2026-06-12",
+    "url": "https://example.com/article/123",
+    "thumb": "https://example.com/thumb.jpg"
+  }
+]
+```
+
+字段：`title`（必填，空则跳过本条）、`author` / `date` / `url` / `thumb`（可选，无则留空）。
+
+## 步骤
+
+### Step 1 — 样本截取（本地）
+
+用 `write` 工具将完整 HTML 写入临时文件（如 `extract_list.html`），再用 `write` 工具将 `{"html": "<HTML内容>", "keep_items": 3}` 写入 JSON 输入文件，stdin 重定向交给 Node.js 清洗并截取前 3 条：
+
+```bash
+node '<技能目录>/references/extract-sample.js' < <临时 JSON 输入文件>
+```
+
+输出仅含前 3 条（或更少）的干净 HTML 样本。
+
+### Step 2 — 规则生成（LLM）
+
+先用 `read` 读取 `references/list-rule-gen.md`（HTML 正则生成指导，含编写规则与示例），按其中指导分析 Step 1 输出的样本 HTML，生成提取规则：
+
+- 字段集固定为 `{"title": "新闻标题", "author": "作者名", "date": "发布日期", "url": "文章链接", "thumb": "缩略图地址"}`
+- 输出 `{container_regex, fields: {title, author, date, url, thumb}}` 格式的 JSON 规则，**不写入文件**，直接在后续步骤内联使用
+
+`container_regex` 用于定义每条记录的外层容器边界（如 `<li>...</li>`），Node.js 先用它切分 HTML 为单条容器，再对每条容器内部应用字段正则——避免跨边界匹配。字段正则若有捕获组，提取值取 `group(1)`；建议每个字段正则只含 1 个捕获组。
+
+### Step 3 — 批量提取（本地）
+
+对完整 HTML 用相同清洗逻辑处理后再提取（与 Step 1 清洗口径一致）。用 `write` 工具将输入 JSON 写入临时文件，再 stdin 重定向交给 Node.js：
+
+```bash
+node '<技能目录>/references/extract-regex.js' < <临时输入文件>
+```
+```
+
+输入 JSON：`{"html": "<完整HTML>", "rules": <step2 规则>}`
+
+输出：JSON 数组，每项含 `url`, `date`, `author`, `thumb`, `title` 五个字段（title 为空的条目已移除）。
+
+### Step 4 — LLM 数据规范
+
+将 Step 3 输出的数组交给 LLM 进行数据规范：
+
+- URL 相对路径 → 基于 `{{ url }}` 转为绝对地址
+- 日期统一格式 `yyyy-mm-dd`
+- 作者清洗（去多余空白、特殊字符）
+- **保持条目数量和顺序不变**
+- 输出必须是 JSON 数组（不是对象包裹）
+
+### Step 5 — 验证
+
+检查每项 title 非空，输出规范后的 JSON 数组（供 extract 技能阶段 4 校验）。