helixlife-v5-cli 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helixlife-v5-cli",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Helix（vip.helixlife.cn）精细化浏览器自动化命令行工具。",
   "main": "helix-cli.js",
   "bin": {

package/references/vip.helixlife.cn.site-ops.md

@@ -155,7 +155,7 @@
 | 对话 · 新建会话 | S-09 |
 | 工作站 · 新建任务弹窗 | S-10 |
 | 工作台 · 进入子工作台 | S-11 |
-| 工作台 · 综述全流程（拟定主题→精修） | WB-1 |
+| 工作台 · 综述全流程（拟定主题→精修）；**扩写/润色/校对/翻译等必先定页+run-code 脚本** | WB-1 |
 | 工作台 · SCI 论著全流程 | WB-2 |
 | 工作台 · 国自然基金全流程 | WB-3 |
 | 工作台 · 临床申请书全流程 | WB-4 |
@@ -407,6 +407,76 @@ div.side-menu--item[to='/edu/courses']
 
 **取消全文生成弹窗**：同 dialog 内 `getByRole('button', { name: '取 消' })` 或 `Close`。
 
+**WB-1 · 用户说法与脚本路由（Agent 硬门禁）**
+
+> 用户说「扩写前言」却被做成「添加子级」的根因：**同一动词在不同步骤页含义不同**，且 outline 树按钮默认隐藏（须 hover）。**必须先** `eval location.pathname`，**必须优先** `run-code` 下表脚本，禁止从 snapshot 猜「添加子级」。
+
+**0 · 定页（第一步，不可跳过）**
+
+```bash
+helixlife-v5-cli --raw eval "location.pathname"
+```
+
+**1 · 说法 → 脚本（jova 综述）**
+
+| 当前 `pathname` | 用户说法（示例） | 脚本（工作区 `scripts/`） | Agent 改动的变量 |
+| --- | --- | --- | --- |
+| `…/jova/outline` | `扩写前言`、`扩写 前言`、`精简结论`、`润色 1. 乳腺癌…` | `workbench-jova-outline-regenerate-node.js` | `intent`（动词+章节；支持连写或空格） |
+| `…/jova/proofread` | `校对 前言`、`确认校对`、`AI 改写`、`替换原文` | `workbench-jova-proofread-section.js` | `intent` + `action` |
+| `…/jova/writing` | `扩写 前言`、`翻译 前言`、`润色 摘要`、`降重`、`文献列表` | `workbench-jova-writing-tool.js` | `intent`（**工具与章节间建议空格**：`扩写 前言`） |
+
+执行：`helixlife-v5-cli run-code --filename=scripts/<上表脚本名>`
+
+**2 · outline 页：扩写 ≠ 添加子级（反模式）**
+
+确认提纲页左侧为**提纲树**（非正文）。节点行 `aria-label` 含「操作区」；**移入前**行内按钮不可见。移入后出现：
+
+| 按钮 | 作用 | 用户何时才会要 |
+| --- | --- | --- |
+| **编辑** | 右侧「重新生成」→ 用户需求（扩写/精简/润色等）→ 一键生成 → 替换 → 保存 | **扩写前言、润色某节**等改**节点文字** |
+| 添加同级 | 树结构新增同级节点 | 用户明确说「加同级提纲」 |
+| **添加子级** | 树结构新增子节点 | 用户明确说「加子标题/子条目」 |
+| 删除 | 删节点 | 用户明确说删除 |
+
+**禁止**：将「扩写 / 精简 / 润色 / 改写 + 章节名」映射为「添加子级」或「添加同级」。前者是 **AI 重写该节点正文**（`编辑` 路径），后者只改提纲层级。
+
+`outline-regenerate-node.js` 已实现：定位 `[aria-label*="操作区"]` 且首列文案匹配章节 → hover → **编辑**（不点添加子级）。
+
+**3 · writing 页：右侧 AI 工具栏**
+
+精修页中央为富文本 `textbox`；**右侧竖栏**文案：校对、文风、润色、降重、翻译、改写、**扩写**、缩写、文献列表。用户「扩写前言」在 **writing** 页时：选章节 → 点栏内 **扩写** → 一键生成（走 `writing-tool.js`），**不是** outline 树操作。
+
+| 工具 | 特殊项 |
+| --- | --- |
+| 文风 | `getByRole('textbox', { name: '参考文风' })` **必填** |
+| 文献列表 | 仅打开列表，无一键生成 |
+| 其余 7 项 | 原文内容 + `getByRole('button', { name: '一键生成' })` + 生成结果 + `替换原文` |
+
+**4 · 生成后门禁**
+
+- 脚本返回 `needsReplaceChoice` 或用户未说「替换原文」：**禁止**自动点「替换原文」。
+- proofread 脚本：用户仅说「校对 xxx」时 **禁止**自动「确认校对」。
+- writing · 文风：`参考文风` 为必填；`writing-tool.js` 会用 `referenceStyle` 或选中段落兜底。
+
+**5 · 禁止的低效路径（导致 Agent 数分钟仍失败）**
+
+1. 在 **outline** 页对用户「扩写/润色/精简 + 章节」点「添加子级」或「添加同级」——**永远不对**。
+2. 不 `eval location.pathname` 就在 **proofread / writing** 页找提纲树「编辑」或「添加子级」。
+3. 不用 `run-code --filename=scripts/workbench-jova-*.js`，改用手动 `snapshot` + `click` 拼 hover 才出现的图标按钮。
+4. 同一轮任务内反复 `snapshot` 猜 `e*` ref 定位提纲节点（须脚本内 `aria-label*="操作区"` + 章节文案匹配）。
+
+**6 · 执行命令模板**
+
+```bash
+# ① 定页（不可跳过）
+helixlife-v5-cli --raw eval "location.pathname"
+
+# ② 按上表改脚本内 intent / action 后执行，示例：
+helixlife-v5-cli run-code --filename=scripts/workbench-jova-outline-regenerate-node.js
+```
+
+脚本路径相对于**打开浏览器时的工作区根**（helix-cli 仓库即 `scripts/...`）。
+
 ---
 
 ##### WB-2：SCI 论著工作台（`sci`）

package/scripts/workbench-jova-outline-regenerate-node.js

@@ -0,0 +1,154 @@
+/**
+ * 综述工作台（jova）· 确认提纲页（/workbench/jova/outline）· 节点 AI 重新生成
+ *
+ * 【页面门禁】仅用于 pathname 含 /workbench/jova/outline；writing 页扩写走 writing-tool.js。
+ *
+ * 【禁止误判】用户「扩写前言」= 本脚本（hover → 编辑 → 重新生成），绝不是提纲树「添加子级」。
+ *
+ * 典型场景：用户说「扩写前言」「扩写 前言」「精简结论」「润色 1. xxx」等。
+ *
+ * 流程：
+ *   悬停提纲节点 → 编辑（不点添加子级/添加同级）→ 填写「用户需求」→「一键生成」
+ *   → 等待「生成结果」→「替换原文」→ Popconfirm「确 定」→「保 存」
+ *
+ * 用法（仅需改 intent 一行，或显式指定 nodeTitle / userRequirement）：
+ *   helixlife-v5-cli run-code --filename=scripts/workbench-jova-outline-regenerate-node.js
+ *
+ * intent 解析规则（动词与章节可连写或空格）：
+ *   「扩写前言」「扩写 前言」 → nodeTitle=前言, userRequirement=扩写
+ *   「精简结论」             → nodeTitle=结论, userRequirement=精简
+ *   「润色摘要：」             → nodeTitle=摘要：, userRequirement=润色
+ *   无法解析时整句作为 userRequirement，nodeTitle 回退为「前言」
+ */
+async page => {
+  // ── Agent 通常只改这一行 ──
+  const intent = '扩写前言';
+
+  // 也可显式覆盖（非 null 时优先于 intent 解析）
+  const nodeTitleOverride = null;
+  const userRequirementOverride = null;
+
+  function parseIntent(raw) {
+    const verbs = ['扩写', '精简', '改写', '润色', '重写', '优化'];
+    const text = raw.trim();
+    for (const verb of verbs) {
+      if (text.startsWith(verb)) {
+        const title = text.slice(verb.length).trim();
+        if (title) return { nodeTitle: title, userRequirement: verb };
+      }
+    }
+    return { nodeTitle: '前言', userRequirement: text };
+  }
+
+  const parsed = parseIntent(intent);
+  const nodeTitle = nodeTitleOverride ?? parsed.nodeTitle;
+  const userRequirement = userRequirementOverride ?? parsed.userRequirement;
+
+  const main = page.locator('main');
+
+  if (!page.url().includes('/workbench/jova/outline')) {
+    return {
+      ok: false,
+      reason: '当前不在综述工作台确认提纲页 /workbench/jova/outline',
+      intent,
+      nodeTitle,
+      userRequirement,
+    };
+  }
+
+  async function resetEditingState() {
+    const closeIcons = main.getByRole('img', { name: 'close' });
+    for (let i = 0; i < (await closeIcons.count()); i++) {
+      const icon = closeIcons.nth(i);
+      if (await icon.isVisible()) {
+        await icon.click();
+        await page.waitForTimeout(400);
+      }
+    }
+    const cancelReplace = main.getByRole('button', { name: '取 消' });
+    if ((await cancelReplace.count()) > 0 && (await cancelReplace.first().isVisible())) {
+      await cancelReplace.first().click();
+      await page.waitForTimeout(400);
+    }
+    const saveBtn = main.getByRole('button', { name: '保 存' });
+    if ((await saveBtn.count()) > 0 && (await saveBtn.first().isVisible())) {
+      await saveBtn.first().click();
+      await page.waitForTimeout(400);
+    }
+  }
+
+  function outlineNode(title) {
+    const base = title.replace(/[：:]\s*$/, '');
+    const titleRe = new RegExp(`^${base.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[：:]?$`);
+    return main
+      .locator('[aria-label*="操作区"]')
+      .filter({
+        has: page.locator(':scope > *').first().filter({ hasText: titleRe }),
+      })
+      .first();
+  }
+
+  await resetEditingState();
+
+  const opArea = outlineNode(nodeTitle);
+  if ((await opArea.count()) === 0) {
+    return {
+      ok: false,
+      reason: `未找到提纲节点「${nodeTitle}」`,
+      intent,
+      nodeTitle,
+      userRequirement,
+    };
+  }
+
+  // 1. 悬停 → 编辑
+  await opArea.hover();
+  await page.waitForTimeout(400);
+  await opArea.getByRole('button', { name: '编辑' }).click();
+
+  // 2. 右侧「重新生成」面板
+  const regenTitle = main.getByText('重新生成', { exact: true });
+  await regenTitle.waitFor({ state: 'visible', timeout: 10000 });
+
+  const userReqBox = main.getByRole('textbox', { name: '用户需求' });
+  await userReqBox.waitFor({ state: 'visible', timeout: 5000 });
+  await userReqBox.fill(userRequirement);
+
+  // 3. 一键生成 → 等待「替换原文」可用
+  await main.getByRole('button', { name: '一键生成' }).click();
+  const replaceBtn = main.getByRole('button', { name: '替换原文' });
+  await replaceBtn.waitFor({ state: 'visible', timeout: 120000 });
+  await page.waitForTimeout(800);
+
+  // 4. 替换原文 → Popconfirm「是否将本次生成结果替换原文？」→ 确 定
+  await replaceBtn.click();
+  const confirmPrompt = main.getByText('是否将本次生成结果替换原文？', { exact: true });
+  await confirmPrompt.waitFor({ state: 'visible', timeout: 10000 });
+  await main.getByRole('button', { name: '确 定' }).click();
+  await page.waitForTimeout(800);
+
+  // 5. 左侧内联编辑器「保 存」
+  const saveBtn = main.getByRole('button', { name: '保 存' });
+  await saveBtn.waitFor({ state: 'visible', timeout: 10000 });
+  const inlineEditor = saveBtn.locator('xpath=ancestor::li[1]//textarea | ancestor::li[1]//input[@type="text"] | ancestor::li[1]//*[@role="textbox"]').first();
+  const editorText = (await inlineEditor.inputValue().catch(() => '')) || (await inlineEditor.textContent().catch(() => '')) || '';
+
+  await saveBtn.click();
+  await page.waitForTimeout(1000);
+
+  const panelClosed = !(await regenTitle.isVisible().catch(() => false));
+  const nodePresent = (await outlineNode(nodeTitle).count()) > 0;
+  const contentApplied = editorText.includes(nodeTitle) || editorText.length > 0;
+
+  return {
+    ok: nodePresent && panelClosed && contentApplied,
+    intent,
+    nodeTitle,
+    userRequirement,
+    panelClosed,
+    nodePresent,
+    contentApplied,
+    editorTextLength: editorText.length,
+    url: page.url(),
+  };
+}

package/scripts/workbench-jova-proofread-section.js

@@ -0,0 +1,262 @@
+/**
+ * 综述工作台（jova）· 初稿校对页 · 章节校对 / AI 改写
+ *
+ * Agent 调用约定（严格遵守）：
+ *
+ * 1) 用户只说「校对 <章节>」、未指明操作时：
+ *    action = null → 仅滚动定位 → 悬停 → 点「点击本段进入编辑校对」或「重新编辑」
+ *    → 返回 needsUserChoice，由 Agent 询问用户选「确认校对」或「AI 改写」
+ *    → 禁止自动点「确认校对」
+ *
+ * 2) 用户明确说「确认校对」：action = 'confirm'
+ *
+ * 3) 用户明确说「AI 改写」：
+ *    action = 'ai_rewrite' → 点「AI 改写」→（有额外需求则填写）→「一键重写」→ 等待生成
+ *    → 返回 needsReplaceChoice，提醒用户是否替换原文，禁止自动点「替换原文」
+ *
+ * 4) 用户明确同意替换原文：action = 'replace'
+ *
+ * 用法：
+ *   helixlife-v5-cli run-code --filename=scripts/workbench-jova-proofread-section.js
+ */
+async page => {
+  const intent = '校对 1. 乳腺癌分子分型体系及其分子特征';
+  const action = null; // null | 'confirm' | 'ai_rewrite' | 'replace'
+  const extraRequirement = ''; // 仅 ai_rewrite 时可选
+
+  const main = page.locator('main');
+
+  function parseIntent(raw) {
+    const m = raw.match(/^校对\s*(.+)$/);
+    return { sectionTitle: (m ? m[1] : raw).trim() };
+  }
+
+  const { sectionTitle } = parseIntent(intent);
+
+  if (!page.url().includes('/workbench/jova/proofread')) {
+    return {
+      ok: false,
+      reason: '当前不在综述工作台初稿校对页 /workbench/jova/proofread',
+      intent,
+      sectionTitle,
+    };
+  }
+
+  async function dismissPopconfirmOnly() {
+    const cancel = main.getByRole('button', { name: '取 消' });
+    if ((await cancel.count()) > 0 && (await cancel.first().isVisible())) {
+      await cancel.first().click();
+      await page.waitForTimeout(300);
+    }
+  }
+
+  function sectionHeading(title) {
+    return main.getByRole('heading', { name: title, exact: true }).first();
+  }
+
+  function sectionBlock(title) {
+    return sectionHeading(title).locator('xpath=ancestor::div[contains(@class,"group")][1]');
+  }
+
+  async function navigateToSection(title) {
+    const toc = main.locator('[class*="cursor-pointer"]').getByText(title, { exact: true });
+    if ((await toc.count()) > 0) {
+      await toc.first().click({ timeout: 3000 }).catch(() => {});
+      await page.waitForTimeout(500);
+    }
+    const heading = sectionHeading(title);
+    if ((await heading.count()) === 0) {
+      return { ok: false, reason: `未找到章节「${title}」` };
+    }
+    await heading.scrollIntoViewIfNeeded();
+    await page.waitForTimeout(400);
+    return { ok: true };
+  }
+
+  async function detectProofreadStatus(block) {
+    const pending = block.getByText('请校对本段内容', { exact: true });
+    const done = block.getByText('本段完成校对', { exact: true });
+    if ((await pending.count()) > 0) return 'pending';
+    if ((await done.count()) > 0) return 'done';
+    return 'completed_or_editing';
+  }
+
+  async function clickEnterEdit(block) {
+    const enterLabels = [
+      '点击本段进入编辑校对',
+      '点击本段进行校对',
+      '点击本段进行编辑校对',
+    ];
+    for (const label of enterLabels) {
+      const btn = block.getByText(label, { exact: true });
+      if ((await btn.count()) > 0 && (await btn.first().isVisible())) {
+        await btn.first().click();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  async function openSectionEdit(title) {
+    const nav = await navigateToSection(title);
+    if (!nav.ok) return nav;
+
+    const block = sectionBlock(title);
+
+    if ((await block.getByRole('button', { name: '确认校对' }).count()) > 0) {
+      return { ok: true, proofreadStatus: 'already_editing' };
+    }
+
+    const proofreadStatus = await detectProofreadStatus(block);
+
+    if (proofreadStatus === 'pending') {
+      await block.getByText('请校对本段内容', { exact: true }).first().hover();
+      await page.waitForTimeout(600);
+      if (!(await clickEnterEdit(block))) {
+        return { ok: false, reason: '未找到「点击本段进入编辑校对」入口', proofreadStatus };
+      }
+    } else if (proofreadStatus === 'done') {
+      await block.getByText('本段完成校对', { exact: true }).first().hover();
+      await page.waitForTimeout(600);
+      const reEdit = block.getByText('重新编辑', { exact: true });
+      if ((await reEdit.count()) === 0 || !(await reEdit.first().isVisible())) {
+        return { ok: false, reason: '未找到「重新编辑」入口', proofreadStatus };
+      }
+      await reEdit.first().click();
+    } else {
+      await block.hover();
+      await page.waitForTimeout(600);
+      const reEdit = block.getByText('重新编辑', { exact: true });
+      if ((await reEdit.count()) > 0 && (await reEdit.first().isVisible())) {
+        await reEdit.first().click();
+      } else if (await clickEnterEdit(block)) {
+        // ok
+      } else {
+        return { ok: false, reason: '无法进入编辑模式（未找到入口）', proofreadStatus };
+      }
+    }
+
+    await block.getByRole('button', { name: '确认校对' }).waitFor({ state: 'visible', timeout: 10000 });
+    await page.waitForTimeout(400);
+    return { ok: true, proofreadStatus };
+  }
+
+  async function confirmProofread(title) {
+    const block = sectionBlock(title);
+    await block.getByRole('button', { name: '确认校对' }).click();
+    await page.waitForTimeout(1000);
+    return { ok: true };
+  }
+
+  async function waitReplaceReady(timeoutMs = 120000) {
+    const replaceBtn = main.getByRole('button', { name: '替换原文' });
+    await replaceBtn.waitFor({ state: 'visible', timeout: timeoutMs });
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (await replaceBtn.isEnabled()) return replaceBtn;
+      await page.waitForTimeout(1000);
+    }
+    throw new Error('等待「替换原文」可点击超时');
+  }
+
+  async function aiRewriteGenerate(title, extra) {
+    const block = sectionBlock(title);
+    await block.getByRole('button', { name: /AI\s*改写/ }).click();
+    await main.getByText('原文内容', { exact: true }).waitFor({ state: 'visible', timeout: 10000 });
+
+    if (extra) {
+      const extraBox = main.getByRole('textbox', { name: '额外需求' });
+      if ((await extraBox.count()) > 0) await extraBox.fill(extra);
+    }
+
+    await main.getByRole('button', { name: '一键重写' }).click();
+    await waitReplaceReady();
+
+    return { ok: true, generated: true, replaceReady: true };
+  }
+
+  async function aiRewriteReplace() {
+    const replaceBtn = main.getByRole('button', { name: '替换原文' });
+    await replaceBtn.click();
+    await main.getByText('是否将本次生成结果替换原文？', { exact: true }).waitFor({ state: 'visible', timeout: 10000 });
+    await main.getByRole('button', { name: '确 定' }).click();
+    await page.waitForTimeout(1000);
+    return { ok: true, replaced: true };
+  }
+
+  await dismissPopconfirmOnly();
+
+  const needOpenEdit = action === null || action === '' || action === undefined || action === 'confirm' || action === 'ai_rewrite';
+  let opened = { ok: true, proofreadStatus: 'already_editing' };
+
+  if (needOpenEdit && action !== 'replace') {
+    opened = await openSectionEdit(sectionTitle);
+    if (!opened.ok) return { ok: false, intent, sectionTitle, ...opened };
+  }
+
+  if (action === null || action === undefined || action === '') {
+    return {
+      ok: true,
+      needsUserChoice: true,
+      intent,
+      sectionTitle,
+      proofreadStatus: opened.proofreadStatus,
+      availableActions: ['confirm', 'ai_rewrite'],
+      message: '已进入该段编辑模式。请选择：① 确认校对（直接完成本段校对）② AI 改写（AI 重新生成内容）',
+      url: page.url(),
+    };
+  }
+
+  if (action === 'confirm') {
+    await confirmProofread(sectionTitle);
+    const block = sectionBlock(sectionTitle);
+    const afterStatus = await detectProofreadStatus(block);
+    return {
+      ok: true,
+      intent,
+      sectionTitle,
+      action,
+      proofreadStatusBefore: opened.proofreadStatus,
+      proofreadStatusAfter: afterStatus,
+      message: '本段已确认校对完成。',
+      url: page.url(),
+    };
+  }
+
+  if (action === 'ai_rewrite') {
+    const generated = await aiRewriteGenerate(sectionTitle, extraRequirement);
+    return {
+      ok: generated.ok,
+      intent,
+      sectionTitle,
+      action,
+      extraRequirement: extraRequirement || null,
+      generated: true,
+      needsReplaceChoice: true,
+      availableActions: ['replace'],
+      message:
+        'AI 改写结果已生成。请在右侧查看「生成结果」，确认无误后告知我「替换原文」以应用；若不满意可直接在页面调整或重新生成。',
+      url: page.url(),
+    };
+  }
+
+  if (action === 'replace') {
+    const replaced = await aiRewriteReplace();
+    return {
+      ok: replaced.ok,
+      intent,
+      sectionTitle,
+      action,
+      replaced: true,
+      message: '已替换原文。如需完成本段校对，请明确告知「确认校对」。',
+      url: page.url(),
+    };
+  }
+
+  return {
+    ok: false,
+    reason: `未知 action「${action}」，应为 null | confirm | ai_rewrite | replace`,
+    intent,
+    sectionTitle,
+  };
+}

package/scripts/workbench-jova-writing-tool.js

@@ -0,0 +1,310 @@
+/**
+ * 综述工作台（jova）· 初稿精修页（/workbench/jova/writing）· 右侧 AI 工具
+ *
+ * 【页面门禁】仅用于 pathname 含 /workbench/jova/writing；outline 页「扩写前言」走 outline-regenerate-node.js。
+ *
+ * 支持工具（右侧栏）：校对、文风、润色、降重、翻译、改写、扩写、缩写、文献列表
+ *
+ * Agent 调用约定（严格遵守）：
+ *
+ * 1) 用户说「<工具> <章节>」、未指明后续操作时：
+ *    action = null → 选中章节 → 打开工具 →（文风填参考文风）→ 一键生成
+ *    → 返回 needsReplaceChoice，禁止自动点「替换原文」
+ *    例外：文献列表仅打开列表面板，无生成步骤
+ *
+ * 2) 用户明确说「替换原文」：action = 'replace'
+ *
+ * 3) 自检全部工具：probeAll = true（开发/验收用，依次跑 9 项，不替换原文）
+ *
+ * intent 示例：
+ *   「翻译 前言」  → tool=翻译, sectionTitle=前言
+ *   「文风 摘要」  → tool=文风, sectionTitle=摘要（须 referenceStyle 或自动兜底）
+ *   「文献列表」  → tool=文献列表, sectionTitle 可空（选中全文参考文献）
+ *
+ * 用法：
+ *   helixlife-v5-cli run-code --filename=scripts/workbench-jova-writing-tool.js
+ */
+async page => {
+  const intent = '翻译 前言';
+  const action = null; // null | 'replace'
+  const extraRequirement = ''; // 额外需求（可选）
+  const referenceStyle = ''; // 文风专用；空则从选中段落截取兜底
+  const probeAll = false; // true = 验收 9 个工具（用「关键词」短段）
+
+  const TOOLS = ['校对', '文风', '润色', '降重', '翻译', '改写', '扩写', '缩写', '文献列表'];
+
+  const main = page.locator('main');
+
+  if (!page.url().includes('/workbench/jova/writing')) {
+    return { ok: false, reason: '当前不在初稿精修页 /workbench/jova/writing', intent };
+  }
+
+  function parseIntent(raw) {
+    const text = raw.trim();
+    for (const tool of TOOLS) {
+      if (text === tool || text.startsWith(`${tool} `) || text.startsWith(tool)) {
+        const sectionTitle = text.slice(tool.length).trim();
+        return { tool, sectionTitle: sectionTitle || null };
+      }
+    }
+    return { tool: null, sectionTitle: text || null };
+  }
+
+  async function closePanel() {
+    const closeIcons = main.getByRole('img', { name: 'close' });
+    for (let i = 0; i < (await closeIcons.count()); i++) {
+      const icon = closeIcons.nth(i);
+      if (await icon.isVisible().catch(() => false)) {
+        await icon.click();
+        await page.waitForTimeout(400);
+      }
+    }
+    const cancel = main.getByRole('button', { name: '取 消' });
+    if ((await cancel.count()) > 0 && (await cancel.first().isVisible().catch(() => false))) {
+      await cancel.first().click();
+      await page.waitForTimeout(300);
+    }
+  }
+
+  async function navigateAndSelectSection(title) {
+    if (title) {
+      const toc = main.locator('[class*="cursor-pointer"]').getByText(title, { exact: true });
+      if ((await toc.count()) > 0) {
+        await toc.first().click({ timeout: 5000 }).catch(() => {});
+        await page.waitForTimeout(500);
+      }
+      const heading = main.getByRole('heading', { name: title, exact: true }).first();
+      if ((await heading.count()) > 0) {
+        await heading.scrollIntoViewIfNeeded();
+        await page.waitForTimeout(300);
+      }
+    }
+
+    const selected = await page.evaluate(t => {
+      const editor = document.querySelector('main [role="textbox"]');
+      if (!editor) return { ok: false, reason: '未找到富文本编辑器' };
+
+      if (!t) {
+        const body = editor.textContent?.trim() || '';
+        const range = document.createRange();
+        range.selectNodeContents(editor);
+        const sel = window.getSelection();
+        sel?.removeAllRanges();
+        sel?.addRange(range);
+        return { ok: true, textLength: body.length, preview: body.slice(0, 80), wholeDoc: true };
+      }
+
+      const headings = [...editor.querySelectorAll('h1,h2,h3,h4,h5,h6')];
+      const idx = headings.findIndex(h => h.textContent?.trim() === t);
+      if (idx < 0) return { ok: false, reason: `编辑器内未找到章节「${t}」` };
+
+      const start = headings[idx];
+      const level = parseInt(start.tagName[1], 10);
+      let end = null;
+      for (let i = idx + 1; i < headings.length; i++) {
+        if (parseInt(headings[i].tagName[1], 10) <= level) {
+          end = headings[i];
+          break;
+        }
+      }
+
+      const range = document.createRange();
+      range.setStartBefore(start);
+      range.setEndBefore(end || editor.lastChild || editor);
+      const sel = window.getSelection();
+      sel?.removeAllRanges();
+      sel?.addRange(range);
+
+      const text = range.toString();
+      return {
+        ok: true,
+        textLength: text.length,
+        preview: text.slice(0, 80),
+        sectionText: text.slice(0, 500),
+      };
+    }, title);
+
+    await page.waitForTimeout(400);
+    return selected;
+  }
+
+  async function waitReplaceReady(timeoutMs = 120000) {
+    const replaceBtn = main.getByRole('button', { name: '替换原文' });
+    await replaceBtn.waitFor({ state: 'visible', timeout: timeoutMs });
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (await replaceBtn.isEnabled()) return true;
+      await page.waitForTimeout(1000);
+    }
+    return false;
+  }
+
+  async function fillExtraIfNeeded() {
+    if (!extraRequirement) return;
+    const box = main.getByRole('textbox', { name: '额外需求' });
+    if ((await box.count()) > 0 && (await box.first().isVisible().catch(() => false))) {
+      await box.first().fill(extraRequirement);
+    }
+  }
+
+  async function fillReferenceStyleIfNeeded(selected) {
+    const refBox = main.getByRole('textbox', { name: '参考文风' });
+    if ((await refBox.count()) === 0 || !(await refBox.first().isVisible().catch(() => false))) {
+      return { filled: false };
+    }
+    const ref =
+      referenceStyle ||
+      (selected.sectionText
+        ? selected.sectionText.slice(0, 200)
+        : 'This review synthesizes molecular subtyping and precision therapeutic strategies in breast cancer.');
+    await refBox.first().fill(ref);
+    return { filled: true, referenceStyle: ref.slice(0, 80) };
+  }
+
+  async function pickTranslationLanguage() {
+    for (const label of ['English', '英文']) {
+      const opt = main.getByText(label, { exact: true });
+      if ((await opt.count()) > 0 && (await opt.first().isVisible().catch(() => false))) {
+        await opt.first().click();
+        await page.waitForTimeout(300);
+        return label;
+      }
+    }
+    return null;
+  }
+
+  async function openToolAndGenerate(tool, sectionTitle) {
+    await closePanel();
+
+    const selected = await navigateAndSelectSection(sectionTitle);
+    if (!selected.ok) return { ok: false, tool, sectionTitle, ...selected };
+
+    const toolBtn = main.getByText(tool, { exact: true });
+    if ((await toolBtn.count()) === 0) {
+      return { ok: false, tool, sectionTitle, reason: `未找到工具「${tool}」` };
+    }
+    await toolBtn.first().click();
+    await page.waitForTimeout(800);
+
+    if (tool === '文献列表') {
+      const panel = main.getByText('文献列表', { exact: true });
+      const visible = (await panel.count()) > 0;
+      const refLinks = await main.locator('a[href*="pubmed"], a[href*="doi"], a[href*="clmd"]').count();
+      return {
+        ok: visible,
+        tool,
+        sectionTitle,
+        selected,
+        mode: 'list',
+        refLinkCount: refLinks,
+        message: '已打开文献列表面板。',
+      };
+    }
+
+    await main.getByText('原文内容', { exact: true }).waitFor({ state: 'visible', timeout: 10000 }).catch(() => {});
+
+    let refStyle = null;
+    if (tool === '文风') {
+      refStyle = await fillReferenceStyleIfNeeded(selected);
+    }
+    if (tool === '翻译') {
+      await pickTranslationLanguage();
+    }
+    await fillExtraIfNeeded();
+
+    const genBtn = main.getByRole('button', { name: '一键生成' });
+    if ((await genBtn.count()) === 0 || !(await genBtn.first().isVisible().catch(() => false))) {
+      return { ok: false, tool, sectionTitle, reason: '未找到「一键生成」按钮' };
+    }
+    await genBtn.first().click();
+
+    const replaceReady = await waitReplaceReady();
+    return {
+      ok: replaceReady,
+      tool,
+      sectionTitle,
+      selected,
+      refStyle,
+      replaceReady,
+      mode: 'generate',
+    };
+  }
+
+  async function replaceGenerated() {
+    const replaceBtn = main.getByRole('button', { name: '替换原文' });
+    if ((await replaceBtn.count()) === 0 || !(await replaceBtn.isEnabled().catch(() => false))) {
+      return { ok: false, reason: '「替换原文」不可用' };
+    }
+    await replaceBtn.click();
+    await main.getByText('是否将本次生成结果替换原文？', { exact: true }).waitFor({ state: 'visible', timeout: 10000 });
+    await main.getByRole('button', { name: '确 定' }).click();
+    await page.waitForTimeout(1000);
+    return { ok: true, replaced: true };
+  }
+
+  if (probeAll) {
+    const probeSection = '关键词';
+    const results = [];
+    for (const tool of TOOLS) {
+      const r = await openToolAndGenerate(tool, probeSection);
+      results.push({ tool, ok: r.ok, mode: r.mode, replaceReady: r.replaceReady, reason: r.reason });
+    }
+    return {
+      ok: results.every(r => r.ok),
+      probeAll: true,
+      probeSection,
+      results,
+      url: page.url(),
+    };
+  }
+
+  const { tool, sectionTitle } = parseIntent(intent);
+  if (!tool || !TOOLS.includes(tool)) {
+    return {
+      ok: false,
+      intent,
+      reason: `无法解析工具，支持：${TOOLS.join('、')}`,
+    };
+  }
+  if (tool !== '文献列表' && !sectionTitle) {
+    return { ok: false, intent, reason: '请指定章节标题，如「翻译 前言」' };
+  }
+
+  if (action === 'replace') {
+    const replaced = await replaceGenerated();
+    return {
+      ok: replaced.ok,
+      intent,
+      tool,
+      sectionTitle,
+      action,
+      ...replaced,
+      message: replaced.ok ? '已替换原文。' : replaced.reason,
+      url: page.url(),
+    };
+  }
+
+  const generated = await openToolAndGenerate(tool, sectionTitle);
+
+  if (generated.mode === 'list') {
+    return { ok: generated.ok, intent, tool, sectionTitle, action: null, ...generated, url: page.url() };
+  }
+
+  if (!generated.ok) {
+    return { ok: false, intent, tool, sectionTitle, action: null, ...generated, url: page.url() };
+  }
+
+  return {
+    ok: true,
+    intent,
+    tool,
+    sectionTitle,
+    action: null,
+    needsReplaceChoice: true,
+    availableActions: ['replace'],
+    replaceReady: generated.replaceReady,
+    selected: generated.selected,
+    message: `「${tool}」已生成结果，请在右侧查看；确认后告知我「替换原文」以应用。`,
+    url: page.url(),
+  };
+}